构造函数调用已创建的对象

Question

如果我在已经构造的对象或结构上调用构造函数， 它将分配新空间，还是仅使用现有空间？那么第一次对象分配是否更耗费资源呢？像这样：

struct F {
    int a,b,c,d;
    F(int _a, int _b) {a = _a; b = _b}; 
    void a(int _a, int _b) {a = _a; b = _b};
};  

//first constructor call
F f = F(5, 6);

//second constructor call on an already constructed object
f = F(7, 8);

//third constructor call on an already constructed object
f(7, 8);

//is the constructor call more res. intesive, than the call to a function which does the same? 
f.a(9, 0)

构造函数调用是否比调用具有相同功能的函数（void a(...)）更占用资源？

当我在已创建的对象上调用构造函数时，析构函数是否会被调用？

Answer 1

首先，[c] 标记不合适，因为构造函数是 C++ 独有的功能。我假设您提供的代码片段实际上是 C++，而不是 C 的某种奇怪的方言。C++ 和 C 是不同的语言；不要将您的问题标记为两者，因为每个问题都会得到不同的答案。

其次，你的构造函数定义是错误的。构造函数必须与类本身具有完全相同的名称。所以 f() 应该是 F()。是的，C++ 中区分大小写很重要！我假设这就是您对代码片段其余部分的意思。 _{OP 只是犯了一个拼写错误。}

在我解释其余代码的作用之前，您必须了解所有C++ 中的类（和结构）具有编译器自动生成的特殊成员函数，如果您不要提供它们。也就是说，您的代码片段基本上与以下内容相同：

struct F
{
    F(int _a, int _b) {a = _a; b = _b};  // constructor
    ~F() {}                              // destructor
    F(const F& rhs)                      // copy constructor
        : a(rhs.a)
        , b(rhs.b)
        , c(rhs.c)
        , d(rhs.d)
    {}
    F& operator=(const F& a)             // copy assignment operator
    {
        a = rhs.a;
        b = rhs.b;
        c = rhs.c;
        d = rhs.d;
        return *this;
    }

    void a(int _a, int _b) {a = _a; b = _b};   // one of your functions

    int a;
    int b;
    int c;
    int d;
};

如果您没有定义复制构造函数、复制赋值运算符或析构函数，则编译器将为您生成它们。另外，如果您不提供其他构造函数，编译器将生成默认构造函数。类 F 没有默认构造函数，因为已经有一个接受两个参数的（非复制）构造函数。

复制构造函数和复制赋值运算符的默认实现只是复制每个数据成员。

存在特殊成员函数的原因是因为 C++ 概括了将基本类型复制到用户定义对象的概念。考虑一下：

int a = 42;
int b = 13;
b = a;

对于像 int 这样的基本类型，您可以像这样复制它的值。 C++ 将复制语义推广到对象，因此您可以执行以下操作：

F f(10, 20); // calls first constructor
F g(30, 40); // calls first constructor
g = f;       // calls g's copy-assignment operator.

现在您可以看到这如何应用于您的代码：

F f = F(5,6); 

上面的行构造一个临时 F 对象，然后将临时对象复制到 f< /code> 通过复制构造函数。然后临时F对象被破坏。

f = F(7,8);

上面的行构造了另一个临时 F 对象，然后通过复制赋值运算符将该临时对象分配给 f 。然后临时F对象被破坏。原始的 f 对象没有被破坏。

f.a(9,0)   

上面的行是对名为 f 的对象的正常函数调用。

对于您的代码片段，假设编译器不会优化临时变量（实际上通常会这样做），那么调用函数 a 会“占用更少的资源”，因为在这种情况下不会生成临时变量。但是，对于您的第一次构造函数调用，您可以这样做：

F f(5,6); // Constructor called; no temporaries are made

了解构造函数的用途：它们用于创建对象。如果你已经有一个对象，那么你不需要调用构造函数。

正如我多次推荐的那样，请挑选一本优秀的 C++ 书籍并阅读它。特殊成员函数及其作用对于 C++ 来说非常基础。

Answer 2

（在您发布的代码中，您在构造函数中使用了小写的 f 而不是大写的 F，我认为这是一个拼写错误）

您的问题很有趣，因为您提出的问题和您提出的代码写的都不一样。在代码中，您编写了

f = F(7, 8);

This does call F 构造函数，但不在现有的 f 对象上。相反，这会创建一个临时 F 对象，该对象通过调用以 7 和 8 作为参数的 tue 构造函数进行初始化，然后使用赋值运算符将现有的 f 变量设置为等于该新对象。因此，构造函数不会在对象上被调用两次；相反，这里调用的是分配。更一般地，如果您为现有对象分配新值，则将使用赋值运算符而不是构造函数来进行复制。这将重用对象的现有内存，尽管它可能会触发辅助内存分配和释放。

没有安全的方法可以两次调用对象的构造函数。如果您确实想调用已创建的对象的构造函数，则可以使用放置 new 来实现：

F f(3, 5);
new (&f) F(7, 9);

这是不安全的，因为它绕过了析构函数通常会执行的典型资源清理，并盲目地覆盖现有元素，因此这几乎是从未在实践中做过。我提到它主要是出于好奇和完整性。 :-)

Answer 3

我忽略OP中的实现，直接进入QA：

如果我在已经构造的对象/结构上调用构造函数，它会分配新空间

吗？不会，该对象不会被重新分配。将调用构造函数的实现（例如函数调用）。

那么第一次对象分配是否更耗费资源？

通常你不应该这样做，除非你正在实现一个集合（例如vector）。

但是，回答这个问题：是的，第二个需要更少的指令。编译器生成简单的指令来设置分配（如果在堆栈上或其他地方）。所以自动创建对象确实有几个阶段，而您正在绕过其中的一些阶段。但认真地说：不要将此视为一种优化 - 仅在绝对必要时才手动调用构造函数/析构函数（再次考虑集合类型）。

构造函数是否调用更多资源。比调用具有相同功能的函数更复杂 (void a(...)) ？

潜在地，编译器的努力也会发挥作用。请记住，构造函数和析构函数调用层次结构中每个类的实现，因此...如果您的类层次结构不平凡，那么单个函数很可能会更快。

当我在已创建的对象上调用构造函数时，析构函数是否会被调用？

如果您以这种方式显式构造一个对象，那么答案是“不”。您的工作就是适当地配对显式调用。你不能错误地实施这个，它和 UB 一样好。顺序始终是construct->destruct。

只是为了清楚所使用的语法：

// explicit ctor
new(ptr) T(ctorArgument);
// explicit dtor
ptr->~T();

Answer 4

您的程序中存在语法错误，修改您的代码

struct F {

    int a,b,c,d;

    F(int _a, int _b) {a = _a; b = _b}; 

    void a(int _a, int _b) {a = _a; b = _b};

};

F f = F(5,6); // Here the default copy constructor gets called.
              // i.e., F( const F& obj ) ;

f = F(7,8);   // A temporary is created is assigned to `f` through default copy assignment operator.
              // i.e., F& operator=( const F& obj );

片段 - 当构造的对象超出范围时（即，当对象的生命周期完成时），析构函数被调用。

Answer 5

你的类 F 没有构造函数，只有方法 f。因此，任何时候都不会调用构造函数。