C++-类和对象（下）

一，const成员函数

一般自定类型的对象传参时，都是传引用这样可以减少一次拷贝构造，同时前面加const进行修饰，以免通过引用来改变实体。

class A
{
    
    
public:
    A(int x = 0)
        : _a(x)
    {
    
    
    }
    void Print()
    {
    
    
        cout << _a << endl;
    }

private:
    int _a;
};
void func(const A &a)
{
    
    
    a.Print();
}
int main()
{
    
    
    A a1;
    return 0;
}

这种情况下，我们通过形参a来调用Print()函数，会发生报错。原因是因为这里发生了权限的放大，由于在调用成员函数时有一个默认的形参就是this指针，但a的this指针是被const修饰的，也就是说将 const *this 传给了 *this，这是一个明显的权限放大问题， 为了解决这一问题就要引出const成员函数这一概念。

将const修饰的“成员函数”称之为const成员函数，const修饰类成员函数，实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。并且const是加在成员函数的形参列表的后面。

class A
{
    
    
public:
    A(int x = 0)
        : _a(x)
    {
    
    
    }
    void Print() const
    {
    
    
        cout << _a << endl;
    }

private:
    int _a;
};

思考下面的四个问题：

• const对象可以调用非const成员函数吗？
  答案是不可以。
  const *this 传给 *this 会发生权限的放大。
• 非const对象可以调用const成员函数吗？
  答案是可以。
  *this 是可以传给 const *this 的，这里是权限的缩小。
• const成员函数内可以调用其它的非const成员函数吗？
  答案是不可以。
  const成员函数中，const修饰的是*this ，如果其调用其他非const成员函数，会发生权限的放大。
• 非const成员函数内可以调用其它的const成员函数吗？
  答案是可以。
  *this 传给 const *this 是允许的，这里是权限的缩小。

二，再谈构造函数

1，初始化列表

之前提到类的实例化是对象定义的时候，但对象内部的成员变量是何时被定义的呢？
因为有些变量是要在定义时必须初始化的，比如 const int p；int& a；
初始化列表就是每个成员变量定义的地方 ，初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式。例如下面这样：

class A
{
    
    
public:
    A(int a = 0, int b = 0, int c = 0)
        : _a(a), _b(b), _c(c)
    {
    
    
    }
    void Print() const
    {
    
    
        cout << _a << endl;
    }

private:
    int _a;
    int _b;
    int _c;
};

在调用构造函数的时候，会先进行初始化列表中的内容，在进行构造函数{ } 内部的内容，{ }里的内容实际上是对定义出来的对象进行赋值，而初始化列表是成员变量定义初始化的地方。
注意：

• 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)
• 引用成员变量，const成员变量，自定义类型成员变量且没有默认构造函数时，必须使用初始化列表进行初始化。
• 无论你有没有显示的写出初始化列表，编译器都先使用初始化列表进行初始化。如果没有显示写，那么编译器会去看有没有为成员变量提供缺省值。
• 成员变量在类中的声明次序，就是其在初始化列表中的初始化次序。

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();
}

由于_a2定义在_a1之前，所以在初始化列表中会先对_a2初始化，所以会被初始化成随机值，_a1会被初始化成1.

2，explicit关键字

构造函数不仅可以构造与初始化对象，对于单个参数或者除第一个参数无默认值其余均有默认值的构造函数，还具有类型转换的作用。

class A
{
    
    
public:
    A(int a)
        : _a(a)
    {
    
    
    }

private:
    int _a;
};
int main()
{
    
    
    A a1 = 8;
    return 0;
}

这里的8会调用A类的构造函数，隐式类型转换成A类型，接着通过拷贝构造初始化a1，这里编译器会优化成一个构造函数（后面会讲到）。

class Date
{
    
    
public:
    Date(int year, int month = 1, int day = 1)
        : _year(year), _month(month), _day(day)
    {
    
    
    }

private:
    int _year;
    int _month;
    int _day;
};
int main()
{
    
    
    Date d1 = 2023;
    return 0;
}

这里也会发生隐式类型转换，为了防止这种类型转换可以用explicit 修饰成员函数，来禁止构造函数的隐式类型转换。

