Lecture 5

• Lecture 5 focuses on pointers, pointer operations, special pointers, application of pointers, and memory allocation in C

Concept of Pointers

• A pointer is a variable that stores the memory address of another variable
• Declaration syntax: data_type* ptr; which declares a pointer ptr of data_type
• Assigning address syntax: ptr = &x; assigns the address of x to ptr
• The * informs the compiler that ptr is a pointer type variable, data_type specifies that it will store the address of a data_type variable
• ptr points to x, meaning it points to the memory location of x
• Dereferencing a pointer retrieves the value stored at the memory location it points to
• The * is the dereference operator
• *ptr gets the value at the memory address of ptr
• *ptr = value; assigns value to the memory location of the address of ptr
• Pointers provide an alternative method to access a memory block and the value stored in the memory block
• Pointers enable address operations to access data for data operations
• The values (address values) of pointers are meaningful only at runtime

Pointer Operations

• Deference operation (example):
  • int num1=2, num2= 3, sum=0, mul=0, div=1;
  • int *ptr1, *ptr2;
  • ptr1 = &num1; ptr2 = &num2;
  • sum = *ptr1 + *ptr2;
  • mul = sum**ptr1;
• Comparison operations: it's possible to compare pointers using relational operators
  • Example: p1 > p2, p1==p2, p1!=p2 valid C code
• Add and minus operations: adding/subtracting an integer value c to/from a data_type pointer will increase/decrease the address by c * sizeof(data_type)
  • Example:
  • int x, *p = &x; p = p + 2;
  • p's value is increased by 2 * sizeof(int) = 2 * 4 = 8.
  • If p's value is 1000, then after p = p+2, p's value becomes 1008
• Increment (++) / Decrement (--) operators:
  • p++; is equivalent top = p + 1;
  • p--; is equivalent to p = p - 1;
• ++ has high precedence than *
• *ptr++ is equivalent to *(ptr++)

Special Pointers

• Null pointer: a null pointer (null pointer value) is the special pointer value 0, meaning it does not point anywhere
• A null pointer can be declared using the macro NULL, initialized by the preprocessor as 0
  • Example: int *ptr = NULL; which is equivalent to int *ptr = 0;
• Generic pointer: a generic pointer is a pointer that has void as its data type
• Generic pointers are used to point to a variable of any data type
  • It is declared by syntax: void *ptr;
• Needs to be cast a void pointer to its type before dereferencing
  • Example:
  • int a = 10;
  • void *ptr = &a;
  • printf("%d", *(int *) ptr); // (int *) casts ptr to int pointer
• Generic pointers are used when a pointer has to point to different types of variables at different positions of a program
• Pointer to pointer: a pointer pointing to a pointer of the same type
• A pointer to pointer is declared simply by adding an asterisk (*) to a pointer
  • Example:
  • int x=10;
  • int *p, **pp, ***ppp;
  • p=&x;
  • pp=&p;
  • ppp=&pp;
  • printf(“%d”, **pp); // Outputs 10
  • printf(“%d”, ***ppp); // Outputs 10
• Function type pointer: a function pointer allows you to refer to functions with a specific signature

Applications of Pointers

• Used in pass-by-references, enabling input/output of multiple values to/from a function through function arguments
• Increases the efficiency of accessing data for algorithms
• Essential in dynamic memory allocation and management
• Used to implement complex data structures like linked lists, queues, stacks, trees

Memory Allocations in C

• Static memory allocation: done by the declaration of global or static variables
  • At compile time, a global or static variable is allocated a memory block with a relative address to the data region
  • At runtime, the statically allocated memory blocks are instanced with absolute addresses in the data region
  • The size of the data region is determined by the sum of the sizes of statically allocated memory blocks at compile time
  • Will not be changed and released at runtime
• Automatic memory allocation: done by function arguments and local variables
  • At compile time, a local or argument variable is assigned a memory block with a relative address to the function scope
  • At runtime, when the function is called, the memory blocks local variables are allocated in the stack region
  • Automatically released after the function call is finished
  • By release means that the space of the memory block can be reused by follow-up function calls
  • Automatic release means that the memory release is managed by program execution mechanism, not by program statements
• Dynamic memory allocation: done by the stdlib library function malloc()
  • The memory block of a dynamic allocation is located in the heap region
  • It will not be released automatically after the calling function finishes
  • Dynamically allocated memory blocks can be shared by different functions
  • When a dynamically allocated memory block is not used anymore, it needs to use the free() function to release a memory block
• malloc(size) returns the address of the memory block of the allocated memory block, or returns 0 on failure
• Memory leaking: memory leaking is the situation of losing the address of dynamically allocated space