C++回顾day02---<对象构造和析构，外加友元函数>

一：若没有显示写构造函数，默认会有一个默认构造函数（无参），若自己构造后，不会存在这个默认构造函数

二：类成员若是有const修饰，必须在对象初始化的时候，为该类成员赋值（或者一开始就定死，同C中）

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(12,13);
    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(12,13,14);
    a.getInfo();
    system("pause");
}

四：构造和析构调用顺序

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

五：补充---友元函数（破坏封装性）

（一）友元函数不受访问限制符影响

（二）友元函数是在类外部的一个函数。可以通过对象参数访问私有数据成员

（三）友元函数使用

class A
{
private:
    const int c;
    int af=0;

    //设置友元函数声明  不受访问限制符影响
    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(12,13,14);
    FriendSet(&a, 111);
    a.getInfo();
    system("pause");
}

六：补充---友元类（破坏封装性）

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

class A
{
private:
    const int c;
    int af=0;
    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(100);
    Bobj.Get();
    system("pause");
}