C ++：将对象传递给类构造函数，它是如何存储的？

Question

考虑以下 C++ 中的简单类实现示例。

foo.hpp

#include <vector>
class Foo {
private:
    std::vector<double> X;
public:
    Foo() = default;
    ~Foo() = default;
    Foo(std::vector<double>&);
};

foo.cpp

#include "Foo.hpp"
Foo::Foo(std::vector<double>& X):
        X(X)
{}

在这种情况下，向量 X 通过引用传递给类 Foo 的构造函数。不过，我开始怀疑实现中的操作 X(X) 是否会复制并将其“粘贴”到类的成员 X 中。

这是什么？

Answer 1

是的，数据成员X将从构造函数参数X复制初始化。

如果将数据成员X 声明为引用，则不会发生复制操作。例如

class Foo {
private:
    std::vector<double>& X;
public:
    ~Foo() = default;
    Foo(std::vector<double>&);
};

Foo::Foo(std::vector<double>& X):
        X(X)
{}

然后

std::vector<double> v;
Foo f(v); // no copies; f.X refers to v

Answer 2

在您的示例中，X（Foo 类的成员）是copy-constructed。防止复制的一种解决方案是将 X 定义为 Foo 类中的 lvalue reference，尽管它不是适用于所有情况的通用解决方案，并且如果原始 X 的范围可能是危险的（导致悬空引用）在 Foo 还活着的时候完成！总而言之，根据您的应用，您可以选择以下选项之一

1. 使用lvalue reference对X，如果每个可能的Foo对象的作用域都低于传递的对象（X）：

   foo.hpp

   #include <vector>
   class Foo {
   private:
       std::vector<double> &X;
   public:
       Foo() = default;
       ~Foo() = default;
       Foo(std::vector<double>&);
   };
   

   foo.cpp

   #include "Foo.hpp"
   Foo::Foo(std::vector<double>& X):
           X(X) // keep the lvalue refrence to the passed Object
   {}
   

然后

std::vector<double> v;
Foo f(v); // no copies; f.X refers to v
// Foo function calls including f.X should be finished before destruction of the v Object

1. 如果在调用 Foo 构造函数后 X 内容不应该通过传递的对象名称使用，则将 X 转换为 rvalue reference (std::move) 并将其移动到 Foo 类的成员 X：

   foo.hpp

    #include <vector>
    class Foo {
    private:
        std::vector<double> X;
    public:
        Foo() = default;
        ~Foo() = default;
        Foo(std::vector<double>&&);
    };
   

   foo.cpp

    #include "Foo.hpp"
    Foo::Foo(std::vector<double>&& X):
            X(std::move(X)) // move constructor of std::vector<double> is called in this line
    {}
   

然后

std::vector<double> v = {1.0, 2.0, 3.0}; 
Foo f(std::move(v)); // no copies; f.X use resource of v, but v is empty now
// v is empty now

1. 最后一种方法与您的实现完全相同。在这种情况下： foo.hpp

    #include <vector>
    class Foo {
    private:
        std::vector<double> X;
    public:
        Foo() = default;
        ~Foo() = default;
        Foo(const std::vector<double>&);
    };
   

   foo.cpp

    #include "Foo.hpp"
    Foo::Foo(const std::vector<double>& X): // using const is better! in this case
            X(X) // copy constructor of std::vector<double> is called in this line
    {}
   

然后

std::vector<double> v = {1.0, 2.0, 3.0};
Foo f(v); // do copies; f.X copy the resource of v, and v is still valid

话虽如此，所有这些方法都有自己的应用程序，视情况而定。为了清楚起见，只需简单地应用此优先级规则：
1- 传递rvalue reference，结果为成员move constructor。 （例如，当您想将一个对象传递给 std::thread 构造函数，以及所有权，即资源，以及资源生命周期！）。
2- 传递 lvalue reference 并保留它，当传递的对象生命周期（在这些示例中为 v）大于引用生命周期时。
3- 传递const lvalue reference 并让copy constructor 被调用（在这些示例中为std::vector 的copy constructor），当最后的选择不适用时，由于进一步使用传递的对象或由于@ 987654341@传递的Object。

Answer 3

放心。该成员的类型是vector<double>，因此编译器将在vector<double> 类中查找与提供的参数类型（vector<double>&）匹配的构造函数重载。

它将找到的最佳匹配是 const vector<double>& 重载 - 复制构造函数。

Answer 4

作为替代方案，您可以为类创建一个带有右值引用的构造函数：

#include <vector>
class Foo {
private:
    std::vector<double> X;
public:
    Foo() = default;
    ~Foo() = default;
    Foo(const std::vector<double>&);
    Foo(std::vector<double>&&);
};

那么构造函数会这样实现：

Foo::Foo(std::vector<double>&& X_) : X(std::move(X_)) {}

调用此构造函数时不进行复制。