How to use C++ move semantics and perfect forwarding - 面试题

C++ Move Semantics and Perfect Forwarding

Move semantics and perfect forwarding introduced in C++11 are core features for modern C++ performance optimization, significantly improving program performance by reducing unnecessary copy operations.

Move Semantics

Lvalues and Rvalues:

Lvalue: Named objects that can have their address taken, typically on the left side of assignment operators
Rvalue: Temporary objects, literals, objects about to be destroyed, typically on the right side of assignment operators

cpp
int a = 10;    // a is lvalue, 10 is rvalue
int b = a + 5; // b is lvalue, a + 5 is rvalue

std::move: std::move converts an lvalue to an rvalue reference, enabling move semantics.

cpp
std::string str1 = "Hello";
std::string str2 = std::move(str1);  // Move construction, str1 becomes empty
// str1 is now in a valid but unspecified state

Move Constructor and Move Assignment Operator

Move constructor:

cpp
class MyString {
private:
    char* data;
    size_t size;
    
public:
    // Regular constructor
    MyString(const char* str = "") {
        size = strlen(str);
        data = new char[size + 1];
        strcpy(data, str);
    }
    
    // Copy constructor
    MyString(const MyString& other) {
        size = other.size;
        data = new char[size + 1];
        strcpy(data, other.data);
        std::cout << "Copy constructor called" << std::endl;
    }
    
    // Move constructor
    MyString(MyString&& other) noexcept {
        data = other.data;
        size = other.size;
        other.data = nullptr;
        other.size = 0;
        std::cout << "Move constructor called" << std::endl;
    }
    
    // Copy assignment operator
    MyString& operator=(const MyString& other) {
        if (this != &other) {
            delete[] data;
            size = other.size;
            data = new char[size + 1];
            strcpy(data, other.data);
        }
        std::cout << "Copy assignment called" << std::endl;
        return *this;
    }
    
    // Move assignment operator
    MyString& operator=(MyString&& other) noexcept {
        if (this != &other) {
            delete[] data;
            data = other.data;
            size = other.size;
            other.data = nullptr;
            other.size = 0;
        }
        std::cout << "Move assignment called" << std::endl;
        return *this;
    }
    
    ~MyString() {
        delete[] data;
    }
};

Advantages of Move Semantics

Performance improvement:

cpp
// Without move semantics
std::vector<std::string> createVector() {
    std::vector<std::string> vec;
    vec.push_back("Hello");
    vec.push_back("World");
    return vec;  // Before C++11, deep copy occurs
}

// With move semantics
std::vector<std::string> createVectorMove() {
    std::vector<std::string> vec;
    vec.push_back("Hello");
    vec.push_back("World");
    return vec;  // After C++11, move occurs, avoiding deep copy
}

// Usage
auto vec = createVectorMove();  // Move construction, no copy

Container operation optimization:

cpp
std::vector<MyString> vec;
vec.reserve(10);

MyString str1("Hello");
vec.push_back(str1);           // Copy construction
vec.push_back(std::move(str1)); // Move construction, faster

vec.emplace_back("World");     // In-place construction, fastest

Perfect Forwarding

Perfect forwarding allows function templates to perfectly forward their arguments to other functions, preserving the value category (lvalue or rvalue) of the arguments.

std::forward:

cpp
template <typename T>
void wrapper(T&& arg) {
    target(std::forward<T>(arg));  // Perfect forwarding
}

void target(const std::string& str) {
    std::cout << "Lvalue reference: " << str << std::endl;
}

void target(std::string&& str) {
    std::cout << "Rvalue reference: " << str << std::endl;
}

// Usage
std::string str = "Hello";
wrapper(str);              // Forwards as lvalue reference
wrapper(std::string("World"));  // Forwards as rvalue reference

Reference collapsing rules:

T& & → T&
T& && → T&
T&& & → T&
T&& && → T&&

Universal References

Universal References are references declared using T&& that can bind to lvalues or rvalues.

cpp
template <typename T>
void process(T&& arg) {
    // arg is a universal reference
    if constexpr (std::is_lvalue_reference_v<T>) {
        std::cout << "Lvalue reference" << std::endl;
    } else {
        std::cout << "Rvalue reference" << std::endl;
    }
}

// Usage
int x = 42;
process(x);              // T = int&, binds to lvalue
process(42);             // T = int, binds to rvalue

Note: T&& is only a universal reference in type deduction contexts, otherwise it's an rvalue reference.

cpp
template <typename T>
class MyClass {
    void process(T&& arg);  // Rvalue reference, not universal reference
};

template <typename T>
void process(T&& arg);      // Universal reference

Practical Application Examples

Smart pointer factory function:

