1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

#include <iostream>

class BigObject {
public:
    BigObject() { std::cout << "Default Constructor\\n"; }
    BigObject(const BigObject&) { std::cout << "Copy Constructor\\n"; }
    BigObject(BigObject&&) { std::cout << "Move Constructor\\n"; }
    ~BigObject() { std::cout << "Destructor\\n"; }
};

// 没有优化的版本
BigObject createWithoutRVO() {
    BigObject obj;      // 1. 构造局部对象
    return obj;         // 2. 拷贝/移动构造返回值
}                       // 3. 析构局部对象

int main() {
    BigObject result = createWithoutRVO();  // 4. 拷贝/移动构造result
    return 0;
}
// 可能的输出：
// Default Constructor
// Move Constructor
// Destructor
// Move Constructor
// Destructor
// Destructor

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

// 编译器优化后的实际效果
BigObject createWithRVO() {
    // 编译器直接在result的内存位置上构造
    return BigObject{};  // RVO - 返回临时对象
}

BigObject createWithNRVO() {
    BigObject local;     // NRVO - 返回具名对象
    // 编译器优化：local直接构造在返回值位置
    return local;
}

int main() {
    BigObject obj1 = createWithRVO();   // 没有拷贝！
    BigObject obj2 = createWithNRVO();  // 也没有拷贝！
    return 0;
}
// 输出：
// Default Constructor (只构造一次)
// Default Constructor (只构造一次)
// Destructor
// Destructor

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

#include <iostream>
#include <string>

class Person {
private:
    std::string name;
    int age;

public:
    Person(const std::string& n, int a) : name(n), age(a) {
        std::cout << "Person constructed: " << name << "\\n";
    }

    Person(const Person& other) : name(other.name), age(other.age) {
        std::cout << "Person copied: " << name << "\\n";
    }

    Person(Person&& other) noexcept
        : name(std::move(other.name)), age(other.age) {
        std::cout << "Person moved: " << name << "\\n";
    }

    ~Person() {
        std::cout << "Person destroyed: " << name << "\\n";
    }
};

// RVO 示例 - 返回临时对象
Person createPersonRVO(const std::string& name, int age) {
    return Person(name, age);  // 返回临时对象 - RVO适用
}

// NRVO 示例 - 返回具名对象
Person createPersonNRVO(const std::string& name, int age) {
    Person p(name, age);  // 具名局部对象
    // 可能有一些额外的操作
    if (age < 0) age = 0;
    return p;  // 返回具名对象 - NRVO适用
}

