C Pointers: Basics, Declaration, and Usage

Unit 3 Overview: Pointers in C

• Unit 3 focuses on pointers, a derived data type in C, that holds the address of another variable
• It covers the basics, arrays, chains, character strings, functions, structures, related issues, and dynamic memory allocation

Pointer Basics

• A pointer stores the memory address of another variable and can also be known as a locator or indicator
• Pointers are more efficient for handling arrays and structures
• Pointers enable referencing and passing functions as arguments
• Using pointers reduces program length and execution time and allows C to support dynamic memory management

Pointer Declaration and Usage

• A pointer is declared using data_type* pointer_variable_name shown with an example of int* p
• A void type pointer works with all data types however is not often used
• A pointer is initialized by assigning the address of a variable to it using the & operator
• Example of pointer initialization int a = 10; int *ptr; ptr = &a; or int *ptr = &a;
• A pointer variable must point to the same type of data
• e.g. float a; int *ptr; ptr = &a; this is an error due to type mismatch

Memory Representation

• A pointer stores the address of another variable
• Using the * operator, the value at the address the pointer refers to can be viewed

Reference and Dereference Operators

• The & is called the reference operator, while the * is called the dereference operator
• The & operator gives the address of a variable, and the * operator retrieves the value from that address

Pointer Syntax Examples

• & determines the address of a variable
• * accesses the value at the address
• printf("%d",*p); it will print the value of a
• printf("%d",*&a); it will also print the value of a
• printf("%u",&a); it will print the address of a
• printf("%u",p); it will print the address of a
• printf("%u",&p); it will print the address of p

Key Facts About Pointers in C

• A normal variable directly stores a value, while a pointer stores the address of a variable
• The content of a pointer is always a whole number representing an address
• Always initialized to NULL (i.e., int *p = NULL) and the value of a NULL pointer is 0
• The & gets the address of a variable, and * gets the value the pointer is pointing to
• Assigning NULL signifies the pointer points to nothing

Pointer Arithmetic and Constraints

• Pointers can be subtracted to find array element spacing
• Addition, multiplication and division of pointers are not permitted
• Pointers are 2 bytes for a 16-bit compiler

Pointers and Arrays

• The compiler allocates contiguous memory blocks for arrays, and the base address (location of the first element) for an array is done at compile time
• Declaring int arr[5]={ 1, 2, 3, 4, 5 }; and each int takes two bytes and the first address is 1000 then the next elements addresses are 1002 1004 1006 1008
• The array name arr gives the constant pointer to arr[0] containing the address, i.e. 1000
• arr is equivalent to &arr[0] by default
• A pointer of type int can point to an array arr

Accessing Array Elements with Pointers

• Every element of an array arr can be accessed using p++ to advance to the next element
• Decrementing a pointer after incrementing isn't permitted (p-- won't work)
• Using a pointer, you can point to an array and from there access the array elements
• If int a[5] = {1, 2, 3, 4, 5}; int *p = a you can print with printf("%d", *p); p++;
• Use the base address a as the pointer

Different Ways to Access Arrays

• printf("%d", a[i]); prints the array elements by incrementing index
• printf("%d", i[a]); does the same as a[i]
• printf("%d", a+i); prints the array element addresses
• printf("%d", *(a+i)); yields the value of a given array element
• printf("%d", *a); prints just the value of the first array element

Pointer vs Array Name

• There is a compile-time error: base address cannot be changed by doing a++
• Array's name points to the first element, and &arr[0] points to the address of the first array elment
• arr equals &arr[0]
• arr[0] equals *arr

Equivalence Expressions

• &arr[1] equals (arr + 1) and arr[1] equals *(arr + 1)
• &arr[2] equals (arr + 2) and arr[2] equals *(arr + 2)
• &arr[3] equals (arr + 3) and arr[3] equals *(arr + 3)
• &arr[i] equals (arr + i) and arr[i] equals *(arr + i)

Pointer Arithmetic

• Four arithmetic operators apply to pointers: increment, decrement, addition, subtraction
• Incrementing a pointer is generally in an array, because of contiguous memory, so contents of next memory location is known.
• new_address = current_address + i * size_of(data type) will increment pointer
• Address + 1 = Address
• Address++=Address
• ++Address = Address

Increment Type Differences

• 32 bit int variable increment by 2 bytes
• 64 bit int variable, it increases by 4 bytes
• In an example of pointer incrementation; address of p is printed, then incremented, then that value is printed

Decrementing Pointers

• Like incrementing, pointers can be decremented using the formula new_address = current_address - i * size_of(data type)
• The new address is printed with the dereferenced value, and the pointer variable's address changes

