Lesson 02: Data Types and Variables

[signed | unsigned] char <variable_name>;

Character data types are used to store a single character value enclosed in single quotes. Use the type specifier char to define a character data type. Variables of type char are 1 byte in length.

A char can be signed, unsigned, or unspecified. By default, a signed char is assumed.

Objects declared as characters (char) are large enough to store any member of the basic ASCII character set.

[signed | unsigned] [long long | long | short] int <variable_name>;

Use the int type specifier to define an integer data type. Variables of type int can be signed (default) or unsigned.

long can define a long integer (32-bit).

long long is introduced by ISO C99 and defines a 64-bit integer.

Exact-width integer types

The C99 expands integers to exact-width integer types. This allows programmers to write more portable code by specifying the size for integer types. The exact-width integers are defined in stdint.h (for C/C++) and cstdint (for C++). To use these integer types, the header files must be included in the source file.

The exact-width integer types are of the form intN_t and uintN_t. Both types must be represented by exactly N bits with no padding bits. intN_t must be encoded as a two's complement signed integer and uintN_t as an unsigned integer.

float <variable_name>;

Use the float type specifier to define an identifier to be a floating-point data type.

[long] double <variable_name>;

Use the double type specifier to define an identifier to be a floating-point data type. The optional modifier long extends the accuracy of the floating-point value.

bool <variable_name>;

Use bool and the literals false and true to perform Boolean logic tests.

The bool keyword represents a type that can take only the value false or true. The keywords false and true are Boolean literals with predefined values. false is numerically zero and true is numerically one. These Boolean literals are r-values; you cannot make an assignment to them.

You can convert an rvalue that is of type bool to an rvalue that is int type. The numerical conversion sets false to zero and true becomes one.

A zero value, null pointer value, or null member pointer value is converted to false. Any other value is converted to true.

In C, you have to include the stdbool.h file to the source file.

#include <stdbool.h>

Valueless

The void type specifies that valueless is available. It is used in the following situations:

• The Function returns as void
  There are various functions in C which do not return any value or you can say they return void. A function with no return value has the return type as void. For example:
  void exit(int exit_code);
• Function arguments as void
  There are various functions in C which do not accept any parameter. A function with no parameter can accept a void. For example:
  int rand(void);
• Pointers to void
  A pointer of type void * represents the address of an object, but not its type. For example, a memory allocation function
  void *malloc(size_t size);
  returns a pointer to void which can be cast to any data type.

Compound Types

A compound type is a type that is defined in terms of another type. There are two compound types in C/C++ — pointers, and references.

int      x = 5;     // normal integer
int     *ip = &x;   // pointer to integer x
double  *dp;        // pointer to a double
float*   fp;        // pointer to a float
char    *pch;       // pointer to a character

int   x = 5;    // normal integer
int  &y = x;    // y is a reference to x
int&  z = y;    // z is also reference to x

Constants

Constants are fixed values that never change during the execution of a program. Following are the various types of constants:

For example, to declare a value that does not change like the classic circle constant PI, there are two ways to declare this constant:

• By using the const keyword in a variable declaration which will reserve a storage memory

  const double PI = 3.14;

• By using the #define preprocessor directive which doesn't use memory for storage and without putting a semicolon character at the end of that statement

  #define PI 3.14

Identifiers

Variable, function, and user-defined type names are all examples of identifiers. In C/C++, identifiers follow certain rules:

• Uses sequences of letters (a ~ z, A ~ Z), digits (0 ~ 9), and underscores (_) from one to several characters in length.
• A name can not begin with a digit.
• Identifiers may be of any length. The significant characters depend on the version of C and the compiler.
• No spaces are allowed in the name.
• It cannot be a C/C++ reserved word (keyword), and reserved words for the compiler.
• C/C++ is a "case sensitive" language, meaning that "AGE" and "age" are different identifiers.

Variables

A variable is an identifier that is pointed to a memory location to store value(s). Different types of variables require different amounts of memory and have some specific set of operations that can be applied to them.

Naming Conventions

C/C++ programmers generally agree on the following conventions for naming variables:

• Begin variable names with lowercase letters for the local variables.
  Ex: sum; result; average;
