C++ References Explained — Aliases, Pass-by-Reference & Pitfalls

#include <iostream>
#include <string>

int main() {
    int playerScore = 42;

    // 'scoreAlias' is a reference — another name for 'playerScore'
    // No new memory is allocated for scoreAlias itself
    int& scoreAlias = playerScore;

    std::cout << "Before change:" << std::endl;
    std::cout << "  playerScore  = " << playerScore  << std::endl;
    std::cout << "  scoreAlias   = " << scoreAlias   << std::endl;

    // Modifying via the alias modifies the original variable
    scoreAlias += 10;

    std::cout << "After scoreAlias += 10:" << std::endl;
    std::cout << "  playerScore  = " << playerScore  << std::endl; // 52
    std::cout << "  scoreAlias   = " << scoreAlias   << std::endl; // 52

    // Both addresses are identical — they ARE the same variable
    std::cout << "Address of playerScore : " << &playerScore  << std::endl;
    std::cout << "Address of scoreAlias  : " << &scoreAlias   << std::endl;

    // References to other types work identically
    std::string playerName = "Aria";
    std::string& nameRef   = playerName;
    nameRef = "Aria the Bold";  // modifies playerName directly

    std::cout << "playerName is now: " << playerName << std::endl;

    return 0;
}

#include <iostream>
#include <string>
#include <vector>

// BAD: takes a copy — caller's vector is never modified
void addEntryByValue(std::vector<std::string> leaderboard, const std::string& entry) {
    leaderboard.push_back(entry); // modifies the local copy only
}

// GOOD: takes a reference — modifies the caller's actual vector
void addEntryByRef(std::vector<std::string>& leaderboard, const std::string& entry) {
    leaderboard.push_back(entry); // modifies the real leaderboard
}

// const& — efficient read-only access, zero copying
void printLeaderboard(const std::vector<std::string>& leaderboard) {
    std::cout << "--- Leaderboard ---" << std::endl;
    for (int rank = 0; rank < static_cast<int>(leaderboard.size()); ++rank) {
        // leaderboard[rank] = "cheat"; // compiler error — const prevents this
        std::cout << "  #" << (rank + 1) << "  " << leaderboard[rank] << std::endl;
    }
}

// Swaps two integers using references — classic demo
void swapScores(int& firstScore, int& secondScore) {
    int temp  = firstScore;
    firstScore  = secondScore;
    secondScore = temp;
    // No return needed — we modified the originals directly
}

int main() {
    std::vector<std::string> topPlayers = {"Aria", "Bowen", "Chen"};

    // Pass by value — topPlayers is unchanged after this call
    addEntryByValue(topPlayers, "Dana");
    std::cout << "After addEntryByValue, size = " << topPlayers.size() << std::endl; // still 3

    // Pass by reference — topPlayers is modified
    addEntryByRef(topPlayers, "Dana");
    std::cout << "After addEntryByRef, size  = " << topPlayers.size() << std::endl; // now 4

    printLeaderboard(topPlayers);

    int highScore = 980;
    int runnerUp  = 750;
    std::cout << "\nBefore swap: highScore=" << highScore << ", runnerUp=" << runnerUp << std::endl;
    swapScores(highScore, runnerUp);
    std::cout << "After swap:  highScore=" << highScore << ", runnerUp=" << runnerUp << std::endl;

    return 0;
}

#include <iostream>
#include <string>

struct PlayerProfile {
    std::string name;
    int         level;
};

// Reference version: clean syntax, caller guaranteed to pass a real object
void levelUpWithRef(PlayerProfile& profile) {
    profile.level++;                          // dot syntax, no dereferencing needed
    std::cout << profile.name << " is now level " << profile.level << std::endl;
}

// Pointer version: must handle the nullable case
void levelUpWithPointer(PlayerProfile* profilePtr) {
    if (profilePtr == nullptr) {              // null check is mandatory
        std::cout << "No profile provided." << std::endl;
        return;
    }
    profilePtr->level++;                      // arrow syntax required for member access
    std::cout << profilePtr->name << " is now level " << profilePtr->level << std::endl;
}

int main() {
    PlayerProfile warrior = {"Aria", 10};

    // Reference call — natural, no address-of operator needed
    levelUpWithRef(warrior);

    // Pointer call — must pass address explicitly
    levelUpWithPointer(&warrior);

    // Pointers can be reseated — references cannot
    PlayerProfile mage = {"Bowen", 5};
    PlayerProfile* ptr = &warrior;
    std::cout << "ptr points to: " << ptr->name << std::endl; // Aria

    ptr = &mage;  // reseating: now points to mage — legal for pointers
    std::cout << "ptr now points to: " << ptr->name << std::endl; // Bowen

    // References cannot be reseated:
    PlayerProfile& ref = warrior;
    ref = mage;   // This does NOT rebind ref — it COPIES mage into warrior!
    std::cout << "warrior.name after ref = mage: " << warrior.name << std::endl; // Bowen
    // warrior has been overwritten. ref still refers to warrior's memory.

    return 0;
}

#include <iostream>
#include <vector>
#include <string>
#include <stdexcept>

class ScoreBoard {
public:
    ScoreBoard() : scores_({100, 200, 300}) {}

    // SAFE: returns reference to a member — the member outlives this call
    std::vector<int>& getScores() {
        return scores_;
    }

    // SAFE: returns reference to element inside our member vector
    int& scoreAt(int index) {
        if (index < 0 || index >= static_cast<int>(scores_.size())) {
            throw std::out_of_range("Index out of range");
        }
        return scores_[index]; // vector element lives as long as the ScoreBoard does
    }

private:
    std::vector<int> scores_;
};

// DANGEROUS: returns reference to a local variable — undefined behaviour
// Uncomment to see the compiler warning (GCC: -Wreturn-local-addr)
/*
int& getBadReference() {
    int localScore = 42;         // lives on the stack, destroyed when function returns
    return localScore;           // WARNING: address of local variable returned
}                                // localScore is now gone — the reference is dangling
*/

int main() {
    ScoreBoard board;

    // Modify an element through the returned reference — this is idiomatic C++
    board.scoreAt(1) = 999;  // assigns 999 directly into scores_[1]

    // Get the whole vector by reference and modify it
    std::vector<int>& liveScores = board.getScores();
    liveScores.push_back(400); // actually modifies the ScoreBoard's internal vector

    std::cout << "Scores after modification:" << std::endl;
    for (int score : board.getScores()) {
        std::cout << "  " << score << std::endl;
    }

    // const reference extends the lifetime of a temporary (C++ lifetime extension rule)
    const std::string& greeting = std::string("Hello, ") + "Aria";
    // The temporary string is kept alive because a const ref is bound to it
    std::cout << greeting << std::endl; // safe

    return 0;
}