A pointer is a variable that stores the memory address of another variable. In other words, it "points" to the memory location where a value is stored. By using pointers, you can directly access and modify the value at that memory address.
To declare a pointer variable, you use an asterisk (*) symbol before the variable name. For example:
int* ptr; // Declares a pointer to an integer
Here, `ptr` is declared as a pointer to an integer (`int*`). Note that the asterisk indicates that `ptr` is a pointer, not a regular integer variable.
To assign a value to a pointer, you use the address-of operator (`&`) to obtain the memory address of another variable. For example:
int num = 42;
int* ptr = # // Assigns the address of 'num' to 'ptr'
In this case, `ptr` is assigned the memory address of the variable `num`. Now, `ptr` points to the memory location where `num` is stored.
Dereference Operator:
To access the value at the memory address pointed to by a pointer, you use the dereference operator (`*`). For example:
int value = *ptr; // Retrieves the value at the memory address pointed to by 'ptr'
In this case, `*ptr` retrieves the value stored at the memory address pointed to by `ptr`. In other words, it gives you access to the value of `num`, which is 42.
Pointer to Pointer:
In C, you can have pointers that point to other pointers. These are called pointers to pointers, or double pointers.
To declare a pointer to a pointer, you use two asterisks (**). For example:
int num = 42;
int* ptr = # // Stores address of variable num
int** ptrToPtr = &ptr; // Stores address of pointer ptr
Pointer-to-pointer relationships can be extended further by using additional asterisks. For example, a pointer to a pointer to a pointer is declared with three asterisks (***), and so on. Each level of indirection adds another layer of memory address access.
Constant Pointers:
In C, you can create constant pointers, which are pointers whose target address cannot be modified. This means that once a constant pointer is assigned a memory address, it cannot be made to point to a different address.
To create a constant pointer, you use the `const` keyword. You can either make the pointer itself constant or make the target value constant, or even both.
For example, to create a constant pointer, you place the `const` keyword before the pointer's type:
int num = 42;
const int* ptr = #
In this case, `ptr` is a constant pointer to an integer. The `const` keyword indicates that the pointer itself is constant, meaning you cannot modify the address it points to. However, you can change the value at the memory location using a different pointer.
Alternatively, you can make the value pointed to by the pointer constant using the `const` keyword after the asterisk:
int num = 42;
int* const ptr = #
In this case, `ptr` is a constant pointer to an integer. The `const` keyword indicates that the value pointed to by `ptr` cannot be modified. However, you can change the address that `ptr` points to.
Finally, you can create a constant pointer to a constant value by combining both uses of the `const` keyword:
int num = 42;
const int* const ptr = #
In this case, `ptr` is a constant pointer to a constant integer. Both the pointer and the value it points to are constant, so neither the address nor the value can be modified.
Pointers with Arrays:
In C, the name of an array can be thought of as a pointer to the first element of the array. This is because arrays are stored as a contiguous block of memory, and the array name represents the memory address of the first element.
Consider the following example:
int numbers[5] = { 1, 2, 3, 4, 5 };
int* ptr = numbers;
In this case, the array `numbers` contains five integer elements. The pointer `ptr` is assigned the memory address of the first element of the array, which is `&numbers[0]`. Alternatively, you can directly assign `numbers` to `ptr` without using the address-of operator `&`.
You can use pointer notation to access array elements as well:
int firstElement = *ptr; // Accesses the first element of the array
int secondElement = *(ptr + 1); // Accesses the second element of the array
Here, `*ptr` retrieves the value of the first element of the array, while `*(ptr + 1)` accesses the value of the second element. The addition of `1` to the pointer is equivalent to moving the pointer to the next element in the array.
Pointer Arithmetic:
Pointer arithmetic allows you to perform arithmetic operations on pointers, enabling you to traverse and manipulate arrays efficiently.
Incrementing and decrementing pointers:
You can increment or decrement a pointer to access adjacent elements:
int* nextElement = ptr + 1; // Points to the next element in the array
int* prevElement = ptr - 1; // Points to the previous element in the array
Here, `ptr + 1` points to the next element in the array, while `ptr - 1` points to the previous element.
Pointer comparison:
You can compare pointers to determine their relative positions within an array:
bool isPtrEqual = (ptr1 == ptr2); // Checks if two pointers are equal
bool isPtrLess = (ptr1 < ptr2); // Checks if ptr1 is less than ptr2
Here, `ptr1 == ptr2` checks if `ptr1` and `ptr2` point to the same memory address, while `ptr1 < ptr2` compares their relative positions in memory.
Pointer arithmetic with integral values:
You can perform arithmetic operations on pointers with integral values, which allows you to access array elements at specific indices:
int thirdElement = *(ptr + 2); // Accesses the third element of the array
int sixthElement = ptr[5]; // Accesses the sixth element of the array
In the first example, `ptr + 2` moves the pointer two elements ahead, allowing you to access the third element. The second example demonstrates array indexing using pointer notation, where `ptr[5]` accesses the element at index 5.
It's important to note that pointer arithmetic should be performed within the bounds of the array to avoid undefined behavior. Accessing elements beyond the array's range can lead to unexpected results or crashes. (alert-success)
