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

Question

Trying to understand how to make assignment class operator. Member variable constant_name is used to identify object. Member variable changeable_name is used to get affect during assignment. I need this to understand who effects who and what is result of that. Each object gets unique constant_name during creation.

    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();
}

When = operator is described in code at the top I have output:

 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 

Field changable_name was coppyed from AA to A and that is fine.

Now if I remove reference sign in turbo value :

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

I have following in output:

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 

New object AAA was created and assigned to object A . AA had no influence at all. Why compiler decides to activate copy constructor and then assignment operator? I suppose Copy constructor was activated in right hand side of "=" operator.

Another case.

Now if I remove reference sign in turbo operator :

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

I have following in output:

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 

That completely confused me. I suppose AAA was created in left hand side of = . AAA has done no action at all in assignment. In result A was assigned to AA . But why it was needed to create AAA?

Answer 1

When you don't pass the argument by reference in the copy-assignment operator, then the compiler copies the argument you pass, and the function uses that copy. That the function called is the copy-assignment operator doesn't matter, it's the same for all functions.

Search and read more about pass-by-value and pass-by-reference.

As for the return value, the same thing happens there: The compiler creates a copy of the returned value. If you had properly implemented your copy-constructor to actually copy something, the result would have been different.

Answer 2

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

Answer 3

If you don't define below functions in your class then compiler will provide its own versions

default constructor

copy constructor

assignment operator overload

destructor

Now in your second case you have removed the reference from the argument so its a case of pass by value and it was achieved by invoking copy-constructor.

And in third case it is return by value instead of by reference, so the copy ctor again gets called after the job of = operator is done and hence the output.