目录

再谈构造函数 

构造函数体赋值

初始化列表

explicit关键字

static成员

访问静态成员变量的方法

C++11中成员初始化的新玩法

友元

         友元函数

友元类

内部类

再次理解封装

再次理解面向对象

---

内容大纲：

再谈构造函数 

构造函数体赋值

在对象创建时，编译器会通过调用构造函数，给对象中的各个成员变量一个合适的初始值：

class Date
{
public:
    // 构造函数
    Date(int year = 0, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }
private:
    int _year;
    int _month;
    int _day;
};

注：构造函数只是为变量赋初值，并不是初始化，初始化只有一次，而构造函数体内可以进行多次赋值。

初始化列表

初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个成员变量后面跟一个放在括号中的初始值或表达式。是成员变量定义的地方。

class Date
{
public:
    //初始化列表
    Date(int year = 0, int month = 1, int day = 1)
        :_year(year)
        , _month(month)
        , _day(day)
    {}

private:
    int _year;
    int _month;
    int _day;
};

注意：

1.每个成员变量只能在初始化列表出现一次，变量的初始化只有一次

2.类中以下几种变量，必须在初始化列表初始化。

①const修饰的成员变量，定义时必须初始化。

const int a = 10;//correct 创建时就初始化

const int b;//error 创建时未初始化

②引用成员变量,定义时必须初始化

int& b = a; //correct 
int& c;//erro

class Date
{
public:
    //初始化列表

    Date(int i = 1, int d = 2)
        :_i(i)
        , _d(d)
    {
        //_i = 1;//erro,左值指定const对象,这里报错说明到构造函数体内时，成员变量已经定义出来了
    }
private:
    const int _i;
    int& _d;
};
 

③没有默认构造函数的自定义类型 

默认构造函数：1.用户没写编译器默认生成的  2.用户写的无参的构造函数 3.用户写的全缺省构造函数

class A  
{
public:
    A(int val) //这个不是默认构造函数，需要传参调用
    {
        _val = val;
    }
private:
    int _val;
};

class B
{
public:
    B()
       :_a(2021) //必须使用初始化列表对其进行初始化
    {}
private:
    A _a; //自定义类型成员且没有默认构造函数
};

3.尽量使用初始化列表初始化

初始化列表就是当你实例化一个对象时，该对象的成员变量定义的地方，无论用否，编译器都会走这个过程。

①对于内置类型，随便哪种方式都可以

②对于自定义类型，使用初始化列表可以提高效率

class Time
{
public:
    Time(int hour = 0)
    {
        _hour = hour;
    }
private:
    int _hour;
};
class Test
{
public:
    // 使用初始化列表
    Test(int hour)
        :_t(12)// 只需要调用一次Time类的构造函数
    {}
private:
    Time _t;
};

使用了初始化列表，在实例化过程中只调用了一次Time类的构造函数。

若不使用初始化列表

class Time
{
public:
    Time(int hour = 0)
    {
        _hour = hour;
    }
private:
    int _hour;
};

class Test
{
public:
    
    Test(int hour)
    { //初始化列表调用一次Time类的构造函数（不使用初始化列表但也会走这个过程）
        Time t(hour);// 调用一次Time类的构造函数
        _t = t;// 调用一次Time类的赋值运算符重载函数
    }
private:
    Time _t;
};

在实例化过程中会先在初始化列表时调用一次Time类的构造函数，然后在实例化t对象时调用一次Time类的构造函数，最后还需要调用了一次Time类的赋值运算符重载函数，效率就不高

4.成员变量在类中声明的次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后顺序无关

这道题的答案是什么？

class A
{
public:
    A(int a)
        :_a1(a)
        , _a2(_a1)
    {}

    void Print() {
        cout << _a1 << " " << _a2 << endl;
    }
private:
    int _a2;
    int _a1;
};

int main() 
{
    A aa(1);
    aa.Print();
    return 0;
}

A . 输出 1 1

B . 程序崩溃

C . 编译不通过

D . 输出 1 随机值

不过这是以前编译器的处理方式，现在的编译器做了优化，直接这样处理：Date d1(2022), 这也是隐式类型转换。

int a = 10;

double d = a;//这就是经典隐式类型转换。

const int& c = d;//这里引用变量c必须用const修饰，临时变量具有常性

在这个过程中，编译器会先构建一个double类型的临时变量接收a的值，然后再将该临时变量的值赋值给b

对于单参数的自定义类型来说，Date d1 = 2021这种代码的可读性不是很好，我们若是想禁止单参数构造函数的隐式转换，可以用关键字explicit来修饰构造函数。 

static成员

概念：声明为static的类成员称为类的静态成员。用static修饰的成员变量，称之为静态成员变量；用static修饰的成员函数，称之为静态成员函数。静态成员变量一定要在类外进行初始化。

1.静态成员变量必须在类外定义，定义时不添加static关键字

class Pride
{
private:
    static int _a;
};

int Pride::_a = 1;

静态成员变量虽然是私有，但是我们在类外突破类域直接对其进行了访问，这是唯一一个不受访问限定符的限制，否则就没办法对静态成员变量进行定义和初始化了。

 2.静态成员为所以类对象所共享，不属于某个具体的对象

class Pride
{
private:
    int _b;
    static int _a;
};
int main()
{
    Pride p;
    cout << sizeof(p) << endl;//打印结果为4，不是8
}

