C++ de 一个奇怪的发现

昨天考试才看出，一个对象可以访问类的私有成员，代码说明：

class X {
public:
    X() {}
    X(int _size): size(_size) {}
    X(X& anotherX) {
        size=anotherX.size;
    }
    void show() {
        cout<<size<<endl;
    }
private:
    int size;
};

int main() {
    X x1(100),x2(x1),x3;
    x3=x2;
    x3.show();
    x1.show();
    return 0;
}

其中复制构造函数访问了一个同类对象的私有成员。

然后就去网上参考了答案：

一．
封装性是对类外（而不是对象外）的操作来说的。
所以可以在类X中定义了操作本类的另一个对象，
这样的操作是因为，类知道他处理的就是他自己的一个对象
二．
这个函数是在 class X类体里面的，
被认为是在同一个域里，也就是类域。

Standard C++ 98 has mentioned:
"A member of a class can be
--private;
its name can be used only by menbers and friends of the class in which it is declared."

p.s.

java也是如此

import java.math.BigInteger;

public class Add {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        BigInteger aBig=new BigInteger("100");
        aBig=aBig.add(new BigInteger("100"));
        System.out.println(""+aBig+"\n\n");
        
        
        
        Add a1=new Add(100);
        a1.plus(new Add(100)).display().plus(new Add(100)).display();
        a1.display();
        /*
         the output is
200


here, I am: 200
here, I am: 300
here, I am: 300
         */
    }
    private int a;
    public Add(int _a) {
        a=_a;        
    }
    public Add plus(Add another){
        a+=another.a;
        return this;        
    }
    public Add display() {
        System.out.println("here, I am: "+a);
        return this;
    }
}