C++ Pointers

• To declare a pointer, you specify the data type the pointer points to and use the asterisk (*) symbol.

Declare Pointers

A pointer is a variable that stores the memory address of another variable. Pointers are used to work with memory directly and are a powerful feature of the language, allowing for dynamic memory allocation, manipulation of data structures, and efficient access to memory.

To declare a pointer in C++, you use the following syntax:

data_type *pointer_name;

⤏ Here, 'data_type' is the type of the variable to which the pointer will point, and 'pointer_name' is the name of the pointer variable. The '*' symbol is used to declare a pointer.

Here's a simple example:

#include＜iostream＞

int main() {
    // Declare a pointer to an integer
    int *ptr;

    // Declare an integer variable
    int num_ = 42;

    // Assign the address of the integer variable to the pointer
    ptr = &num_;

    // Access the value through the pointer
    std::cout << "Value of num_: " << num_ << std::endl;
    std::cout << "Value of num_ using pointer: " << *ptr << std::endl;

    return 0;
}

In this example, 'ptr' is a pointer to an integer, and it is assigned the address of the 'num_' variable using the address-of operator ( '&'). The value of 'num_' can be accessed through the pointer using the dereference operator ( '*ptr').

Value of num: 42
Value of num using pointer: 42

Note: Always initialize pointers before using them, either by assigning them the address of a valid variable or by setting them to 'nullptr' (in C++11 and later) if they are not intended to point to anything initially.

nullptr

In C++, 'nullptr' is a keyword that represents a null pointer. It was introduced in C++11 as a safer and more expressive alternative to using 'NULL' or '0' for null pointers.

int *p = nullptr; // Null pointer
void *genericPtr = p; // Pointer to void

⤏ Pointers can be set to 'nullptr' to indicate they are not pointing to any valid memory. Pointers to 'void' can be used for generic pointer handling.

Pointer Arguments

* Pointers in C++ are powerful and versatile features that allow you to work with memory directly.

In C++, you can pass pointers as arguments to functions. This allows the function to modify the values pointed to by the pointers, effectively allowing for indirect manipulation of variables. When passing a pointer to a function, you're essentially passing the memory address of a variable, enabling the function to access and modify the content at that location.

Here's a simple example demonstrating the use of pointer arguments in a function:

#include＜iostream＞

// Pointer as an argument and modifies the value
void doubleValue(int *ptr) {
    if (ptr != nullptr) {
        *ptr *= 2;
    }
}

int main() {
    int num = 5;
    int *ptr = #

    std::cout << "Original value of num: " << num << std::endl;

    // Call the function with the pointer as an argument
    doubleValue(ptr);

    std::cout << "Doubled value of num: " << num << std::endl;

    return 0;
}

In this example, the 'doubleValue' function takes a pointer to an integer as an argument and doubles the value stored at the memory location pointed to by that pointer. The 'main' function declares an integer variable 'num', a pointer 'ptr' that points to the address of 'num', and then calls the 'doubleValue' function with the pointer as an argument.

Original value of num: 5
Doubled value of num: 10

As a result, the value of 'num' is modified indirectly through the pointer, and you see the doubled value when printing it in the 'main' function.

* When working with pointer arguments, be cautious about null pointers to avoid undefined behavior. Always check if a pointer is not null before dereferencing it.