一、const修饰成员函数

首先，我们知道，所有的成员函数（除static修饰的），编译器都会隐式传递一个this指针。

它的默认类型为 Type* const this，即this指针只能指向最左边的第一个传入的对象。

const修饰成员函数就是将其类型改变成为 const Type* const this，即缩小了权限，在成员函数内部不能修改传入的这个对象。

void Print()
{
    cout << "Print()" << endl;
    cout << "year:" << _year << endl;
    cout << "month:" << _month << endl;
    cout << "day:" << _day << endl << endl;
}
void Print() const
{
    cout << "Print()const" << endl;
    cout << "year:" << _year << endl;
    cout << "month:" << _month << endl;
    cout << "day:" << _day << endl << endl;
}

例如：一个日期类中，有2个Print函数。（由于const修饰了第一个形参this指针，两个函数的参数是不同的，构成函数重载）

Date d1(2022,1,13);
d1.Print();
const Date d2(2022,1,13);
d2.Print();

对于 Date类型的d1,2个Print函数都可以调用。

对于const Date类型的d2，只能调用加了const修饰的Print函数。（权限问题）

非const对象可以调用两种成员函数，const对象只能调用const修饰的成员函数。

注意：成员函数直接如果要相互调用，会将this指针依次传递，传递过程中，权限只能平移或者缩小。因此3成立，4不成立。

总结：const修饰成员函数实际上是缩小了this指针的权限，变为只读。

1、方便了const成员能够调用这个成员函数。 2、成员函数互相嵌套时，要注意权限问题。

3、对于那些不修改对象成员变量的函数最好加上const修饰。同时，其它参数，可以利用const+引用提高效率和传参范围（能否传入const修饰的对象）

二、初始化列表

对于构造函数（包括拷贝构造），可以利用函数体内赋值和初始化列表对其进行初始化。

注：这里由于函数体内可以多次赋值，实际上并不是严格的初始化。

以上3种情况必须使用初始化列表进行初始化。

对于引用成员变量：由于引用的特点，只能作为一个对象的别名，因此必须在定义时就初始化，而不能采取先定义，后赋值的办法。

对于const成员变量：必须在定义时就赋一个初始值，因为后续它不能被赋值改变。

对于没有默认构造函数的自定义类型成员

默认构造函数可以认为是可以不用传入参数的

对于Myqueue这个类中的两个Stack类型的对象。

不使用初始化列表，只能让编译器调用它们的默认构造函数，得到两个popst和pushst初始值完全相同，都为Stack的构造函数中的默认值。

使用初始化列表，可以对Myqueue的对象q2传入参数，然后可以利用初始化列表对两个popst和pushst分别进行初始化，使得自定义类型初始化内容不同。

注：

3. 尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，
一定会先使用初始化列表初始化。

三、static成员函数+变量

1、static成员函数

static修饰的成员函数，称之为静态成员函数。

静态成员函数不用传递this指针，即可以不依靠实例化的对象来调用

当静态成员函数是public时，可以在外部直接使用类名调用，不需要先实例化一个对象。

1、非静态成员变量是用this找到的，因此找不到具体是哪个对象的成员变量。

2、普通成员函数第一个参数需要传递this指针，静态成员函数没有，所以内部不能调用。

3、const是用来修饰this指针的，没有this指针，自然不能加const。

2、static成员变量

声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量。
静态成员变量一定要在类外进行初始化（规定）。

面试题：实现一个类，计算程序中创建出了多少个类对象

class A
{
public:
    A() { ++_scount; }
    A(const A& t) { ++_scount; }
    ~A() { --_scount; }
    static int GetACount() { return _scount; }
private:
    static int _scount;
};
int A::_scount = 0;

在private内定义一个静态的成员变量_scount（类内声明，类外定义并初始化为0）

这样既可以保证封装性，又可以完成其作为静态变量，不会随意销毁，用来统计对象个数的工作。

特性：

1. 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区
2. 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明
3. 类静态成员即可用类名::静态成员或者对象.静态成员来访问
4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员
5. 静态成员也是类的成员，受public、protected、private 访问限定符的限制
_scount可以不用对象直接访问，但是由于其被private修饰，只能在类内使用。可以使用一个static修饰的静态成员函数，用来返回_scount的值，在外部只需要调用GetAcount函数即可。

这里我们可以看出，静态成员函数和变量可以搭配使用，或者说：静态成员函数可以搭配private修饰的静态成员变量使用。

四、友元函数/类

1、友元函数

class Date
{
    friend ostream& operator<<(ostream& _cout, const Date& d);
    friend istream& operator>>(istream& _cin, Date& d);
public:
    Date(int year = 1900, int month = 1, int day = 1)
        : _year(year)
        , _month(month)
        , _day(day)
        {}
private:
    int _year;
    int _month;
    int _day;
};
ostream& operator<<(ostream& _cout, const Date& d)
{
    _cout << d._year << "-" << d._month << "-" << d._day;
    return _cout;
}
istream& operator>>(istream& _cin, Date& d)
{
    _cin >> d._year;
    _cin >> d._month;
    _cin >> d._day;
    return _cin;
}

对于<<流插入和>>流提取操作符，在类内部成员函数使用时，由于this指针是默认的第一个参数，为对象的地址，不符合我们的习惯cout<<xxx，和xxx>>cin，就需要将<<和>>在类的外部进行重载

但是在外部就不能访问private私有变量了。

此时可以在类的内部任意位置，在该函数的前面加上friend使其变为这个类的朋友，然后就可以在类的外部访问私有变量了。

注意：

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

2、友元类

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

五、内部类

特性：
1. 内部类可以定义在外部类的public、protected、private都是可以的。
2. 注意内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。
3. sizeof(外部类)=外部类，和内部类没有任何关系

当然，如果定义在private内，就不能直接在外部通过A::B bb1来创建对象了。

六、匿名对象

class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A(int a)" << endl;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};
class Solution {
public:
	Solution(int x,int y)
	{}
	int Sum_Solution(int n) {
		//...
		cout << "Sum_Solution(int n)" << endl;
		return n;
	}
};