C++ Reference

In C++, a reference is an alias or an alternative name for an existing variable. It provides an alternative syntax to access and manipulate the value of an object without directly working with its memory address. References are often used as function parameters, allowing functions to modify variables passed to them or to avoid making copies of large objects.

Here are some key points about references in C++:

  1. Declaration
    A reference is declared by appending an ampersand (&) to the variable name when declaring a new reference variable. The reference must be initialized with an existing object during declaration and cannot be changed to refer to a different object afterward.

    2. Example 
    int num = 10;
int& ref = num;   // Declaration of a reference to an integer variable

  2. Alias for an Object
    Once a reference is declared and initialized, it becomes an alias for the object it references. Any modifications made to the reference will affect the original object, and vice versa.

    3. Example 
    int num = 10;
int& ref = num;

ref = 20;   // Modifying the reference also modifies 'num'
cout << num;   // Output: 20

  3. Use in Function Parameters
    References are commonly used in function parameters to pass variables by reference. When a variable is passed by reference, any modifications made to it within the function will affect the original variable.

    4. Example 
    void increment(int& num) {
    num++;
}

int main() {
    int num = 10;
    increment(num);
    cout << num;   // Output: 11
    return 0;
}

  4. Difference from Pointers References should not be confused with pointers. Unlike pointers, references cannot be null and must be initialized at the time of declaration. Additionally, references cannot be reassigned to refer to a different object once initialized.

    5. Example 
    int num = 10;
    int& ref = num;
    
    int* ptr = #   // Pointer to 'num'
    int& ref2 = *ptr;  // Reference to 'num' through a pointer

References provide a convenient way to work with variables in C++, offering a simpler syntax and avoiding the need to explicitly manipulate memory addresses. They are especially useful when passing variables to functions by reference or when creating aliases for existing variables.

Next Article ❯