• Begin variable names with uppercase letters for the global variables.
  Ex. Total;
• Use all uppercase letters for constant variables or macro names, which are defined by the #define statement.
  Ex. #define PI 3.14; const float TAX_RATE = 0.95;
• Using meaningful identifiers
• Separate "words" within identifiers with underscores or mixed upper and lower case.
  Ex: surface_area, surface_Area, surfaceArea.

The following example shows some simple variable declarations with some descriptions for each. The example also shows how the compiler uses type information to allow or disallow certain subsequent operations on the variable.

int result = 0; // Declare and initialize an integer.
double coefficient = 10.8; // Declare and initialize a floating point value.
auto name = "Lady G."; // (C++) Declare a variable and let the compiler deduce the type.
auto address; // (C++) error. The compiler cannot deduce a type without an initializing value.
age = 12; // error. The variable declaration must specify a type or use auto!
result = "Kenny G."; // error. Can't assign text to an int.
string result = "zero"; // (C++) error. Can't redefine a variable with a new type.
int maxValue; // Not recommended! maxValue contains garbage bits until it is initialized.

Local Variables

Variables declared in functions or blocks are called local variables. They are also called auto variables and are only used inside the function or block in which they are declared. The lifetime of Their lifetime begins when the function or block is entered and ends when it is exited. Local variables are typically used to store temporary values that are specific to the function or block in which they are declared. begins when the function or block is entered and ends when it is exited. Local variables are typically used to store temporary values that are specific to the function or block in which they are declared.

• Local variables are declared inside the functions, blocks ({ }), or statements.
• The local variables exist until the block of the function is under execution. When the program exits the block, all the non-static local variables will be destroyed automatically.
• Local variables are stored in the stack segment of the memory, and the default values are unknown (random values). Therefore, you may need to set an initial value for the local variables.
• Local variable names begin with a lowercase letter.

Advantages of using local variables

• The use of local variables offers a guarantee that the values of variables will remain intact while the function is running.
• If several functions change a single global variable, the result may be unpredictable. But declaring it as a local variable solves this issue as each function will create its own instance of the local variable.
• You can give local variables the same name in different functions and blocks because they are only recognized by the function and block they are declared in.
• Local variables are deleted as soon as any function is over and release the memory space that it occupies.

Disadvantages of using local variables

• Common data is required to pass repeatedly as data sharing is not possible between modules.
• They have a very limited scope.

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <stdbool.h>
int main()
{
    // local variables
    auto int    a;          // use 'auto' to define local variable
    int         b = 20, c;  // 'auto' can be ignored

    // actual initialization
    a = 10;
    c = a + b;

    printf("C = %d \n", c);
    return 0;
}

int max(int x, int y)               // x and y enter scope here
{
    // assign the greater of x or y to max
    int max;

    max = (x > y) ? x : y;          // max enters scope here
    return max;
}   // x, y, and max leave scope, and they will be destroyed here

int i;
for (i = 0; i < 5; ++i) {
    int n = 0;
    printf("%d ", ++n);    // prints 1 1 1 1 1 - the previous value is lost
}

int i = 20;                      // first i enters scope and is create here

for (int i = 0; i < 3; i++) {    // second i enters for-loop scope and is create here
    printf("i = %d \n", i);
}                                // second i goes out of scope and is destroyed here
printf("i = %d \n", i);

int main()              // Outer block
{
    int     x = 5;                  // first x enters scope and is create here

    {                               // nested block (second layer block)
        int  x = 10;                // second x enters second scope and is create here
        printf("x: %d \n", x);

        {                           // nested block (third layer block)
            int  x = 15;            // third x enters second scope and is create here
            printf("x: %d \n", x);
        }                           // third x goes out of scope and is destroyed here
    }                               // second x goes out of scope and is destroyed here

    printf("x: %d \n", x);
}                                   // first x goes out of scope and is destroyed here

Global Variables

Global variables are declared outside of any function or block and have global scope, meaning they are accessible from anywhere in the program. Their lifetime extends throughout the entire execution of the program. Global variables are typically used to store shared data that needs to be accessed by multiple functions.

