04 References, Move Semantics & Enums

Overview: Aliasing and Resource Migration

C++ optimizes parameter passing and resource handling using References and Move Semantics. It also enhances type safety through scoped enums (enum class).

---

1. References (Type&): Under the Hood

A Reference acts as an alias for an existing variable.

std::string original = "Hello";
std::string& ref = original; // ref is an alias to original

Compiler Implementation:

Under the hood, compilers implement references as constant pointers (Type* const) that are automatically dereferenced by the compiler on every access.

• No Reassignment: ref = otherVar does not change what ref refers to; it copies the value of otherVar into original.
• No Null References: A reference must be bound to a valid memory location during initialization; there is no null reference.

Pass-by-Const-Reference (const Type&):

To pass large objects to functions efficiently, pass them by const reference. This avoids deep copy overhead while preventing the function from modifying the original object.

---

2. Lvalues vs. Rvalues, Temporaries, and Lifetime Extension

• Lvalue (Locator Value): A variable that occupies a identifiable location in memory (has an address) and persists beyond a single expression.
• Rvalue (Read Value): A temporary value that does not persist beyond the expression that evaluates it (e.g., the return value of a function returning by value).

Lifetime Extension:

Normally, a temporary object is destroyed at the end of the statement. However, binding a temporary object to a const lvalue reference extends its lifetime to match the scope of that reference:

const std::string& ref = getTemporaryString(); // String persists until ref leaves scope

---

3. Rvalue References (Type&&) & Move Semantics

C++11 introduced Rvalue References (Type&&) to support Move Semantics.

void process(std::string& s);  // Lvalue reference: handles persistent variables
void process(std::string&& s); // Rvalue reference: handles temporary values

The Concept of Move Semantics:

When creating an object from a temporary (rvalue) object, we don’t need to perform a costly deep copy of its heap resources. Instead, we can steal (move) the internal resource pointers from the temporary object into the new object, setting the temporary’s internal pointers to nullptr.

Copy: [New Object] gets a fresh copy of [Temp's Heap Memory]
Move: [New Object] takes the pointer to [Temp's Heap Memory]; [Temp] pointer becomes nullptr

---

4. Scoped, Type-Safe Enums (enum class)

Traditional C-style enums (enum) have two major weaknesses:

1. Scope Leak: Names of enum constants leak into the surrounding scope, causing name conflicts.
2. Implicit Casts: Enums implicitly convert to integers, bypassing type checks.

Scoped Enums (enum class):

C++11 scoped enums solve these issues:

enum class ECarTypes : uint8_t { // Explicitly set storage type (1 byte)
    Sedan,
    Hatchback
};

• No Scope Leak: Must be accessed via ECarTypes::Sedan.
• No Implicit Casts: Will not implicitly convert to integers without an explicit static_cast.

---

💻 Conceptual Code Demonstration

#include <iostream>
#include <string>
#include <utility> // For std::move
 
class ResourceHolder {
    std::string* data;
public:
    ResourceHolder() : data(new std::string("Heap Resource")) {}
    ~ResourceHolder() { delete data; }
 
    // 1. Copy Constructor (Deep Copy)
    ResourceHolder(const ResourceHolder& other) {
        data = new std::string(*other.data);
        std::cout << "Deep copied resource!\n";
    }
 
    // 2. Move Constructor (Resource Transfer)
    ResourceHolder(ResourceHolder&& other) noexcept {
        data = other.data;    // Transfer pointer ownership
        other.data = nullptr;  // Leave temporary object in empty state
        std::cout << "Moved resource pointer (zero-copy)!\n";
    }
};
 
enum class EStatus : uint8_t { Pending, Active, Completed };
 
int main() {
    // 3. Move semantics demonstration
    ResourceHolder a;
    std::cout << "Creating copy:\n";
    ResourceHolder b = a;            // Triggers Copy Constructor
    
    std::cout << "Creating move:\n";
    ResourceHolder c = std::move(a); // Triggers Move Constructor (std::move casts to rvalue)
    
    // 4. Scoped enum type safety
    EStatus status = EStatus::Active;
    // int val = status; // ERROR: Will not compile implicitly!
    int val = static_cast<int>(status); // Compile-time explicit cast
    
    return 0;
}