C++ References

Introduction

References in C++ provide an alias for another variable, allowing you to access the variable using a different name. They are particularly useful for passing variables to functions without copying the data, thereby improving performance and allowing functions to modify the original variables.

Declaring References

Syntax for Declaring a Reference

dataType &referenceName = variableName;

Example: Declaring and Using References

#include <iostream>
using namespace std;

int main() {
    int x = 10; // Declare an integer variable
    int &ref = x; // Declare a reference to the variable x

    // Access and modify the variable using the reference
    cout << "x = " << x << endl;
    cout << "ref = " << ref << endl;

    ref = 20; // Modify x through the reference

    cout << "After modifying ref:" << endl;
    cout << "x = " << x << endl;
    cout << "ref = " << ref << endl;

    return 0;
}

Output

x = 10
ref = 10
After modifying ref:
x = 20
ref = 20

Explanation

• int &ref = x; declares a reference ref to the variable x.
• Modifying ref also modifies x because ref is an alias for x.

References as Function Parameters

Passing variables to functions by reference allows the function to modify the original variable. This is more efficient than passing by value, especially for large data types, as it avoids copying the data.

Example: Passing by Reference

#include <iostream>
using namespace std;

// Function to swap two integers using references
void swap(int &a, int &b) {
    int temp = a;
    a = b;
    b = temp;
}

int main() {
    int x = 5, y = 10;

    cout << "Before swap:" << endl;
    cout << "x = " << x << ", y = " << y << endl;

    swap(x, y); // Pass variables by reference

    cout << "After swap:" << endl;
    cout << "x = " << x << ", y = " << y << endl;

    return 0;
}

Output

Before swap:
x = 5, y = 10
After swap:
x = 10, y = 5

Explanation

• void swap(int &a, int &b) defines a function that takes two integers by reference.
• swap(x, y); passes x and y by reference to the swap function, allowing the function to modify the original variables.

Returning References from Functions

Functions can also return references. This is useful when you want to return a reference to a variable rather than a copy of the variable.

Example: Returning a Reference from a Function

#include <iostream>
using namespace std;

// Function that returns a reference to a static variable
int& getStaticVariable() {
    static int x = 10; // Static variable
    return x;
}

int main() {
    int &ref = getStaticVariable(); // Get a reference to the static variable

    cout << "Initial value: " << ref << endl;

    ref = 20; // Modify the static variable through the reference

    cout << "Modified value: " << getStaticVariable() << endl;

    return 0;
}

Output

Initial value: 10
Modified value: 20

Explanation

• int& getStaticVariable() defines a function that returns a reference to a static variable x.
• int &ref = getStaticVariable(); gets a reference to the static variable.
• Modifying ref also modifies the static variable x.

Constant References

Constant references prevent the reference from modifying the referred-to variable. This is useful for passing large objects to functions without copying, while ensuring the function does not modify the object.

Example: Constant Reference

#include <iostream>
using namespace std;

// Function that takes a constant reference
void printValue(const int &value) {
    cout << "Value: " << value << endl;
    // value = 10; // Error: cannot modify a constant reference
}

int main() {
    int x = 5;
    printValue(x); // Pass by constant reference

    return 0;
}

Output

Value: 5

Explanation

• void printValue(const int &value) defines a function that takes a constant reference.
• printValue(x); passes x by constant reference to the printValue function.

Example Programs

Example 1: Using References in a Class

This example demonstrates using references as data members in a class.

#include <iostream>
using namespace std;

class Number {
private:
    int &ref;
public:
    Number(int &n) : ref(n) {}

    void setNumber(int n) {
        ref = n;
    }

    void printNumber() const {
        cout << "Number: " << ref << endl;
    }
};

int main() {
    int x = 10;
    Number num(x);

    num.printNumber(); // Output: 10

    num.setNumber(20);
    num.printNumber(); // Output: 20

    cout << "x: " << x << endl; // Output: 20

    return 0;
}

Output

Number: 10
Number: 20
x: 20

Explanation

• The Number class contains a reference data member ref.
• The constructor initializes ref to refer to an external variable.
• Modifying ref through the Number object also modifies the external variable.

Example 2: Swapping Arrays Elements Using References

This example demonstrates using references to swap elements in an array.

#include <iostream>
using namespace std;

// Function to swap two elements in an array
void swapElements(int &a, int &b) {
    int temp = a;
    a = b;
    b = temp;
}

int main() {
    int arr[] = {1, 2, 3, 4, 5};

    cout << "Array before swap: ";
    for (int i = 0; i < 5; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;

    // Swap the first and last elements
    swapElements(arr[0], arr[4]);

    cout << "Array after swap: ";
    for (int i = 0; i < 5; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;

    return 0;
}

Output

Array before swap: 1 2 3 4 5
Array after swap: 5 2 3 4 1

Explanation

• The swapElements function swaps two elements in an array using references.
• The elements of the array are swapped and printed before and after the swap.

Conclusion

References in C++ provide a way to create aliases for variables, allowing you to access and modify the variables using different names. This chapter covered how to declare and use references, pass references to functions, return references from functions, and use constant references. It also provided example programs to demonstrate the use of references in classes and array element swapping. Understanding how to use references effectively will help you write more efficient and readable code.