• Global variables are usually declared at the top of the program outside all functions and blocks.
• Global variables are available throughout the lift-time of a program.
• Global variables can be accessed from any portion of the program.
• Global variable names begin with an uppercase letter.

The reasons to use global variables are:

• The primary use of global variables is in programs in which many functions must access the value of the same variable.
• Although the use of global variables can reduce the number of arguments that need to be passed to a function.

Advantages of using Global variables

• You can access the global variable from all the functions or modules in a program.
• You are only required to declare a global variable single time outside the modules.
• It is ideally used for storing "constants" as it helps you keep consistency.
• A Global variable is useful when multiple functions are accessing the same data.

Disadvantages of using Global Variables

• Too many variables are declared as global, and then they remain in the memory till program execution is completed. This can cause out-of-memory issues.
• Data can be modified by any function. Any statement written in the program can change the value of the global variable. This may give unpredictable results in multi-tasking environments.
• If global variables are discontinued due to code refactoring, you will need to change all the modules where they are called.

int     W;      // No explicit initializer (zero-initialized by default)
int     X = 0;  // zero initialized
int     Y = 1;  // initialized with value;

#include <stdio.h>

// global variable declaration
int x = 20;

int main () {

    // local variable declaration
    int x = 10;

    printf ("x = %d \n",  x);

    return 0;
}

#include <stdio.h>
int     x = 100;            // global variable with initialization value

int main()
{
    int     x = 10;         // local variable

    // access global variable x
    {
        extern int  x;      // declare an external variable x (pointed to the global variable x)
        printf("global x = %d \n", x);
    }
    printf("local  x = %d", x);
}

#include <stdio.h>
int     x = 100;                        // global variable with initialization value

int main()
{
    int     x = 10;                     // local variable

    printf("global x = %d \n", ::x);    // access global variable x (C++ only)
    
    printf("local  x = %d", x);         // access local variable x
}

Exercises

1. What is the value of j in the following program?

   int i = 64;
   int main()
   {
   int i = 128;
   int j = i;
   }

2. Is the following program legal? If so, what values are printed?

   int i = 50, sum = 0;
   for (int i = 0; i != 10; i++)
   sum += i;
   printf("i: %d, sum: %d \n", i, sum);

Implicit Type Conversion

It is also known as automatic type conversion.

• Done by the compiler on its own, without any external trigger from the user.
• Generally takes place when in an expression more than one data type is present. In such conditions, type conversion takes place to avoid loss of data.
• All the data types of the variables are upgraded to the data type of the variable with the largest data type:

  bool ⇒ char ⇒ short int ⇒ int ⇒ unsigned int ⇒ long ⇒ unsigned long ⇒ long long ⇒ float ⇒ double ⇒ long double

• It is possible for implicit conversions to lose information, signs can be lost (when signed is implicitly converted to unsigned), and overflow can occur (when long long is implicitly converted to float).

In the following situations, the compiler will perform automatic type conversion:

• A particular expression contains more than one data type. The compiler will follow the above rules to convert the type.
• When a value of one type is assigned to a variable of a different type. The compiler will convert the right-hand side type into the target data type (left-hand side).
• When a value is passed as an argument to a function with a different type. Or when a type is returned from a function.

For example:

#include <stdio.h>

int main()
{
    int     i  = 3;
    float   f  = 3.3;
    char    ch = 'A';      // ASCII 'A' is 65 in decimal
    int     x;

    x = (i * 2.5) + f + ch;
    printf("int x = %d \n", x );
    
}

The compiler will perform the following steps to convert the type.


The result of x is:

int x = 75

Explicit Type Conversion

This process is also called type casting and it is user-defined. Here the user can typecast the result to make it of a particular data type. In C++, it can be done in two ways:

Converting by Assignment (C/C++)

Converting by Assignment

This is done by explicitly defining the required type in front of the expression in parenthesis. This can also be considered as forceful casting.

(dataType) expression

Where dataType is the standard C language data type and it indicates the data type to which the final result is converted. An expression can be a constant, a variable, or an actual expression.

#include <stdio.h>

int main()
{
    int    y;

    y = (int) 3.5 * 2;
    printf("int y = %d \n", y );

    return 0;
}

