如何在向量列表初始化时避免对象复制以及如何延长临时对象的生命周期

Question

考虑下面的代码，其中一些“MyType”类的对象存储在一个向量中，然后这个向量被传递给“VectorProcessor”类的一个对象：

// to compile, run: g++ -Wall --std=c++17 test.cpp -o test
#include <vector>
#include <iostream>

using namespace std;

class MyType {
private:
    int x;
public:
    MyType(int a_x) {
        this->x = a_x;
        cout << "MyType constructor; x=" << this->x << endl;
    }
    ~MyType() {
        cout << "MyType destructor; x=" << this->x << endl;
        this->x = 0;
    }
    MyType(const MyType &o)  {
        this->x = o.x +10;
        cout << "MyType copy constructor; x=x'+10=" << this->x << endl;
    }
    MyType& operator=(const MyType& o)  {
        this->x = o.x +20;
        cout << "MyType =copy constructor; x=x'+20=" << this->x << endl;
        return *this;
    }
    MyType(MyType &&o) {
        this->x = o.x + 30;
        cout << "MyType move constructor; x=x'+30=" << this->x << endl;
    }
    MyType & operator=(MyType &&o) {
        this->x = o.x + 40;
        cout << "MyType =move constructor; x=x'+40=" << this->x << endl;
        return *this;
    }
    friend ostream& operator<<(ostream& os, const MyType& s) {
        return os << s.x;
    }
};

template <typename T>
class VectorProcessor {
    private:
        const vector<T> &v;
    public:
        VectorProcessor(const vector<T> &a_lista): v{a_lista} {
            cout << "VectorProcessor constructor" << endl;
        }
        VectorProcessor(const vector<T> &&a_lista): v(a_lista) {
            cout << "VectorProcessor rvalue constructor" << endl;
        }
        const T& getLast() {
            return this->v[this->v.size()-1];
        }
};

int main() {
#if 1
    // test (A)
    vector<MyType> v{1,2,3,4,5};
    VectorProcessor<MyType> r(v);
#else
    // test (B)
    VectorProcessor<MyType> r(vector<MyType>{1,2,3,4,5});
#endif
    cout << "r.getLast(): " << r.getLast() << endl;

    return 0;
}

如果我启用“测试A”，程序输出是：

MyType constructor; x=1
MyType constructor; x=2
MyType constructor; x=3
MyType constructor; x=4
MyType constructor; x=5
MyType copy constructor; x=x'+10=11
MyType copy constructor; x=x'+10=12
MyType copy constructor; x=x'+10=13
MyType copy constructor; x=x'+10=14
MyType copy constructor; x=x'+10=15
MyType destructor; x=5
MyType destructor; x=4
MyType destructor; x=3
MyType destructor; x=2
MyType destructor; x=1
VectorProcessor constructor
r.getLast(): 15
MyType destructor; x=11
MyType destructor; x=12
MyType destructor; x=13
MyType destructor; x=14
MyType destructor; x=15

如果我启用“测试 B”，程序输出是：

MyType constructor; x=1
MyType constructor; x=2
MyType constructor; x=3
MyType constructor; x=4
MyType constructor; x=5
MyType copy constructor; x=x'+10=11
MyType copy constructor; x=x'+10=12
MyType copy constructor; x=x'+10=13
MyType copy constructor; x=x'+10=14
MyType copy constructor; x=x'+10=15
VectorProcessor rvalue constructor
MyType destructor; x=11
MyType destructor; x=12
MyType destructor; x=13
MyType destructor; x=14
MyType destructor; x=15
MyType destructor; x=5
MyType destructor; x=4
MyType destructor; x=3
MyType destructor; x=2
MyType destructor; x=1
r.getLast(): 0

然后我问：不使用指针，或者智能指针，

1) 如何避免在 MyType 类的对象中发生额外的复制（对于测试 A 和 B）？ 2）在“测试B”中，为什么在r.getLast()之前调用了MyType析构函数？也就是说，如何将临时vector<MyType>{1,2,3,4,5}的生命周期延长到块的末尾？

Answer 1

std::initializer_list的设计方式，初始化器相当于：

vector<MyType> v{ MyType(1), MyType(2), MyType(3), MyType(4), MyType(5) };

即它创建临时的MyTypes 来构造初始化列表，然后向量构造函数从初始化列表中复制其元素。有些人认为这是一个错误，但我们现在坚持下去。

为了避免多余的对象，您可以就地构造元素，例如：

vector<MyType> v;
v.reserve(5);
for (int i = 1; i <= 5; ++i)
    v.emplace_back(i);

这段代码有多种包装方式，但这是基本思想。

---

对于您的第二个问题，除了少数例外情况外，临时对象仅存在于创建它们的完整表达式的末尾。绑定到构造函数引用参数不是例外之一。您在test (A) 中的代码是执行此操作的正确方法。