class A

{

private:

    const int a = 11;    //直接定死

    const int b;

    const int c;

public:

    A(int a1,int a2) :c(a2),b(a1)    //构造之前的声明:注意成员变量的初始化顺序和声明的顺序相关-->先是c后是b

    {

        //this->b = a1;    //这样是不允许的,这是再赋值修改，只能在声明中修改

    }

    void getInfo()

    {

        cout << "a:" << a << endl;

        cout << "b:" << b << endl;

        cout << "c:" << c << endl;

    }

};

void main()

{

    A a(,);

    a.getInfo();

    system("pause");

}

class B

{

private:

    int a, b, c;

public:

    B()

    {

        cout << "调用默认构造" << endl;

    }

    B(int a, int b, int c)

    {

        this->a = a;

        this->b = b;

        this->c = c;

    }

    void getInfo()

    {

        cout << "a:" << a << endl;

        cout << "b:" << b << endl;

        cout << "c:" << c << endl;

    }

};

class A

{

private:

    const int c;

    B b;    //在类中是变量声明，不会进行构造为对象

public:

    A(int a1,int a2,int a3):b(a1,a2,a3),c(a1)

    {

        //this->b = a1;    //这样是不允许的,这是再赋值修改，只能在声明中修改

    }

    void getInfo()

    {

        cout << "c:" << c << endl;

        b.getInfo();

    }

};

void main()

{

    A a(,,);

    a.getInfo();

    system("pause");

}

.当类中有成员变量是其他类的对象时，必须先调用成员变量的构造函数，调用顺序与声明顺序一致，之后才会调用自己的构造函数

.析构函数调用顺序与对应的构造函数调用顺序相反

class A

{

private:

    const int c;

    int af=;

    //设置友元函数声明  不受访问限制符影响

    friend void FriendSet(A *ptr, int n);    //第一个参数代表当前对象，其他自己设置

    //类似于在外部设置一个函数接口，可以让所有用户进行修改访问

    //但是不受访问修饰符限制，类的封装性丢失

public:

    A(int a1,int a2,int a3):c(a1)

    {

    }

    void getInfo()

    {

        cout << "c:" << c << endl;

        cout << "af:" << af << endl;

    }

};

void FriendSet(A *ptr, int n)    //第一个参数代表当前对象　　在类的外部实现

{

    ptr->af = n;

}

void main()

{

    A a(,,);

    FriendSet(&a, );

    a.getInfo();

    system("pause");

}

若B类是A类的友元类，则B类的所欲成员函数都是A类的友元函数

class A

{

private:

    const int c;

    int af=;

    friend class B;　　//也是不受访问限制符影响

public:

    A(int a1,int a2,int a3):c(a1)

    {

    }

    void getInfo()

    {

        cout << "c:" << c << endl;

        cout << "af:" << af << endl;

    }

};

class B

{

private:

    A Aobj;　　//这是声明，必须在构造函数中进行初始化

public:

    void Set(int i)

    {

        Aobj.af = i;    //可以直接访问私有

    }

    B() :Aobj(10, 11, 12)    //必须设置构造函数

    {

    }

    void Get()

    {

        cout << "c:" << Aobj.c << endl;

        cout << "af:" << Aobj.af << endl;

    }

};

void main()

{

    B Bobj;    //会调用构造函数

    Bobj.Set();

    Bobj.Get();

    system("pause");

}