类和对象的应用

本次内容大纲

再谈构造函数

在创建对象时，如果没写构造函数，编译器会自动生成一个，如果写了，编译器会根据写的构造函数对每个对象进行初始值

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.引用成员变量
 引用类型的变量在定义时就必须给其一个初始值，所以引用成员变量必须使用初始化列表对其进行初始化

    int a = 10;
    int& b = a;// 创建时就初始化
2.const成员变量
 被const修饰的变量也必须在定义时就给其一个初始值，也必须使用初始化列表进行初始化。

    const int a = 10;//correct 创建时就初始化
    const int b;//error 创建时未初始化
换句话说，只要在定义时必须给一个初始值就要在初始化列表进行初始化.

三、尽量使用初始化列表初始化

这样可以保证数据的安全性，不会在构造函数的时候，一个成员变量进行多次修改

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

#include<iostream>
using namespace std;
int i = 0;
class Test
{
public:

    Test()
        :b(i++)
        ,a(i++)
    {

    }
    void printfnumber()
    {
        cout << a << endl;
        cout << b << endl;
    }
private:
    int a;
    int b;
};
int main()
{
    Test test;
    test.printfnumber();

}

可以看到顺序是从后往前的。

explicit关键字

构造函数不仅可以构造和初始化对象，对于单个参数的构造函数，还支持隐式类型转换。

#include<iostream>
using namespace std;
int i = 0;
class Test
{
public:

    Test(int year)
        :_year(year)
    {}
private:
    int _year

};
int main()
{
    Test test=2022;
    

}

在语法上，代码中Test d1 = 2021等价于以下两句代码：

Test tmp(2021); //先构造
Test d1(tmp); //再拷贝构造
在早期编译器中，编译器会进行默认构造，在进行拷贝构造，随着版本的迭代，编译器会直接进行构造，这就叫隐式类型转换

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

static成员

概念

 声明为static的类成员称为类的静态成员。用static修饰的成员变量，称之为静态成员变量；用static修饰的成员函数，称之为静态成员函数。静态成员变量一定要在类外进行初始化，因为static有自己的作用域

特性

一、静态成员为所以类对象所共享，不属于某个具体的对象
鉴于此，我们看看以下代码的运行结果：

#include<iostream>
using namespace std;
int i = 0;
class Test
{
public:

    
private:
    static int _year;

};
int main()
{
    cout << sizeof(Test) << endl;
    

}

结果计算Test类的大小为1，因为静态成员_year是存储在静态区的，所以计算类的大小或是类对象的大小时，静态成员并不计入其总大小之和。

二、静态成员变量初始化必须在类外定义，定义时不添加static关键字

class Test
{
private:
    static int _n;
};
// 静态成员变量的定义初始化
int Test::_n = 0;
这里静态成员变量_n虽然是私有，但是我们在类外突破类域直接对其进行了访问。这是一个特例，不受访问限定符的限制，否则就没办法对静态成员变量进行定义和初始化了。

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

class Test
{
public:

static void Fun() {

cout << _a << endl; //error不能访问非静态成员

cout << _n << endl; //correct可以访问

}

    private:

int  _a;

static int _n;
};
访问静态成员变量的方法
1.当静态成员变量为公有时，有以下几种访问方式：

#include<iostream>
using namespace std;
int i = 0;
class Test
{
public:
    static int _n; //公有
};
int _n = 10;
int main()
{
    
    Test test;
    cout << test._n << endl;//1.通过类对象突破类域进行访问
    cout << Test()._n << endl;//2.通过匿名对象突破类域进行访问
    cout << Test::_n << endl;//3.通过类名突破类域进行访问
}

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

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

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

class A
{
public:
    void Print()
    {
        cout << _a << endl;
        cout << _p << endl;
    }
private:
    // 非静态成员变量，可以在成员声明时给缺省值。
    int _a = 10; 
    int* _p = (int*)malloc(4);
    static int _n; //静态成员变量不能给缺省值
};
初始化列表是成员变量定义初始化的地方，你若是给定了值，就用你所给的值对成员变量进行初始化，你若没有给定值，则用缺省值进行初始化，若是没有缺省值，则内置类型的成员就是随机值。

友元

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

友元函数
 友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需要加friend关键字。
 对于之前实现的日期类，我们现在尝试重载operator<<，但是我们发现没办法将其重载为成员函数，因为cout的输出流对象和隐含的this指针在抢占第一个参数的位置：this指针默认是第一个参数，即左操作数，但是实际使用中cout需要是第一个形参对象才能正常使用。
 所以我们要将operator<<重载为全局函数，但是这样的话，又会导致类外没办法访问成员，那么这里就需要友元来解决。（operator>>同理）

 我们都知道C++的<<和>>很神奇，因为它们能够自动识别输入和输出变量的类型，我们使用它们时不必像C语言一样增加数据格式的控制。实际上，这一点也不神奇，内置类型的对象能直接使用cout和cin输入输出，是因为库里面已经将它们的<<和>>重载好了，<<和>>能够自动识别类型，是因为它们之间构成了函数重载。

#include<iostream>
using namespace std;
int i = 0;
class Date
{
    //友元函数的声明
    friend ostream& operator>>(ostream& out, const Date& d1);
    friend istream& operator>>(istream& in, Date& d);
private:
    int _year;
    int _month;
    int _day;

};
ostream& operator>>(ostream& out, const Date& d1)
{
    out << d1._year << d1._month << d1._day;

}
istream& operator>>(istream& in, Date& d)
{
    in >> d._year >> d._month >> d._day;
    return in;
}

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

友元类

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

#include<iostream>
using namespace std;
class A {
    friend class B;
public:
    A(int n = 0)
        :_n(n)
    {

    }
private: 
    int _n;

};
class B
{

public:
    void Test(A& a)
    {

        cout << a._n << endl;

    }

};

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

内部类

概念：如果一个类里面还有一个类，这个就叫内部类

1.此时内部类是一个独立的类，它不属于外部类，更不能通过外部类调用内部类

2.外部类对内部类是没有任何访问权限的

3.内部类是外部类天生的友元函数

#include <iostream>
using namespace std;
class A //外部类
{
public:
    class B //内部类
    {
    private:
        int _b;
    };
private:
    int _a;
};
int main()
{
    cout << sizeof(A) << endl; //外部类的大小
    return 0;
}