COM S 326X Deep C Programming for the 21st Century Prof. Rozier Unit 3 – Variables, Continued

Declarations

Types Only four basic types in C int char float – antiquated, bad practice to use (usually) double

Variable Modifiers All variables can be modified with keywords and qualifiers. Data type modifiers long and short are storage modifiers which request more, or less memory. Compilers are not guaranteed to honor long and short modifiers. unsigned and signed change the representation.

Const The const qualifier indicates a variable which: Must be initialized Cannot be changed once initialized

Static The static keyword does a few things. It ensures the variable is initialized to 0x0 unless otherwise specified It makes a variable’s scope restricted to the current file. When it leaves scope, it remains in memory, and if it ever returns to scope, will retain its previous value.

Extern The extern keyword indicates a variable is declared in another file that may, or may not, have been #included directly.

Volatile The volatile keyword indicates to the compiler that the variable can be changed by external entities other than the program itself. Its purpose is prevent the optimizer from removing an apparently unused variable.

Auto The auto keyword informs the compiler that the variable should automatically be created when in scope, and destroyed when out of scope. This is the default behavior. auto signed int x Is the same as int x

Register A particularly dangerous keyword, the register keyword attempts to bind a variable directly to a register. Considered bad practice. The compiler is usually better at deciding this than you are.

Variables and Memory Except for register variables, all other variables live in memory. 0x00000000 Text (Code) Data Heap ↓ ↑ 0xffffffff Stack

Variable allocation and scoping Program initialized global variables main() $rsp local variables (main) $rbp

Variable allocation and scoping Program initialized global variables main() foo() $rsp local variables (foo) $rbp local variables (main)

Variable allocation and scoping Program initialized global variables main() foo() $rsp foo() local variables (foo) $rbp local variables (foo) local variables (main)

Variable allocation and scoping Program initialized global variables main() foo() $rsp local variables (foo) $rbp local variables (main)

Variable allocation and scoping Program initialized global variables main() $rsp local variables (main) $rbp

Variable allocation and scoping Program initialized global variables main() bar() $rsp local variables (bar) $rbp local variables (main)

Variable allocation and scoping Program initialized global variables main() foo() $rsp local variables (foo) $rbp local variables (main)

Variables and Memory Except for register variables, all other variables live in memory. We can also declare variables which take as their type memory address information.

Pointers To declare a variable of a type, such as int: int x; To declare a variable which holds an address of an int we use the pointer operator ‘*’: int *x;

Pointers The following declaration: int* x, y, z; Is not the same as this: int *x, *y, *z; This is why we always associate the * operator, or the dereference operator with the variable and not the type. Think of: int *x as meaning “*x is of type int”.

Pointers Two special unary operators: The address operator: ‘&’ The dereferencing operator: ‘*’ The address operator finds the storage location of whatever it is applied to: The address of x: &x The dereferencing operator finds what is stored at a given address: The value of what is at the address stored in x: *x

Pointers The ‘*’ and ‘&’ operators can be applied recursively: int **x; A pointer to a pointer to an int.

Pointer exercises int x = 5; int *y; y = &x; y++; printf(“%p\n”, y); printf(“%p\n”, &x); printf(“%d\n”, x); printf(“%d\n”, *y); printf(“%d\n”, *x);

Pointers We can use pointers to refer to variables that have been allocated by the compiler, statically, or dynamically, or we can use them to allocate dynamic memory from the heap. #include <stdlib.h> int *x; x = malloc(sizeof(int));

Passing Pointers C functions are called by reference. void foo(int x) { x++; } int main(void) { int x = 5; foo(x);

Passing Pointers If we want to change a value, we should pass a pointer to x. void foo(int *x) { *x = *x + 1; } int main(void) { int x = 5; foo(&x);

Homework 2 is posted Due next Thursday, September 7th.