Common Pitfalls

While modern C++ provides powerful features, it also introduces subtle pitfalls. Understanding errors like dangling captures and use-after-move is key to writing safe code.

The Danger of Use-After-Move

Calling std::move casts an object to an rvalue reference, allowing other objects to steal its resources. After a move:

While the moved-from object (s1) remains in a valid state (and can be reassigned), its contents are unspecified. Reading its value without re-initializing it leads to undefined behavior.

Code Walkthrough

Illustrates common C++ pitfalls and demonstrates their safe, modern alternatives.

#include <iostream>
#include <string>
#include <functional>
// PITFALL: Returns a reference to a temporary local variable
const std::string& getDanglingName() {
    std::string name = "Temporary";
    return name; // Compiler warns: reference to local variable returned
}
// SAFE: Returns the object by value, leveraging Return Value Optimization (RVO)
std::string getSafeName() {
    std::string name = "Safe";
    return name;
}
int main() {
    // 1. Use-after-move pitfall
    std::string text = "Initial Content";
    std::string target = std::move(text);
// std::cout << text; // DANGEROUS: text is in an unspecified state
    text = "New Content"; // Re-initialization is safe
    std::cout << "text: " << text << "\n";
// 2. Dangling capture pitfall
    std::function<void()> func;
    {
        std::string localMsg = "Message";
        // func = [&localMsg] { std::cout << localMsg; }; // PITFALL: localMsg will be out of scope
        func = [localMsg] { std::cout << "Capture: " << localMsg << "\n"; }; // SAFE: Captured by value
    }
    func(); // Safe to execute because localMsg was captured by value
return 0;
}

Interview-Relevant Information