cpp
template <typename T, typename... Args>
std::unique_ptr<T> makeUnique(Args&&... args) {
    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}

// Usage
class Widget {
public:
    Widget(int x, double y) : x_(x), y_(y) {}
private:
    int x_;
    double y_;
};

auto widget = makeUnique<Widget>(10, 3.14);

Thread task wrapper:

cpp
template <typename F, typename... Args>
auto createTask(F&& f, Args&&... args) {
    return std::async(std::forward<F>(f), std::forward<Args>(args)...);
}

// Usage
void task(int x, const std::string& str) {
    std::cout << "Task: " << x << ", " << str << std::endl;
}

auto future = createTask(task, 42, "Hello");

Container insertion optimization:

cpp
template <typename Container, typename T>
void insert(Container& container, T&& value) {
    container.push_back(std::forward<T>(value));
}

// Usage
std::vector<std::string> vec;
std::string str = "Hello";
insert(vec, str);              // Copy insertion
insert(vec, std::string("World"));  // Move insertion

noexcept Specification

Move operations should be marked as noexcept so the standard library can use moves instead of copies during reallocation.

cpp
class MyClass {
public:
    MyClass(MyClass&& other) noexcept {
        // Move constructor implementation
    }
    
    MyClass& operator=(MyClass&& other) noexcept {
        // Move assignment implementation
        return *this;
    }
};

Best Practices

1. Prefer move semantics

cpp
// Recommended
std::string result = std::move(tempString);

// Not recommended
std::string result = tempString;  // Unnecessary copy

2. Use emplace series functions

cpp
// Recommended
vec.emplace_back(args...);  // In-place construction

// Not recommended
vec.push_back(Type(args...));  // May create temporary objects

3. Correctly use std::forward

cpp
template <typename T>
void wrapper(T&& arg) {
    // Correct
    target(std::forward<T>(arg));
    
    // Wrong
    target(arg);  // Always lvalue
    target(std::move(arg));  // Always rvalue
}

4. State of moved-from objects

cpp
std::string str1 = "Hello";
std::string str2 = std::move(str1);

// str1 is in a valid but unspecified state
// Can be safely assigned or destroyed
str1 = "New value";  // OK
std::cout << str1.length();  // OK, but value is undefined

5. Avoid using std::move on const objects

cpp
const std::string str = "Hello";
std::string str2 = std::move(str);  // Won't move, will copy

Common Errors

1. Overusing std::move

cpp
// Wrong
std::string str = "Hello";
std::cout << std::move(str);  // Unnecessary, may affect performance

// Correct
std::cout << str;

2. Using object after move

cpp
std::string str1 = "Hello";
std::string str2 = std::move(str1);
std::cout << str1;  // Undefined behavior

3. Using std::move when returning local variables

cpp
// Wrong
std::string createString() {
    std::string str = "Hello";
    return std::move(str);  // Prevents RVO
}

// Correct
std::string createString() {
    std::string str = "Hello";
    return str;  // Compiler will optimize automatically
}

4. Forgetting noexcept

cpp
// Not recommended
MyClass(MyClass&& other);  // No noexcept

// Recommended
MyClass(MyClass&& other) noexcept;  // Allows standard library optimization

Performance Comparison

cpp
#include <chrono>
#include <vector>

class BigObject {
private:
    std::vector<int> data;
    
public:
    BigObject(size_t size) : data(size) {}
    
    BigObject(const BigObject& other) : data(other.data) {
        std::cout << "Copy" << std::endl;
    }
    
    BigObject(BigObject&& other) noexcept : data(std::move(other.data)) {
        std::cout << "Move" << std::endl;
    }
};

void benchmark() {
    const size_t size = 1000000;
    
    // Copy performance test
    auto start = std::chrono::high_resolution_clock::now();
    std::vector<BigObject> vec1;
    for (size_t i = 0; i < 100; ++i) {
        BigObject obj(size);
        vec1.push_back(obj);  // Copy
    }
    auto end = std::chrono::high_resolution_clock::now();
    auto copy_time = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
    
    // Move performance test
    start = std::chrono::high_resolution_clock::now();
    std::vector<BigObject> vec2;
    for (size_t i = 0; i < 100; ++i) {
        BigObject obj(size);
        vec2.push_back(std::move(obj));  // Move
    }
    end = std::chrono::high_resolution_clock::now();
    auto move_time = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
    
    std::cout << "Copy time: " << copy_time.count() << " ms" << std::endl;
    std::cout << "Move time: " << move_time.count() << " ms" << std::endl;
}

Move semantics and perfect forwarding are important components of modern C++. Using them correctly can significantly improve program performance, especially when dealing with large objects and containers.