class Date
{
    
    
public:
    explicit Date(int year, int month = 1, int day = 1)
        : _year(year), _month(month), _day(day)
    {
    
    
    }

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

三，static成员

声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用static修饰的成员函数，称之为静态成员函数。

特性：

• 静态成员变量必须在类外定义初始化，定义时不添加static关键字，类内只是声明。

class A
{
    
    
public:
    A(int a = 1)
        : _a(a)
    {
    
    
    }

private:
    int _a;
    static int _b;
};
int A::_b = 1;

• 静态成员为所有类对象共享，不属于某个具体对象存放在静态区。
• 类的静态成员可以通过类名::静态成员（前提是public作用域下） 或者对象.静态成员。
• 静态成员函数没有隐藏的this指针，不能访问任何非静态成员。
• 静态成员也是类的成员，受public、protected、private 访问限定符的限制。

思考：

• 实现一个类，计算程序中创建出了多少对象？

分析：由于创建对象时都会调用构造函数或者是拷贝构造，所以在这两个函数上动手脚就可以了。可以定义一个计数器，每次调用这两个函数计数器加1，有人会想到用全局变量做计数器，但是这种做法不是很安全，因为全局函数谁都可以更改。
所以我们采用静态的成员变量充当这个计数器，静态的成语变量不被某个对象所拥有，而是属于整个类的。

class A
{
    
    
public:
    A()
    {
    
    
        _count++;
    }
    A(const A &a)
    {
    
    
        _count++;
    }

private:
    static int _count;
};
void func()
{
    
    
    A a1;
    A a2(a1);
    A a3;
}
int main()
{
    
    
    func();
    return 0;
}

上面这种情况，我们是调用了一个函数，在函数内部创建了许多对象，而出了这个函数我们无法去访问_count，除非我们再创建一个对象，用其去访问_count，最终将_count的值减1。
其实大可不必这样，我们只需再类中publi作用域下定义一个静态的成员函数，起作用就是返回_count的值，这样我们就可以指明类的作用域直接访问这个成员函数，不再需要创建一个新的对象。

class A
{
    
    
public:
    A()
    {
    
    
        _count++;
    }
    A(const A &a)
    {
    
    
        _count++;
    }
    static int sum()
    {
    
    
        return _count;
    }

private:
    static int _count;
};
void func()
{
    
    
    A a1;
    A a2(a1);
    A a3;
}
int main()
{
    
    
    func();
    cout << A::sum() << endl;
    return 0;
}

• 静态成员函数可以调用非静态成员函数吗？

由于静态成员函数中没有this指针这一默认参数，所以其无法去调用非静态成员函数。

• 非静态成员函数可以调用类的静态成员函数吗？

静态成员函数是属于整个类的，可以通过非静态成员函数去访问。

四，友元（friend）

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

1，全局函数做友元

我们之前讲述过运算符重载，但是我们在用成员函数重载<<运算符的时候，会出现问题，因为流插入(<<)操作符有两个操作数，而采用成员函数重载它的时候，this指针充当了第一个操作数，第二个操作数是ostream类的对象，所以使用时会出现下面的情况：
a1 << cout

• ostream类
  

cout实际上是ostream类的一个对象，之所以他能使用cout << 这种形式打印数据，实际上他做了运算符重载+函数重载。

为了解决上述情况，我们用全局函数进行运算符重载：

class A
{
    
    
public:
    A(int a = 0)
        : _a(a)
    {
    
    
    }

private:
    int _a;
};
ostream &operator<<(ostream &_cout, const A &a)
{
    
    
    cout << a._a << endl;
}

但是这种写法是不对的，无法在类外直接访问类的私有成员，所以我们要将这个函数作为A类的友元函数。

class A
{
    
    
    friend ostream &operator<<(ostream &_cout, const A &a);

public:
    A(int a = 0)
        : _a(a)
    {
    
    
    }

private:
    int _a;
};
ostream &operator<<(ostream &_cout, const A &a)
{
    
    
    cout << a._a << endl;
}

说明：

• 友元函数可访问类的私有和保护成员，但不是类的成员函数
• 友元函数不能用const修饰（其没有this指针）
• 友元函数可以在类定义的任何地方声明，不受类访问限定符限制
• 一个函数可以是多个类的友元函数
• 友元函数的调用与普通函数的调用原理相同

2，类做友元

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

• 友元关系是单向的，不具有交换性。

class B;
class A
{
    
    
    friend class B;
    friend ostream &operator<<(ostream &_cout, const A &a);

public:
    A(int a = 0)
        : _a(a)
    {
    
    
    }

private:
    int _a;
};
class B
{
    
    
public:
    B()
    {
    
    
    }

private:
    int _b;
};

B是A的友元类，B类的所有成员函数都可以访问A类的私有成员，但是A类不是B的友元类，A的成员函数无法访问B的私有成员。

• 友元关系不能传递
  如果C是B的友元， B是A的友元，则不能说明C时A的友元。
• 友元关系不能继承。

3，成员函数做友元

class B;
class A
{
    
    
    friend void B::func(const A &a);
    friend ostream &operator<<(ostream &_cout, const A &a);

public:
    A(int a = 0)
        : _a(a)
    {
    
    
    }

private:
    int _a;
};
class B
{
    
    
public:
    B()
    {
    
    
    }
    void func(const A &a)
    {
    
    
        cout << a._a << endl;
    }

private:
    int _b;
};

注意：这样写是会编译不通过的，编译器在编译的时候只会向上去找，不会向下去找，编译器到达 friend void B::func(const A &a);这一行的时候，它并不知道有这个函数，所以要在这之前前先声明一下这个函数，但是成员函数实在类内声明的，所以B类的定义要放在A类的上面。

class A;
class B
{
    
    
public:
    B()
    {
    
    
    }
    void func(const A &a)
    {
    
    
        cout << a._a << endl;
    }

private:
    int _b;
};

class A
{
    
    
    friend void B::func(const A &a);
    friend ostream &operator<<(ostream &_cout, const A &a);

public:
    A(int a = 0)
        : _a(a)
    {
    
    
    }

private:
    int _a;
};

五，内部类

==概念：==如果一个类定义在另一个类的内部，这个内部类就叫做内部类。内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。
==注意：==内部类就是外部类的友元类，参见友元类的定义，内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。
特性：

• 内部类可以定义在外部类的public、protected、private都是可以的。
• 注意内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。

class A
{
    
    
private:
    static int k;
    int h;

public:
    class B // B天生就是A的友元
    {
    
    
    public:
        void foo(const A &a)
        {
    
    
            cout << k << endl;   // OK
            cout << a.h << endl; // OK
        }
    };
};
int A::k = 1;
int main()
{
    
    
    A::B b;
    b.foo(A());
    return 0;
}

• sizeof(外部类)=外部类，和内部类没有任何关系。

cout << sizeof(A) << endl;

属于A类内部的只有h这一变量。

六，匿名对象

匿名对象就是在类的实例化定义对象的时候，不用写对象的名字。

class A
{
    
    
public:
    A(int a = 0)
        : _a(a)
    {
    
    
    }

private:
    int _a;
};

int main()
{
    
    
    A a1();
    return 0;
}

之前说过这样定义a1的对象使用全缺省的构造函数，是错误的，他会和函数的声明冲突（函数名 a1，返回值A类型，参数为空）。
但可以这样来创建匿名对象。

class A
{
    
    
public:
    A(int a = 0)
        : _a(a)
    {
    
    
    }

private:
    int _a;
};

int main()
{
    
    
    A();
    return 0;
}

==注意：==匿名对象的声明周期就在这一行，过了这一行就会调用析构函数。

七，拷贝对象时编译器的优化

在传参和传返回值的过程中，一般编译器会做一些优化，减少对象的拷贝，这个在一些场景下还是非常有用的。

class A
{
    
    
public:
    A(int a = 0)
        : _a(a)
    {
    
    
        cout << "A(int a)" << 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 f1(A aa)
{
    
    
}
A f2()
{
    
    
    A aa;
    return aa;
}

• 传值传参

int main()
{
    
    
    A aa1;
    f1(aa1);
    cout << endl;
    return 0;
}

在创建aa1时发生一次构造，传值传参发生一次拷贝构造。

int main()
{
    
    
    f1(1);
    f1(A(2));
    return 0;
}

第一种方式：1首先会发生隐式类型转换，调用一次构造函数，隐式类型转换出来的对象传递给形参发生一次拷贝构造，但是由于发生在一行中，所以编译器会优化成一次构造。
第二种方式：创建一个匿名对象直接传参，首先会一次构造函数，接着一次拷贝构造，但编译器会优化成为一个构造。

• 传值返回

A f2()
{
    
    
    A aa;
    return aa;
}
int main()
{
    
    
    A aa2 = f2();
    return 0;
}

aa对象创建一次构造，传值返回一次拷贝构造，用返回值初始化aa2又一次拷贝构造，但编译器会优化成一次构造+一次拷贝构造。

A f2()
{
    
    
    return A();
}
int main()
{
    
    
    A aa2 = f2();
    return 0;
}

如果传一个匿名对象做返回，那么编译器会优化为一次构造。

总结

• 接收返回值对象，尽量拷贝构造接收不要赋值接收
• 函数中返回对象时，尽量返回匿名对象
• 尽量使用const& 传参
  注意
  编译器不同所作出的优化也可能不太一样，越新的编译器做出的优化越大。如果你的编译器做出的优化和我举例中的优化不太一样，也是正常的。

八，再次理解类和对象

现实生活中的实体计算机并不认识，计算机只认识二进制格式的数据。如果想要让计算机认识现
实生活中的实体，用户必须通过某种面向对象的语言，对实体进行描述，然后通过编写程序，创
建对象后计算机才可以认识。比如想要让计算机认识洗衣机，就需要：

1. 用户先要对现实中洗衣机实体进行抽象—即在人为思想层面对洗衣机进行认识，洗衣机有什么属性，有那些功能，即对洗衣机进行抽象认知的一个过程
2. 经过1之后，在人的头脑中已经对洗衣机有了一个清醒的认识，只不过此时计算机还不清楚，想要让计算机识别人想象中的洗衣机，就需要人通过某种面相对象的语言(比如：C++、Java、Python等)将洗衣机用类来进行描述，并输入到计算机中
3. 经过2之后，在计算机中就有了一个洗衣机类，但是洗衣机类只是站在计算机的角度对洗衣机对象进行描述的，通过洗衣机类，可以实例化出一个个具体的洗衣机对象，此时计算机才能洗衣机是什么东西。
4. 用户就可以借助计算机中洗衣机对象，来模拟现实中的洗衣机实体了。
   在类和对象阶段，大家一定要体会到，类是对某一类实体(对象)来进行描述的，描述该对象具有那些属性，那些方法，描述完成后就形成了一种新的自定义类型，才用该自定义类型就可以实例化具体的对象