The compiler will perform the following steps to convert the type.


The result of x is:

int y = 6

Conversion using Cast Operator (C++ only)

const

Objects of type const cannot be changed by your program during execution. Also, an object pointed to by a const pointer cannot be modified. The compiler is free to place variables of this type into read-only memory (ROM). A const variable will receive its value either from an explicit initialization or by some hardware-dependent means. For example,

const int a = 10;

will create an integer called a with a value of 10 that may not be modified by your program.

const with pointers

• A const to the LEFT of * indicates that the object pointed by the pointer is a const object.
• A const to the RIGHT of * indicates that the pointer is a const pointer.

The following table summarizes what types of pointers you can create with const:

What is the static modifier?

The static modifier is a keyword in C and C++ that can be applied to variables, functions, and classes. It has different effects depending on the context in which it is used.

static void printMessage() {
std::cout << "Static function message" << std::endl;
}
int main() {
    printMessage(); // Calling static function from main()
    return 0;
}

class Counter {
public:
    static int count; // Static class member variable
    void increment() {
        count++;
    }
};
int Counter::count = 0; // Initialization outside class declaration
int main() {
    Counter::count++; // Accessing static class member using class name
    std::cout << Counter::count << std::endl;
    return 0;
}

Benefits of Using Static Modifiers

Static modifiers provide several benefits for programmers:

• Data Persistence: Static variables retain their value throughout the program's execution, allowing them to store shared data that persists across function calls.
• Controlled Visibility: Static functions and class members are only visible within their respective files or classes, preventing unintended access and promoting encapsulation.
• Efficient Memory Usage: Static variables are initialized only once, reducing memory overhead compared to repeatedly initializing local variables.

Considerations when Using Static Modifiers

When using static modifiers, it is important to consider the following points:

• Overuse: Avoid overusing static modifiers, as they can make code less modular and difficult to maintain.
• Thread Safety: Static variables shared among multiple threads require synchronization mechanisms to prevent data races, where multiple threads attempt to access and modify the same variable simultaneously, leading to unpredictable or corrupted data. Mutexes, semaphores, and other synchronization primitives are essential for ensuring thread-safe access to static variables.
• Initial Values: Static variables must be initialized explicitly to establish their starting values. Default initialization based on data types may not always align with the expected behavior, leading to potential issues. Explicit initialization ensures consistent and predictable variable states.
• Global vs. Local Static Variables: Global static variables have external linkage, allowing access from anywhere in the program, while local static variables have internal linkage, limiting access to within the file where they are declared. Global static variables are useful for shared data across modules, while local static variables are preferred for maintaining state within a function or block.
• Static Functions and Namespace Pollution: Static functions have internal linkage and cannot be overloaded, affecting their visibility and redefinition capabilities. Excessive use of static functions outside of classes can contribute to namespace pollution, making it challenging to identify and distinguish specific functions.
• Static Class Members and Object Independence: Static class members are shared among all objects of the class, providing a central repository for shared data or utility functions. This promotes encapsulation and reduces code redundancy.
• Memory Management: Static variables, especially static class members, require careful memory management to prevent memory leaks. If not properly deallocated, they can lead to memory consumption issues.
• Performance: Static variables can enhance performance when used for caching frequently accessed data or reducing repeated memory allocations. However, overreliance can lead to less efficient code and hinder optimization opportunities.
• Testing and Debugging: Static variables can make it more difficult to test and debug code, as they can interfere with the expected behavior of functions and classes. It is important to consider the impact of static variables on testing and debugging when designing and implementing code.
• Documentation and Communication: Static modifiers can make code less self-documenting, as they can affect the visibility and linkage of variables and functions. It is important to provide clear and concise documentation to explain the purpose and usage of static members when sharing code with others.

In summary, static modifiers are powerful tools that can be used to manage variable storage duration, function visibility, and class member accessibility in C/C++ programming. However, it is important to use them judiciously, considering their potential benefits and drawbacks to writing maintainable, efficient, and secure code.

volatile: Ensuring Data Integrity in Multithreaded and Hardware-Influenced Environments

