Pointer Operations
Pointer operations give it powerful functionality. In addition to the dereference operation (*) and the address-of operation (&), pointers also support some arithmetic operations. For example, pointers can perform addition and subtraction, but it is important to note that pointer addition and subtraction are not simple numerical addition or subtraction; they are based on the size of the data type they point to.
Suppose we have a pointer to an integer array:
int arr[5] = {1, 2, 3, 4, 5};
int *ptr = arr;
ptr = ptr + 2;
std::cout << *ptr << std::endl; In this example, ptr initially points to the starting address of the array arr. When executing ptr = ptr + 2;, since ptr is a pointer to an integer, and an integer typically occupies 4 bytes in memory (depending on the compiler and system), ptr will move to the address of the third element in the array (because each element occupies 4 bytes, moving two elements means moving 8 bytes). At this point, the value output by *ptr is 3.
Null Pointer
A null pointer is a special pointer value that does not point to any valid memory address. In C++, we typically use nullptr to represent a null pointer. The main purpose of a null pointer is to initialize pointer variables or to check whether a pointer points to valid memory under certain conditions.
int *nullPtr = nullptr;
if (nullPtr == nullptr) {
std::cout << "This is a null pointer." << std::endl;
}Before performing pointer operations, checking whether a pointer is a null pointer is a good programming practice that can avoid many runtime errors.
The Deep Relationship Between Pointers and Arrays
The array name can often be regarded as a constant pointer that points to the first element of the array. For example:
int arr[5] = {1, 2, 3, 4, 5};
int *ptr = arr;
for (int i = 0; i < 5; i++) {
std::cout << *(ptr + i) << " ";
}In this loop, ptr + i successively points to each element of the array, and by dereferencing *(ptr + i), we can obtain the value of the corresponding element. This also demonstrates the convenience of pointers when traversing arrays.
Additionally, we can use pointers to dynamically create multi-dimensional arrays. For example, creating a two-dimensional array:
int rows = 3;
int cols = 4;
int **twoDArray = new int*[rows];
for (int i = 0; i < rows; i++) {
twoDArray[i] = new int[cols];
}
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++) {
twoDArray[i][j] = i * cols + j;
}
}
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++) {
std::cout << twoDArray[i][j] << " ";
}
std::cout << std::endl;
}
for (int i = 0; i < rows; i++) {
delete[] twoDArray[i];
}
delete[] twoDArray;In this code, we first create a pointer array twoDArray, where each element is a pointer to an integer array, thus implementing dynamic allocation of a two-dimensional array. After use, it is important to correctly release memory to avoid memory leaks.
Pointers are ubiquitous in C++, from simple variable access to complex data structure construction, they are indispensable. Through continuous learning and practice, we can better master pointers as a powerful tool and write efficient, robust C++ programs.