【C++】类与对象理解和学习（下）

本章知识点概括Ⅰ

本章知识点概括Ⅱ

初始化列表

前言

在上一篇文章中，我们学习了构造函数，以用来实现自定义类型的自动初始化，但是我们当时的方式真的是真正意义上的初始化吗？我们知道，所谓初始化，是伴随着一个变量被创建出来时一起存在的。换句话来说，初始化只能有一次，即随着变量的创建而产生。而我们以往的方式实际上是一种赋值，通过函数体来实现赋值。

也就是说，我们之前的操作并不是真正的初始化操作，我们还可以再次进行验证一下。假如我们的类成员变量里存在一个const类型的变量。（const修饰的变量具有常数性，即只能初始化一次，初始化后的值就是该变量的值，不可再被修改）。

那么针对这种现象，应如何解决呢？这就运用到了此次的初始化列表

初始化列表的使用

使用方式：

以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式。（程序运行时，会先走初始化列表，再走构造函数的函数体，即在进入函数体之前，变量已经被初始化列表进行初始化）

注意事项

对于一般类型的成员变量，我们可以使用初始化列表，也可以使用函数体赋值的方式，实现初始化。但是对于以下几种，则必须使用初始化列表：

const修饰的变量

引用成员变量

自定义类型成员（且该自定义类型没有默认构造函数时）

因此建议大家：能使用初始化列表，就使用初始化列表！

初始化列表的初始顺序

初始化列表的初始化顺序取决于声明的顺序！如下：

总结起来就一句话：能用初始化列表初始化，就用初始化列表！

explicit关键字

隐式类型转换

我们知道，在进行赋值操作时，假如两边类型不匹配，我们会用（）进行强制类型转换，比如int a=(int)1.1,我们将浮点型数据强制转换为了整型数据，这种 由我们自己进行的类型转换叫做显示类型转换。

而与之对应的便是 隐式类型转换，由编译器来自动实现。比如我们这么来写：int a = 1.1;这中间便发生了隐式类型转换。同样，对于自定义类型也会发生隐式类型转换，如下：

但是实际上运行的结果是什么呢？

我们会发现编译器并没有调用拷贝构造，这是为什么呢？这是由于我们的编译器对此进行了优化，直接将构造+拷贝构造优化为直接构造。（后面会讲编译器的优化，这里我们只需要明白，自定义类型也会发生隐式类型转换）

同样，C++11中支持多参的构造函数进行隐式类型转换。如下：

不过这种隐式类型转换的代码可读性太差了，为了限制自定义类型对象的这种行为，我们可以使用关键字explicit，我们在构造函数前面加上explicit，就会禁止这种隐式类型转换行为。如下：

static成员

修饰普通对象

早在C语言阶段我们就见识过该关键字，static修饰的变量存放在静态区，只能初始化一次，生命周期随着整个程序的结束而结束。

放在类中修饰类成员

static修饰的类成员成为静态成员函数/静态成员变量，具有如下特征：

静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区

静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明

类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问

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

静态成员也是类的成员，受public、protected、private 访问限定符的限制

我们通过如下案例来更好的理解：

不仅如此，静态成员函数不可以访问类成员变量，但是，类成员函数可以访问静态成员变量！

那么它有什么用呢？实际上用处确实不是很常用，但是在有些场景下就会用起来比较舒服，就比如下面的一个牛客题目，用它来做会很舒服,大家可以试一下（点击传送）。

友元函数与友元类

友元函数

友元函数可以 直接访问类的 私有成员，它是 定义在类外部的 普通函数，不属于任何类，但需要在类的内部声明，声明时需要加 friend关键字。也就是说，友元函数会突破private的限制， 使普通的函数也可以访问类中的成员变量。如下：

class A
{
    //将函数定义放在类中，并加上friend，使其成为友元函数，实现对类中private限制的成员变量的访问
    friend int Get_a(const A& d);
public:    
    A()
        :_a(10)
    {}
private:
    int _a;
};
//普通的函数，按理说无法访问private限制的类成员变量，但是我们成为友元函数后，就可以进行访问了
int Get_a(const A& d)
{
    return d._a;
}
int main()
{
    A aa;
    cout << Get_a(aa) << endl;//10
}

