In C++, a pointer is a variable that stores the memory address of another variable. It allows you to directly access and manipulate the memory of a variable, which can be useful in certain situations, such as dynamically allocating memory or passing large objects to a function by pointer to avoid copying them.
Declaring Pointers
To declare a pointer, you use the asterisk (*) operator followed by the variable type and the variable name. Here is an example of declaring a pointer to an int variable:
int x = 10; int *ptr = &x;
In this example, the variable ptr is a pointer to the variable x. The ampersand (&) operator is used to get the memory address of a variable, and the asterisk (*) operator is used to declare a pointer. The value stored in ptr is the memory address of the variable x.
Accessing Variables using Pointers
Once a pointer has been declared and initialized, you can use the dereference operator (*) to access the variable it points to. Here is an example:
int x = 10; int *ptr = &x; *ptr = 20; cout << x;
Output:
20
In this example, the value of x is changed to 20 by dereferencing the pointer ptr and assigning a new value to it.
Passing Variables to Functions by Pointer
Another common use of pointers is to pass variables to functions by pointer. This allows the function to modify the original variable, rather than a copy of it. Here is an example of passing an int variable to a function by pointer:
void doubleValue(int *x) {
*x *= 2;
}
int x = 10;
doubleValue(&x);
cout << x;
Output:
20
Pointers and Arrays
Pointers can also be used with arrays. Here is an example of declaring a pointer to an array:
int array[5] = {1, 2, 3, 4, 5};
int *ptr = array;
In this example, ptr is a pointer to the first element of the array. We can access the array elements using pointer arithmetic. For example, we can access the second element of the array by using *(ptr + 1).
Dynamic Memory Allocation
Pointers are also used in dynamic memory allocation. In C++, we can use the new and delete operators to dynamically allocate and deallocate memory. Here is an example of allocating memory dynamically:
int *ptr = new int; *ptr = 10;
In this example, the new operator is used to allocate memory for an int variable, and the pointer ptr is assigned the memory address of the newly allocated int. This allows us to dynamically allocate memory as needed, rather than having to pre-allocate a fixed amount of memory for a variable.
To deallocate memory, we can use the delete operator. Here is an example:
int *ptr = new int; *ptr = 10; delete ptr;
In this example, the memory allocated to the int variable is deallocated and the pointer ptr is set to null. It is important to always deallocate memory when it is no longer needed to prevent memory leaks.
When using dynamic memory allocation, it is important to keep track of the memory and deallocate it when it is no longer needed. We can use smart pointers to help with this, which automatically deallocate memory when they go out of scope. The most commonly used smart pointers in C++ are std::unique_ptr and std::shared_ptr. These smart pointers can be used in place of raw pointers, and handle the deallocation of memory for you, making your code more robust and safe.
Conclusion
In this article, we have discussed the basics of C++ pointers. Pointers are powerful features of C++ that allow you to directly access and manipulate memory, which can be useful in certain situations such as passing large objects to a function by pointer or dynamically allocating memory. However, pointers can also be difficult to work with and can lead to errors if not used correctly. It is important to understand the basics of pointers and to use them with care when programming in C++.
