类分配运算符和副本构造函数

Question

试图了解如何使分配类运算符。 成员变量constant_name用于标识对象。 成员变量changeable_name用于在分配期间生效。 我需要这样做，以了解谁影响了谁以及结果如何。 每个对象在创建期间都会获得唯一的constant_name 。

    class turbo
        {
    static string m;


    public:

        string changable_name ="";
        string constant_name  ="";
        void nm()
                {
                m=m+"A";
                changable_name=m;
                constant_name=changable_name;
                };

        void printID()
            {
                printf("constant_name=%s changable_name=%s ",constant_name.c_str(),changable_name.c_str());
            };


        turbo() {
                nm();
                printID();
                printf("default constructor \n");
                };

        turbo & operator = (turbo & value){ printID(); printf("= operator\n"); if (!(&value==this)) { changable_name = value.constant_name; } ;  return *this; }

        turbo (turbo&) {nm(); printID(); printf("copy constructor\n");}

        };


    string turbo::m;



int main( int argc, char ** argv )
{
    turbo f;
    turbo ff;

    f=ff;

    printf("--- result ---\n");
    f.printID();
}

当顶部的代码中描述了=运算符时，我将输出：

 constant_name=A changable_name=A default constructor 
 constant_name=AA changable_name=AA default constructor 
 constant_name=A changable_name=A = operator
 --- result ---
 constant_name=A changable_name=AA 

现场changable_name从coppyed AA到A ，那就是罚款。

现在，如果我删除turbo value中的参考符号：

turbo & operator = (turbo  value){ printID(); printf("= operator\n"); if (!(&value==this)) { changable_name = value.constant_name; } ;  return *this; }

我在输出中有以下内容：

constant_name=A changable_name=A default constructor 
constant_name=AA changable_name=AA default constructor 
constant_name=AAA changable_name=AAA copy constructor
constant_name=A changable_name=A = operator
--- result ---
constant_name=A changable_name=AAA 

创建了新对象AAA并将其分配给对象A AA根本没有任何影响。 为什么编译器决定先激活复制构造函数，然后再激活赋值运算符？ 我想在“ =”运算符的右侧激活了复制构造函数。

另一种情况。

现在，如果我删除turbo operator中的参考符号：

turbo operator = (turbo & value){ printID(); printf("= operator\n"); if (!(&value==this)) { changable_name = value.constant_name; } ;  return *this; }

我在输出中有以下内容：

constant_name=A changable_name=A default constructor 
constant_name=AA changable_name=AA default constructor 
constant_name=A changable_name=A = operator
constant_name=AAA changable_name=AAA copy constructor
--- result ---
constant_name=A changable_name=AA 

那完全让我感到困惑。 我想AAA是在=左侧创建的。 AAA根本没有采取任何行动。 结果A被分配给AA 。 但是为什么需要创建AAA？

Answer 1

如果您没有在copy-assignment运算符中通过引用传递参数，则编译器将复制您传递的参数，然后函数使用该副本。 所调用的函数是复制分配运算符并不重要，所有函数都相同。

搜索和阅读有关值传递和引用传递的更多信息。

至于返回值，这里也会发生同样的事情：编译器创建返回值的副本。 如果您正确实现了复制构造函数以实际复制某些内容，则结果将有所不同。

Answer 2

当value参数按值而不是按引用传递时，对&value == this的测试毫无意义，因为在调用成员函数之前在堆栈上创建了一个新的turbo实例，并且该实例的地址显然没有等于调用对象的地址。

Answer 3

如果您未在类中定义以下函数，则编译器将提供其自己的版本

默认构造函数

复制构造函数

赋值运算符重载

析构函数

现在，在第二种情况下，您已从参数中删除了引用，因此它是按值传递的情况，这是通过调用copy-constructor实现的。

在第三种情况下，它是按值而不是引用返回的，因此在完成=运算符的工作并因此输出之后，将再次调用复制ctor。