The volatile modifier plays a crucial role in C/C++ programming, particularly in multithreaded environments and when dealing with hardware interactions. It informs the compiler that a variable's value can be altered by external factors beyond the program's direct control, such as hardware devices, concurrent threads, or interrupt handlers.

When a variable is declared as volatile, the compiler is instructed to refrain from optimizing its usage. This means that the compiler cannot assume the variable's value to remain constant between access points. Instead, it must always retrieve the latest value from memory whenever the variable is referenced.

This precaution is essential because external factors might modify the variable's value without the program's explicit knowledge. In a multithreaded setting, multiple threads may simultaneously access and alter shared data, potentially leading to inconsistencies if the compiler optimizes variable access.

Similarly, when interacting with hardware devices, their registers or memory locations can be updated by external processes or interrupts. Without the volatile modifier, the compiler might use a cached value, leading to erroneous behavior.

By employing the volatile modifier, programmers ensure that the code always reflects the current value of the variable, preventing potential conflicts and ensuring data integrity in multithreaded and hardware-influenced environments.

A variable should be declared volatile whenever its value could change unexpectedly. And use volatile to avoid the compiler optimizing the code away if it seems that no useful operations are contained within it. The variable should be declared volatile in the following situations:

• Memory-mapped peripheral registers
• Accessing global variables in an interrupt service routine (ISR) or signal handler.
• Sharing global variables between multiple tasks within a multi-threaded application
• Software delay loop variables in a highly optimized function
• Variables that should not be optimized out if not used

When a volatile variable is not declared as volatile, the compiler assumes that its value cannot be modified externally to the implementation. Therefore, the compiler might perform unwanted optimizations. This can manifest itself in a number of ways:

• The code might become stuck in a loop while polling hardware.
• A multi-threaded code might exhibit strange behavior.
• Optimization might result in the removal of code that implements deliberate timing delays.

void do_something(int param1);
int Global_variable;

vois IRQ_Handle(void)       // Interrupt Service Routine
{
    Global_variable = 1;
}

int main()
{
    Global_variable = 0;
    while(1) {              // Stay in this loop
        if( Global_variable )
             do_something();
    }
}

void do_something(int param1);
volatile int Global_variable;

vois IRQ_Handle(void)       // Interrupt Service Routine
{
    Global_variable = 1;
}

int main()
{
    Global_variable = 0;
    while(1) {              // Stay in this loop
        if( Global_variable )
             do_something();
    }
}

int volatile var = 0;

