下面在介绍组合与继承之前，先介绍一下访问限制，访问限制:public、、private、private三者是按照授权的大小排序的。这里有个博客，对这三者有了经典的诠释。
http://blog.csdn.net/artechtor/article/details/2295739
下面先介绍public and private，而protected在继承那里在说。
public： 是指类的内部东西都是公有的，它的访问域在任何地方都可以，比如Class A,A a ; 此时可以用a.的方式使用类中的任意public变量和函数。这个比较简单就不举例子了。
private: （使用与成员变量和成员函数）仅仅属于同一类本身可以访问。
这句话就是说，仅仅可以通过类的成员函数可以访问（作用域仅仅在类的声明那段里）。所以即使在其他函数中用Class A定义一个对象，然后用A.ii 也是不能访问私有成员变量，也就是说private 的变量只能通过成员函数来访问（直接或者间接的使用成员函数的方式）。
第一种：直接用对象调用 (本类的可以操作private成员变量或者private成员函数的) public成员函数来访问private属性的类中函数或者变量。
第二种：一个同类对象可调用类的public成员函数(为指向该类的指针)来访问同一个类的另一个对象的私有成员变量，进而来访问这个类的private成员变量
下面分别举例说明两种情况。
第一种：
代码和结果如下：

#include<iostream>
using namespace std;

class A{
    private:
        int i;
    public:
        A():i(10){}
        void print(){
            cout<<"A.i = "<<i<<endl;
        }
};

int main()
{
    A a;
//    a.i;         //这里取消注释的话就会编译错误 提示 i 是private变量 
    a.print();    
    
    return 0;
}

结果：

第二种：
1、一个对象可以通过成员函数（参数为指向同类的指针）访问另一对象的private变量。代码如下：

#include<iostream>
using namespace std;

class A{
    public:
        int i;
        A():i(10),j(20){}
        void print( A * p){
            p->j = 50;
            cout<<"私有变量p->j= "<<p->j<<endl;
        }
    private:
        int j;
};

int main()
{
    A a;
    A b;
    a.print( &b);//这种是通过成员函数访问同一个类的private成员变量，
                     //这种方式也可以修改对应对象所指向的private变量的值 
}

结果：

2、一个对象不可以通过成员函数（参数为指向异类的指针）访问另一异类对象的private变量。代码如下：

#include<iostream>
using namespace std;
//class B;
class B{
    private:
        int k;
    public:
        B():k(90){}
}; 
class A{
    public:
        int i;
        A():i(10),j(20){}
        void print( A * p){
            p->j = 50;
            cout<<"p->j= "<<p->j<<endl;
        }
        void print( B*p){
            p->k = 1;
            cout<<"p->k= "<<p->k<<endl;
        }
    private:
        int j;
};

int main()
{
    A a;
    A b;
    B c;
//    a.print( &b);//这种是通过成员函数访问同一个类的private成员变量，这种方式也可以修改对应对象所指向的private变量的值 
    a.print(&c);//不同的类之间就不可以访问 
}  

上述代码在编译的时候出现下面的错误：
[Error] 'int B::k' is private

补充：

还需要补充的一点就是，这仅仅是在编译的时候有效的，如果有办法在运行时刻去修改private的成员变量也是可以的。
比如将一个类对象的指针强制转化成下面形式：
A a;
int* p = &a; //这里的a是A类的对象
*p = 20; //这样通过修改地址处的值进而修改类的成员变量
条件： (p 指向的地方恰好是在类中private成员变量所在的位置，因为一个类就是占用了一块内存，所有的成员变量都是依照次序顺序存储的，所以只要获得了类对象的基指针，再知道private成员变量的偏移量就可以在运行的时刻来修改private的值了)
通过上面那种方式就可以修改了private成员变量的值
说明：C++的OOP思想仅仅在源代码里存在（编译成功之前），编译之后的编码就不具有OOP思想了
(也就是说编译器作为规则来限制代码的OOP，但是编译后的.o文件与 C编译后的.o是一样的，都是就变成了过程式)
所以才有了只要在运行时刻能够拿到指针，就可以修改指针指向的内容。