Introduction to Pointers and Pointer Arithmetic in C++

Pointers are one of the most powerful features in C++ that allow direct memory access. A pointer is a variable that stores the memory address of another variable. With pointers, you can manipulate data directly at the memory level, which makes them essential in advanced C++ programming.

What is a Pointer?

A pointer in C++ is a variable that stores the address of another variable. Instead of holding a data value, a pointer holds the location (address) where the data is stored in memory. The type of pointer corresponds to the type of data it points to.

Syntax for Declaring a Pointer

        type *pointer_name;

Here, type refers to the data type of the variable the pointer will point to (e.g., int, float), and pointer_name is the name of the pointer.

Example of Declaring and Using a Pointer

    #include <iostream>

    int main() {
        int number = 10;
        int *ptr = &number;  // Pointer to int, storing the address of 'number'

        // Accessing value through pointer
        std::cout << "Value of number: " << *ptr << std::endl;
        std::cout << "Address of number: " << ptr << std::endl;

        return 0;
    }

In this example:

  • int *ptr declares a pointer ptr that points to an integer.
  • &number takes the address of the variable number and assigns it to ptr.
  • *ptr is used to dereference the pointer, which means accessing the value stored at the address the pointer points to.
  • ptr itself stores the memory address of number.

Pointer Arithmetic

Pointer arithmetic refers to operations that can be performed on pointers, such as incrementing, decrementing, and adding integers to pointers. Pointer arithmetic is based on the size of the type the pointer is pointing to.

Common Pointer Arithmetic Operations

  • ptr++: Increments the pointer by the size of the type it points to.
  • ptr--: Decrements the pointer by the size of the type it points to.
  • ptr + n: Moves the pointer n elements ahead.
  • ptr - n: Moves the pointer n elements back.

Example of Pointer Arithmetic

    #include <iostream>

    int main() {
        int arr[] = {10, 20, 30, 40, 50};
        int *ptr = arr;

        std::cout << "Value at ptr: " << *ptr << std::endl;

        ptr++;  // Increment pointer (move to next element)
        std::cout << "Value at ptr after increment: " << *ptr << std::endl;

        ptr--;  // Decrement pointer (move back to previous element)
        std::cout << "Value at ptr after decrement: " << *ptr << std::endl;

        ptr = ptr + 2;  // Move the pointer forward by 2 elements
        std::cout << "Value at ptr after adding 2: " << *ptr << std::endl;

        return 0;
    }

In this example:

  • arr[] is an array of integers.
  • ptr is initialized to point to the first element of the array (arr[0]).
  • ptr++ moves the pointer to the next element of the array, and *ptr accesses its value.
  • ptr-- moves the pointer back to the previous element.
  • ptr = ptr + 2 moves the pointer two positions forward in the array.

Dereferencing a Pointer

Dereferencing a pointer means accessing the value that the pointer is pointing to. You can dereference a pointer by using the * operator.

Example of Dereferencing a Pointer

    #include <iostream>

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

        std::cout << "Value of num: " << num << std::endl;
        std::cout << "Value through pointer: " << *ptr << std::endl;

        return 0;
    }

In this example:

  • ptr is pointing to the address of num.
  • *ptr is used to access the value stored at the memory address ptr points to, which is 5.

Conclusion

Pointers are a fundamental concept in C++ that provide powerful control over memory and data manipulation. Understanding how to declare, use, and manipulate pointers with pointer arithmetic is essential for any C++ programmer. Pointer arithmetic can be used effectively with arrays, and dereferencing allows access to the data they point to. By mastering pointers and pointer arithmetic, you gain better control over how your program interacts with memory, making your code more efficient and flexible.




Advertisement