对于C++拷贝构造函数的思考

Posted 2022-09-16 smstong

//
// When a variable contains an object directly,
// copying, assignment and returning becomes complex.
// In C++, "copy constructor" and "assignment operator" are
// necessary for those operations.
//
// In practice, coping objects is rarely needed. So, other OO
// languges usually don't operate on objects directly, but on
// their references(pointers) instead.
//
// For example, in Java/Python, a variable contains a reference(pointer) to
// the actual object. As a result, copying, assignment, and
// returning such a variable are just simple as if it was an
// integer.
//
// In C++, we can use class pointers to mimic references in Java,
// but code full of "*" looks ugly.
//
//

#include <iostream>
using namespace std;
class A

        public:
                // constructor
                A()
                
                        cout << "A::A() being called\\n";
                
                // copy constructor
                A(const A& old_obj)
                
                        cout << "A::A(const A&) being called.\\n";
                
;
// A's copy constructor will be called
void f1(const A obj)

        return;

// A's copy constructor will not be called
void f2(const A& obj)

        return;

A f3(const A& obj)

        // A's copy constructor will be called
        return obj;

// copy constructor will NOT be called
A& f4(A& obj)

        return obj;


int main(int argc, char** argv)

        A o1;
        A o2 = o1; // call copy constructor
        A o3;
        o3 = o1;  // assignment operator
        cout << "f1\\n";
        f1(o1);
        cout << "f2\\n";
        f2(o1);
        cout << "f3\\n";
        f3(o1);
        cout << "f4\\n";
        f4(o1);

RESULT:

$ ./a.out
A::A() being called
A::A(const A&) being called.
A::A() being called
f1
A::A(const A&) being called.
f2
f3
A::A(const A&) being called.
f4