说明静态成员变量属于整个类或者对象，计算类的大小或是类对象的大小时，静态成员并不计入其总大小之和。

3.静态成员函数没有隐藏的this指针，不能访问任何非静态成员 

class Pride
{
public :
    static void PrintVal()
    {
        cout << _a;//静态成员函数仅仅可以访问静态成员变量
        cout << _b;//非静态成员变量不能访问
    }
private:
    int _b;
    static int _a;
};

说明：含有静态成员变量的类，一般含有一个静态成员函数，用于访问静态成员变量

访问静态成员变量的方法

1.当静态成员变量为公有时，有以下几种访问方式：

class Pride
{
public:
    static int _a;
};
int Pride::_a = 1;//初始化静态变量
int main()
{
    Pride p;
    cout << p._a << endl;//通过实例化对象来访问
    cout << Pride()._a << endl;//通过匿名对象来访问
    cout << Pride::_a << endl;//通过类名来访问
}

2. 当静态成员变量为私有时，有以下几种访问方式：

class Pride
{
public :
    static int GetVar()
    {
        return _a;
    }
private:
    static int _a;
};
int Pride::_a = 1;
int main()
{
    Pride p;
    p.GetVar();//通过实例化对象调用成员函数访问
    Pride().GetVar();//通过匿名对象调用成员函数访问
    Pride::GetVar();//通过类名调用静态成员函数进行访问
}

静态成员和类的普通成员一样，也有public、private和protected这三种访问级别，所以当静态成员变量设置为private时，尽管我们突破了类域，也不能对其访问。

注意区分两个问题：
1.静态成员函数可以调用非静态成员函数吗？不能
2.非静态成员函数可以调用静态成员函数吗？ 能

原因：

第一问：因为非静态成员函数的第一个形参默认为this指针，而静态成员函数中没有this指针，故静态成员函数不可调用非静态成员函数。

第二问：因为静态成员函数和非静态成员函数都在类中，在类中不受访问限定符的限制。

C++11中成员初始化的新玩法

C++11支持非静态成员变量在声明时进行初始化赋值，但是要注意这里不是初始化，这里是给声明的成员变量一个缺省值。

class Pride
{
private:
    int _a = 10;
    int _c = 20;//缺省值
};

这就是对构造函数不处理内置类型打的一个补丁（用缺省值）

初始化列表才是成员变量定义初始化的地方，你若是给定了值，就用你所给的值对成员变量进行初始化，你若没有给值，则用缺省值进行初始化，若是没有缺省值，则内置类型的成员就是随机值。

友元

友元分为友元函数和友元类。友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。

友元函数

友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需要加friend关键字。

对于之前实现的日期类，我们现在尝试重载operator<<及operator>>,但是我们并不能在类里面实现，因为cout的输出流对象和隐含的this指针在抢占第一个参数的位置：this指针默认是第一个参数，即左操作数，但是实际使用中cout需要是第一个形参对象才能正常使用。如果在类里面实现，那么调用只能这样d<<cout，

所以我们实现成全局函数，但是全局函数不能访问类中私有成员变量，这时候就需要实现成友元函数。

class Data
{
    // 友元函数的声明，可以在类的随意位置

    friend ostream& operator<<(ostream& out, const Data& d);

    friend istream& operator>>(istream& in, Data& d);
public:
    Data(int year = 0, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }
private:
    int _year;
    int _month;
    int _day;
};
// <<运算符重载
ostream& operator<<(ostream& out, const Date& d)
{
    out << d._year << "-" << d._month << "-" << d._day<< endl;
    return out;
}
// >>运算符重载
istream& operator>>(istream& in, Date& d)
{
    in >> d._year >> d._month >> d._day;
    return in;
}

其中cout是ostream类的一个全局对象，cin是istream类的一个全局变量，<<和>>运算符的重载函数具有返回值是为了实现连续的输入和输出操作。

友元函数说明：
1、友元函数可以访问类是私有和保护成员，但不是类的成员函数。
2、友元函数不能用const修饰。
3、友元函数可以在类定义的任何地方声明，不受访问限定符的限制。
4、一个函数可以是多个类的友元函数。
5、友元函数的调用与普通函数的调用原理相同。

友元类

友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中非公有成员

class A
{
    // 声明B是A的友元类
    friend class B;
public:
    A(int n = 0)
        :_n(n)
    {}
private:
    int _n;
};

class B
{
public:
    void Test(A& a)
    {
        // B类可以直接访问A类中的私有成员变量
        cout << a._n << endl;
    }
};

友元类说明：
1、友元关系是单向的，不具有交换性。
例如上述代码中，B是A的友元，所以在B类中可以直接访问A类的私有成员变量，但是在A类中不能访问B类中的私有成员变量。
2、友元关系不能传递。
如果A是B的友元，B是C的友元，不能推出A是C的友元。

内部类

概念:如果一个类定义在另一个类的内部，则这个类被称为内部类

注意：
1.此时的内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象区调用内部类。
2.外部类对内部类没有任何优越的访问权限。
3.内部类就是外部类的友元类，即内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。

特性：

1.内部类可以定义在外部类的public、private以及protected这三个区域中的任一区域。
2.内部类可以直接访问外部类中的static、枚举成员，不需要外部类的对象/类名。
3.外部类的大小与内部类的大小无关。

再次理解封装

C++是基于面向对象的程序，面向对象有三大特性：封装、继承、多态。

 

再次理解面向对象

可以看出，面向对象其实是在模拟抽象映射现实世界：