（复制构造函数）作为参数传递的对象如何初始化另一个对象如何访问私有成员？

Question

Example code:

class my
{
    int x;
    public:
    my(int a)
    {
        x = a;
    }
    my(my &obj)
    {
        x = obj.x;
    }
.
.
}

int main(void)
{
    my object1(5);
    my object2(object1);
    return 0;
}

How is object2 initialized by passing it object1? As far as I can see object1 can't access the member x directly, then how does it help in initializing object2?

Answer 1

Private applies to classes not objects . Any object of class X has access to the private members of all other objects of class X.

Answer 2

Access control (public/private/protected) controls whether a piece of code can legally refer to a name of a class's member. Individual objects don't play a role here; the whole problem is just about code and names.

Let's compare the constructor from your question, a friend function and a free function:

class my
{
  int x;

  friend void fr(my&);
public:
  my(my &obj)
  {
    x = obj.x;
  }
};

void fr(my &obj)
{
  obj.x += 1;
}

void nonfr(my &obj)
{
  obj.x += 2;
}

Take the statement x = obj.x; . A statement is a piece of code. Where is that piece of code? Inside the constructor of class my . So it's a part of the class and so it can access the name obj.x .

Next, the statement obj.x += 1; . Where is that piece of code? Inside the function fr , which is a friend of class my . It's a friend, so it can access the name obj.x .

Finally, the statement obj.x += 2; . Where is that piece of code? Inside the function nonfr . nonfr is an ordinary function unrelated to class my , so it has no right to access the names of private (or protected) members of class my , so it will fail to compile.

---

Side notes:

Normally, a copy constructor should take its parameter by reference to const, like this:

my(const my &obj)

Copy constructors which take by non-const reference can modify the source object, and viable use cases for them are extremely rare. Not to mention that they prevent copying from temporaries, since those can't bind to non-const references.

Also, it's generally preferable to use mem-initialiser-lists instead of assignment inside the constructor, because the latter first initialises the member and then assings to it. So in total, the constructor should look like this:

my(const my &obj) : x(obj.x)
{}

Not to mention the fact that unless you need special handling in the copy constructor (which you don't here), you shouldn't declare it at all and let the compiler generate it for you. See Rule of Zero and Rule of Three for more information.