这里有以下几点需要注意：

友元函数是单向的，即我是你的友元函数，我可以访问你，但是你不可以访问我。

友元函数不具有传递性。即a是b的友元，b是c的友元，但是这里a不是c的友元

友元函数可以在类定义的任何地方声明，不受类访问限定符限制

友元函数不能用const修饰

一个函数可以是多个类的友元函数

友元函数的调用与普通函数的调用原理相同

不具有继承性（后面讲到继承时会提）

友元类

与友元函数相通，这里我们将一个类的声明放在另一个类中，并在前面加上friend关键字，就会变成这个类的友元类。就可以实现对该类中的私有成员进行正常访问。（注意事项与友元函数相同）

class Time
{
    friend class Date;// 声明日期类为时间类的友元类，则在日期类中就直接访问Time类中的私有成员变量
public:
    Time(int hour = 0, int minute = 0, int second = 0)
        : _hour(hour)
        , _minute(minute)
        , _second(second)
    {}
private:
    int _hour;
    int _minute;
    int _second;
};
class Date
{
public:
    Date(int year = 1900, int month = 1, int day = 1)
        : _year(year)
        , _month(month)
        , _day(day)
    {}
    void SetTimeOfDate(int hour, int minute, int second)
    {
        // 直接访问时间类私有的成员变量
        _t._hour = hour;
        _t._minute = minute;
        _t._second = second;
    }
private:
    int _year;
    int _month;
    int _day;
    Time _t;
};

注意，这里Date是Time的友元类，Date可以访问Time的私有成员变量，但是Time类不可以访问Date中的私有成员变量。（原因与成员函数相同，单向性）。

内部类

如果一个类定义在另一个类的内部，这个内部类就叫做内部类。也就是在类中定义一个类。当然，这种情况我们实际上并不常用，不过该知道的还是要知道。

先来看以下它的特点

天生就是外部类的友元，即内部类可以访问外部类的私有成员变量

独立存在，不参与计算外部类的大小。

受类访问限定符的限制，如果定义在private里，则无法被直接调用

对于外部类的static成员变量，内部类可以直接使用，不需要外部类的对象/类名。

class A
{
private:
    static int _a;
    int _b = 10;;
public:
    //B是A的内部类，不参与A对象的大小计算，B天生是A的友元类
    //受类访问限定符的影响
    class B
    {
    public:
        void test(const A& d)
        {
            cout << d._b << endl;//可以访问外部类的私有成员变量
            cout << _a << endl;//直接使用static成员
        }
    private:
        int _c;
    };
};
int A::_a = 20;
int main()
{
    A a;
    A::B b;//定义内部类（此时处于public，可以通过类作用域限定符来定义）
    b.test(a);//10 20
    cout << sizeof(a) << endl;//大小为4,内部类不参与外部类大小计算
}

匿名对象

匿名对象，匿名，即不用取名字。我们可以这样来定义一个类对象。

特点：“死的快”（生命周期只有一行），实例化对象时不用取名字。

拷贝对象时编译器的优化

在前面就已经提到了编译器进行的一些优化，这里我们再来谈一谈，编译器会在哪些情况下进行优化，会怎么进行优化呢？我们来定义这么一个类，来进行观察

class A
{
public:
    //构造
    A(int a = 10)
        :_a(a)
    {
        cout << "A(int a=10)" << endl;
    }
    //拷贝构造
    A(const A& aa)
        :_a(aa._a)
    {
        cout << "A(const A& aa)" << endl;
    }
    //运算符重载
    A& operator=(const A& aa)
    {
        cout << "A& operator=(const A& aa)" << endl;
        if (this != &aa)
        {
            _a = aa._a;
        }
        return *this;
    }
    //析构
    ~A()
    {
        cout << "~A()" << endl;
    }
private:
    int _a;
};

传参时的优化

void func1(A a)
{}
void func2(const A& a)
{}

传返回值的优化