int task1()
{
    while (var == 0) { // do sth }
}
int task2()
{
    var++;
}

// Software Delay
void Delay()
{
    volatile int i;
    volatile int i;

    for (i = 0; i < 10000; i++)
        for (j = 0; j < 500; j++);
}

extern

You can share a variable in multiple C source files by using external variables. It is declared using the extern keyword. The extern simply tells the compiler that the variable is defined elsewhere and not within the same block where it is used. The extern modifier is most commonly used when there are two or more files sharing the same global variables.

// File1.c
int GlobalVar = 0;  // Declaration and Definition of the variable

void IncGlobalVar()
{
    GlobalVar ++;
}

// main.c
#include <stdio.h>

extern int GlobalVar;       // Declaration of the variable
void IncGlobalVar();        // Declaration of the function

int main()
{
    IncGlobalVar();
    printf("GlobalVar = %d \r\n\n", GlobalVar);
    
    system("pause");    // for Windows Console Application
    return 0;
}

The >extern modifier only can be used with global variables. An external variable must be defined exactly once in one of the source files of the program. To access the external variables, the external variables must be declared either outside or inside the function that wants to access.

auto

auto tells the compiler that the local variable it precedes is created upon entry into a block and destroyed upon exit from a block. Since all variables defined inside a function or a block are auto by default, the auto keyword is seldom (if ever) used.

register

Registers are faster than memory to access, so the variables that are most frequently used in a C program can be put in registers using the register keyword. The register modifier could be used only on local variables, and it caused the compiler to attempt to keep that variable in a register of the CPU instead of placing it in memory (RAM).

• If you use & operator with a register variable, then the compiler may give an error or warning (depending upon the compiler you are using), because when we say a variable is a register, it may be stored in a register instead of memory and accessing the address of a register is invalid.

  #include <stdio.h>
  int main()
  {
  register int n = 20;
  int *ptr;
  ptr = &n;
  printf("address of n : %p \n", ptr);
  return 0;
  }

  When you compile the code, the compiler will show an error message as below:

  line 6: ptr = &n; [Error] address of register variable 'n' requested

• The register modifier can be used with pointer variables. Obviously, a register can have an address of a memory location.

  #include <stdio.h>
  int main()
  {
  int n = 20;
  register int *ptr;
  ptr = &n;
  printf("address of n : %p \n", ptr);
  return 0;
  }

  Build the code and execute it:
  

  address of n : 0x7ffc1320465c

• The register modifier can not be used with a static modifier.

  #include <stdio.h>
  int main()
  {
  register static int n = 20;
  n++;
  printf("address of n : %d \n", n);
  return 0;
  }

  When you compile the code, the compiler will show an error message as below:

  line 4: register static int n = 20; [Error] multiple storage classes in declaration specifiers

• The register can only be used within a block (local), it can not be used in the global scope (outside the function).

  #include <stdio.h>
  
  register int n = 20;
  int main()
  {
  n++;
  printf("address of n : %d \n", n);
  return 0;
  }

  When you compile the code, the compiler will show an error message as below:

  line 3: register int n = 20; [Error] Storage class 'register' is not allowed here

• The register is only a request. The compiler is free to ignore it.

What is the fp?

1. fp is a pointer to …
2. fp is a pointer to a function passing (an int and a pointer to float ) returning …
3. fp is a pointer to a function passing (an int and a pointer to float ) returning a pointer to …
4. fp is a pointer to a function passing (an int and a pointer to float ) returning a pointer to an int data

What is the signal?

1. signal is a function passing (an int and a …
   2. fp is a pointer to …
   3. fp is a pointer to a function passing (an int ) returning …
   4. fp is a pointer to a function passing (an int ) returning nothing (void)

5. signal is a function passing (an int and a (fp) pointer to a function passing (an int ) returning nothing (void) ) returning a pointer to …
6. signal is a function passing (an int and a (fp) pointer to a function passing (an int ) returning nothing (void) ) returning a pointer to a function passing (an int ) returning …
7. signal is a function passing (an int and a (fp) pointer to a function passing (an int ) returning nothing (void) ) returning a pointer to a function passing (an int ) returning nothing (void)

Some declarations look much more complicated than they are due to array size and argument lists in prototype form. If you see "[3]", that's read as "array (size 3) of …". If you see "(char *, int)" that's read as "function passing (char *, int) and returning …". Here's a fun one:

int (*(*func)(char *,double))[9][20];

It is:

ptr is a pointer to a function passing (a pointer to char and a double ) returning a pointer to an array (size 9) of array (size 20) of int data

The most important thing here is to recognize the following recursive structure of all declarations (const, volatile, static, extern, inline, struct, union, and typedef are removed from the statement for simplicity but can be added back easily):

dataType [ derived_part1: * | & ] identifier [ derived_part2: [] | () ]

Where

Once you've got all 4 parts parsed,

[identifier] is [derived-part2 (containing/returning)] [derived-part2 (pointer/reference to)] dataType.

If there's recursion, you find your object (if there's any) at the bottom of the recursion stack, it'll be the inner-most one and you'll get the full declaration by going back up and collecting and combining derived parts at each level of recursion.

While parsing you may move [identifier] to after [derived-part2] (if any). This will give you a linearized, easy-to-understand, declaration.

char * (**(*foo[3][5]) (void)) [7][9];

foo is an array (size 3) of an array (size 5) of a pointer to a function returning a pointer to pointer to an array (size 7) of an array (size 9) of pointers to a char.

It is quite possible to make illegal declarations using this rule, so some knowledge of what's legal in C is necessary. For instance, if the above had been:

int *((*func)())[][];

it would have been "func is a pointer to a function returning an array of array of pointers to int". Since a function cannot return an array, but only a pointer to an array, that declaration is illegal.

Illegal combinations include:

In all the above cases, you would need a set of parentheses to bind a * symbol on the left between these () and [] right-side symbols in order for the declaration to be legal.

Here are some more examples: