Understanding References and Pointers | CodeSignal Learn

Understanding References and Pointers | CodeSignal Learn

Understanding References and Pointers

Welcome! Today, we are going to learn about something very important in C++ : references and pointers . This might sound a bit challenging, but I'll break it down for you with simple explanations and examples. By the end of this lesson, you'll understand what references and pointers are, when to use them, and how they can make your code more powerful. Our goal is to get comfortable with these concepts so you can manage memory more efficiently and write clearer and more efficient code.

Understanding what References are

A reference in C++ is like a nickname for a variable. Imagine a friend named Alex, who you call "Al." "Al" is just another name for Alex. Similarly, a reference is another name for a variable. In C++, we use the & symbol to create a reference . Here’s the basic syntax: C++ int x = 10; int &ref = x; // ref is now a reference to x Here, x is an integer with value 10. We create a reference ref to x . Important characteristics of references : Initialization : References must be initialized when created: C++ int y = 5; int &ref = y; // Correct: ref is initialized with y // int &r; // Error: reference must be initialized Constant Aliases : Once initialized, a reference cannot be changed to refer to another variable: C++ ref = 20; // This sets y (and hence ref) to 20, doesn't reassign ref

Understanding what Pointers are

A pointer stores the address of another variable, like a treasure map showing where the treasure is buried. Think of the pointer as the map and the variable as the treasure. In C++, we use the * symbol to define a pointer . Here’s the basic syntax: C++ int x = 10; int *ptr = &x; // ptr now holds the address of x Here, x is an integer value, and ptr is a pointer, showing where to find x . Note that the pointer can be assigned only to a reference of the target variable.

Dereferencing a Pointer

To access the value at the address a pointer holds, we use the * operator, called dereferencing : C++ int z = 30; int *ptr = &z; // ptr points to z *ptr = 40; // changes the value of z to 40 std::cout << z; // 40 In this code, we change the value through the pointer instead of using its name directly. To do it, we firstly dereference the pointer with the * operator.

Sign up

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Pointer Arithmetic

Pointers can navigate through memory. If you have an array, you can move the pointer to the next element by incrementing it: int arr[] = {1, 2, 3}; int *ptr = arr; // points to arr[0] ptr++; // now ptr points to arr[1] std::cout << *ptr; // 2 This can be especially useful when iterating through complex data types. It is possible to go out of the array's bounds this way, so it is crucial to be careful when using this iteration method.

Assign Options

Defining a pointer without initializing it with a value is also possible. We can assign a value to it later: int x = 10; int *ptr; ptr = &x; // ptr now holds the address of x Like a regular variable, a pointer can be re-assigned: int x = 10; int *ptr; ptr = &x; // ptr now holds the address of x std::cout << *ptr << std::endl; // 10 int y = 5; ptr = &y; // ptr now holds the address of y std::cout << *ptr << std::endl; // 5 Here, we use the same ptr variable to store the address of x, and then the address of y .