int main() {
    std::cout << "=== RVO Demo ===\\n";
    Person p1 = createPersonRVO("Alice", 25);

    std::cout << "\\n=== NRVO Demo ===\\n";
    Person p2 = createPersonNRVO("Bob", 30);

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

// 源代码
BigObject createObject() {
    return BigObject(42);
}

// 编译器眼中的代码（概念性等价）
void createObject(BigObject* result) {
    // 直接在result指向的内存构造对象
    new (result) BigObject(42);
}

// 调用方
BigObject obj;  // 编译器可能不实际分配内存
createObject(&obj);  // 直接在使用obj的地方构造

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

#include <iostream>
#include <vector>
#include <memory>

class Shape {
public:
    virtual ~Shape() = default;
    virtual void draw() const = 0;
};

class Circle : public Shape {
    double radius;
public:
    explicit Circle(double r) : radius(r) {
        std::cout << "Circle created\\n";
    }

    void draw() const override {
        std::cout << "Drawing circle, radius: " << radius << "\\n";
    }
};

class Rectangle : public Shape {
    double width, height;
public:
    Rectangle(double w, double h) : width(w), height(h) {
        std::cout << "Rectangle created\\n";
    }

    void draw() const override {
        std::cout << "Drawing rectangle: " << width << "x" << height << "\\n";
    }
};

// 工厂函数 - RVO 优化
Shape* createShape(const std::string& type) {
    if (type == "circle") {
        return new Circle(5.0);  // 返回指针，没有RVO问题
    }
    return new Rectangle(3.0, 4.0);
}

// 更好的设计 - 使用智能指针
std::unique_ptr<Shape> createShapeModern(const std::string& type) {
    if (type == "circle") {
        return std::make_unique<Circle>(5.0);  // RVO对unique_ptr也适用
    }
    return std::make_unique<Rectangle>(3.0, 4.0);
}

// 值语义的工厂 - RVO最适用
template<typename T>
T createFromVector(const std::vector<int>& data) {
    T result;
    for (int x : data) {
        result.insert(x);  // 假设T有insert方法
    }
    return result;  // NRVO
}

int main() {
    auto circle = createShapeModern("circle");
    circle->draw();
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

#include <iostream>
#include <string>
#include <algorithm>

class StringProcessor {
public:
    // RVO - 返回临时对象
    static std::string toUpper(std::string s) {
        std::transform(s.begin(), s.end(), s.begin(), ::toupper);
        return s;  // NRVO
    }

    // RVO - 返回临时对象
    static std::string concatenate(const std::string& a, const std::string& b) {
        return a + b;  // RVO - 返回临时对象
    }

    // NRVO with multiple return paths
    static std::string process(const std::string& input, bool uppercase) {
        std::string result = input;

        // 一些处理
        if (uppercase) {
            std::transform(result.begin(), result.end(), result.begin(), ::toupper);
        } else {
            std::transform(result.begin(), result.end(), result.begin(), ::tolower);
        }

        // 编译器通常能对单return路径进行NRVO
        // 如果有多个return，可能无法优化
        return result;
    }

    // 更好的多路径写法
    static std::string processBetter(const std::string& input, bool uppercase) {
        // 直接在返回值位置构造
        return uppercase ? toUpper(input) : toLower(input);
    }

private:
    static std::string toUpper(const std::string& s) {
        std::string result = s;
        std::transform(result.begin(), result.end(), result.begin(), ::toupper);
        return result;  // NRVO
    }

    static std::string toLower(const std::string& s) {
        std::string result = s;
        std::transform(result.begin(), result.end(), result.begin(), ::tolower);
        return result;  // NRVO
    }
};

int main() {
    std::string hello = "Hello, World!";

    // 这些调用都不会产生拷贝
    std::string upper = StringProcessor::toUpper(hello);
    std::string combined = StringProcessor::concatenate("Hello", "World");
    std::string processed = StringProcessor::processBetter(hello, true);

    std::cout << upper << "\\n";
    std::cout << combined << "\\n";
    std::cout << processed << "\\n";
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

#include <iostream>
#include <vector>
#include <cmath>

template<typename T>
class Matrix {
private:
    std::vector<T> data;
    size_t rows, cols;

public:
    Matrix(size_t r, size_t c) : rows(r), cols(c), data(r * c) {}

    // 运算符重载 - 返回临时对象，RVO优化
    Matrix operator+(const Matrix& other) const {
        Matrix result(rows, cols);
        for (size_t i = 0; i < data.size(); ++i) {
            result.data[i] = data[i] + other.data[i];
        }
        return result;  // NRVO
    }

    Matrix operator*(T scalar) const {
        Matrix result(rows, cols);
        for (size_t i = 0; i < data.size(); ++i) {
            result.data[i] = data[i] * scalar;
        }
        return result;  // NRVO
    }

    // 链式操作 - RVO/NRVO 避免中间临时对象
    friend Matrix operator*(T scalar, const Matrix& m) {
        return m * scalar;  // RVO
    }
};

int main() {
    Matrix<double> m1(100, 100);
    Matrix<double> m2(100, 100);

    // 复杂的表达式，如果没有RVO会产生大量临时对象
    Matrix<double> result = m1 + m2 * 2.0;  // RVO优化

    // 等价于：
    // Matrix<double> temp1 = m2 * 2.0;  // 可能被优化掉
    // Matrix<double> temp2 = m1 + temp1; // 可能被优化掉
    // Matrix<double> result = temp2;      // 直接构造result
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

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

class QueryBuilder {
private:
    std::vector<std::string> conditions;
    std::string table;

public:
    QueryBuilder() = default;

    // 链式调用 - 每个方法返回新对象
    QueryBuilder from(const std::string& t) const {
        QueryBuilder result = *this;
        result.table = t;
        return result;  // NRVO
    }

    QueryBuilder where(const std::string& cond) const {
        QueryBuilder result = *this;
        result.conditions.push_back(cond);
        return result;  // NRVO
    }

    std::string build() const {
        std::string query = "SELECT * FROM " + table;
        if (!conditions.empty()) {
            query += " WHERE ";
            for (size_t i = 0; i < conditions.size(); ++i) {
                if (i > 0) query += " AND ";
                query += conditions[i];
            }
        }
        return query;  // RVO
    }
};

int main() {
    // 链式调用，每个中间结果都通过RVO优化
    std::string query = QueryBuilder{}
        .from("users")
        .where("age > 18")
        .where("status = 'active'")
        .build();

    std::cout << query << "\\n";
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

std::string badNRVO(bool condition) {
    std::string a = "Hello";
    std::string b = "World";

    if (condition) {
        return a;  // 返回a
    } else {
        return b;  // 返回b - 编译器无法确定返回哪个对象
    }
}

std::string goodRVO(bool condition) {
    // 直接返回临时对象，RVO始终可用
    return condition ? "Hello" : "World";
}

std::string goodNRVO(bool condition) {
    std::string result;
    if (condition) {
        result = "Hello";
    } else {
        result = "World";
    }
    return result;  // 单一返回点，NRVO可能应用
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

class Container {
    std::vector<int> data;

public:
    // NRVO不适用 - 返回成员变量
    std::vector<int> getData() const {
        return data;  // 必须拷贝，因为data是成员
    }

    // 更好的方式
    const std::vector<int>& getDataRef() const {
        return data;  // 返回引用，避免拷贝
    }

    // 或者使用移动语义
    std::vector<int> takeData() {
        return std::move(data);  // 移动而非拷贝
    }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

class Complex {
    double re, im;

public:
    Complex(double r, double i) : re(r), im(i) {}

    // 条件运算符返回临时对象 - RVO适用
    static Complex max(const Complex& a, const Complex& b) {
        return a.re > b.re ? Complex(a.re, a.im) : Complex(b.re, b.im);
    }

    // 或者使用三元运算符直接返回
    static Complex max_simple(const Complex& a, const Complex& b) {
        return a.re > b.re ? a : b;  // 返回引用？不，这里会拷贝
    }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

#include <iostream>

struct GuaranteedRVO {
    GuaranteedRVO() { std::cout << "Constructor\\n"; }
    GuaranteedRVO(const GuaranteedRVO&) = delete;  // 删除拷贝构造函数
    GuaranteedRVO(GuaranteedRVO&&) = delete;       // 删除移动构造函数
};

// C++17 之前：编译错误，因为需要拷贝/移动构造函数
// C++17 之后：完全合法，保证省略拷贝

GuaranteedRVO createObject() {
    return GuaranteedRVO{};  // C++17: 保证直接在返回值位置构造
}

int main() {
    GuaranteedRVO obj = createObject();  // 只调用一次构造函数
    return 0;
}
// 输出: Constructor

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

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

class Demo {
    std::string name;

public:
    Demo(const std::string& n) : name(n) {
        std::cout << "Constructor: " << name << "\\n";
    }

    Demo(const Demo& other) : name(other.name + " (copy)") {
        std::cout << "Copy Constructor: " << name << "\\n";
    }

    Demo(Demo&& other) noexcept : name(std::move(other.name) + " (move)") {
        std::cout << "Move Constructor: " << name << "\\n";
    }

    ~Demo() {
        std::cout << "Destructor: " << name << "\\n";
    }
};

// 不同返回方式的比较
Demo returnByValue() {
    Demo local("local");
    return local;  // NRVO 可能应用，否则移动
}

Demo returnWithMove() {
    Demo local("local");
    return std::move(local);  // 强制移动，阻止NRVO
}

Demo returnTemporary() {
    return Demo("temporary");  // RVO 保证应用(C++17)
}

int main() {
    std::cout << "=== NRVO possible ===\\n";
    Demo d1 = returnByValue();

    std::cout << "\\n=== Forced move ===\\n";
    Demo d2 = returnWithMove();

    std::cout << "\\n=== RVO guaranteed ===\\n";
    Demo d3 = returnTemporary();

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

class BestPractices {
public:
    // 1. 返回临时对象优先于具名对象
    static std::vector<int> createVector1() {
        return std::vector<int>{1, 2, 3, 4, 5};  // RVO guaranteed
    }

    // 2. 如果必须使用具名对象，确保单一返回点
    static std::vector<int> createVector2(size_t size) {
        std::vector<int> result;
        result.reserve(size);
        for (size_t i = 0; i < size; ++i) {
            result.push_back(i);
        }
        return result;  // 单一返回点，NRVO可能应用
    }

    // 3. 不要为了"优化"而使用std::move
    static std::vector<int> createVector3() {
        std::vector<int> v{1, 2, 3};
        // return std::move(v);  // 不好！阻止NRVO
        return v;  // 好！让编译器决定
    }

    // 4. 对于工厂函数，返回值而不是指针
    template<typename T, typename... Args>
    static T create(Args&&... args) {
        return T(std::forward<Args>(args)...);  // RVO适用
    }

    // 5. 复杂初始化使用立即函数
    static std::vector<int> createComplex() {
        // 使用lambda立即执行复杂初始化
        return []{
            std::vector<int> v;
            v.reserve(100);
            for (int i = 0; i < 100; ++i) {
                if (i % 2 == 0) v.push_back(i);
            }
            return v;  // NRVO inside lambda
        }();  // RVO on return
    }
};