Adding to Pointers

• Is achievable by new_address = current_address - (number * size_of(data type))
• When adding the value for a 32-bit int, the code will add 2 * number ,and when the int is 64 bit, will add 4 * number to the address

Pointer Subtraction

• Is achievable from the pointer variable, for example new_address = current_address - (number * size_of(data type))

Chains of Pointers

• Chains of pointers refers to series of pointers where each pointer points to the next memory location
• Often used in structures like linked lists, used for data structures implementations
• The basic concept involves storing memory addresses of variables or data, and a chain of pointers, creating a sequence.

Singly Linked Lists

• Linked lists have all the data and a pointer, and the last pointer has NULL, which shows the end of the chain
• This shows storing elements of same type, though, not as contiguous
• Each node, within this list, contains both a data field and a next pointer
• Only a current node knows where the list's next element exists

Linked List Structure Components

• Struct Node includes int data and Node* next, indicating two data list members using data and next
• data indicates the value that's stored, and next stores some of memory address of the next node
• The pointer to the list's first node, is called head

Linked List Basic Operations

• Insert, delete, and print are the basic operations required to manipulate list nodes
• Insert operations include at Head, Given Position, and at End
• Delete Operations include From Head, From Given position, and from End
• Insert operations at head take 0(1) time complexity
• Insert operations at a given position or at the end take O(N) time complexity
• Delete operations from the Head take 0(1) time complexity
• Delete operations from a Given position take O(N) time complexity
• The number of nodes in the linked list is N
• Print takes O(N) time complexity and O(1) space complexity

Insertion Algorithms for Singly Linked Lists

• To insert a node at the start of a singly linked list, the new node becomes the Head and returns if if its empty, update pointer
• For insertions at a specific position, the code traverses the list until the requested position reached to add the node before it
• When inserting a node at the end of the list, a new node made current head and returns, otherwise the code traverses till the last node until it finds head and then returns

Deletion Algorithms for Singly Linked Lists

• Removing the first node requires ensuring it is not NULL; free allocated memory
• Removing nodes anywhere require that, head pointer checks for Null, call functions to traverse and detatch before reallocating memory

Additional List Algorithms for printing linked lists

• Ensure that the head is not equal to Null, and then creates a temporary pointer
• After which the code iterates through the linked list and prints all values, while it moves past it

Dynamic Memory Allocation

• Includes malloc(), calloc(), free(), and realloc(), to help be effective with how memory gets used
• Dynamic Memory lets program to change a structure's, like an Array, size at times of runtime

Dynamic Allocation Functions

• Includes:
  • malloc()
  • calloc()
  • free()
  • realloc()

Memory Allocation with Malloc

• Memory allocation and the malloc method in C allows to allocate and use single big block of memory
• Returns a type void pointer, which can be casted into pointer, without initialising memory at at execution

Contiguous Allocation with Calloc

• Calloc, another method, allocates the specified number of blocks, with malloc.
• However it initializes first block with 0, and does use two instead of one paramters

Dealocate with free Function

• The ""free"" method in C assists with dynamically de-allocating some memory
• The deallocation is required after usage of malloc or calloc.
• The code also reduces overall memory wastage

Realloc Method

• There is also realloc methods exists, short for rea-llocation memthod
• Can dynamically change how memory allocated by using malloc, or calloc previously
• This option maintains everything is currently allocated, while initialising new blocks with garbage

Static vs Dynamic Memory Allocation

• Compile time versus runtime; static memory allocation exists on complile time and dynamic allocations occurs run time, as defined previously

• Static cannot increase during execution time, since memory allocations can not be made, whereas dynamic has code that adjust during execution

• Static memory tends to use array and dynamic uses linked lists

Static vs Dynamic Malloc implementation

• the malloc functions allocates the requested memory, runtime

The Function Components

• Reserves and returns type void pointer, and requires a block of memory
• Assign any pointers through methods that type cast, although this does create garbage
• Does return if failure to allocate

Calloc Implentation Details

• Contiguous calloc needs to have two components, size and how many memebers it needs, during memory allcoation
• The values can change during execution time

Freeing memory for malloc

• malloc and calloc dont clean on close, and have to be manually cleaned with free

Syntax for Freeing

• The command (free*)calloc(blocks, siz -type) performs actions to dynamically allocate memory blocks and release that pointer
• free(ptr) performs functions to remove pointers from allocated memory

Important Distinction

• Memory has to be manaually reallocated from processes if malloc or callsoc is applied to it

Realloc

• Has the option to change previously allocated blocks, or add to current block addresses

Function Requirements

• Needs pointers of address and data size, the code does create format allocations if its initialised in proper byte formats