目录
一、初始化列表
先看下面这段代码
class Date
{
public:
Date(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
private:
//声明
int _year;
int _month;
int _day;
const int _N;
};
int main()
{
Date d1(2022, 1, 19);//对象定义/对象实例化
return 0;
}以日期类为例：类被定义出来以后，对于成员变量它是一种声明，告诉我们变量的类型与名称，并非初始化；
当在主函数中对类进行实例化时，类就被初始化了，类里面包含的成员变量也就被定义了，这里要注意构造函数里的语句只是对成员变量进行赋值，并非初始化；
我们可以看到在成员变量中有一个 const int _N;的成员变量，对于这种加了const的变量，只有在定义的同时进行初始化；
为了解决这样的问题，C++就有了一个初始化列表，来确保以上的变量能够在定义的时候就初始化了；
1.初始化列表的使用方法
初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式。
class Date
{
public:
//初始化列表 - 成员变量定义的地方
Date(int year, int month, int day, int i)
:_N(10)
,_year(year)
,_month(month)
,_day(day)
{}
private:
int _year;
int _month;
int _day;
const int _N; //const
};注意：1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)2. 类中包含以下成员，必须放在初始化列表位置进行初始化：引用成员变量const成员变量自定义类型成员(该类没有默认构造函数)
class A
{
public:
A(int a )//如果这里没有显示定义A（int a）
{
_a = a;
}
private:
int _a;
};
class Date
{
public:
//初始化列表 - 成员变量定义的地方
Date(int year, int month, int day, int i)
: _N(10)
, _ref(i)
, _aa(-1)
, _year(year)
, _month(month)
, _day(day)
{}
private:
int _year;
int _month;
int _day;
/*以下几种必须在定义的时候初始化*/
const int _N; //const
int& _ref; //引用
A _aa; //没有默认构造函数的成员变量
};
int main()
{
int i = 0;
Date d1(2022, 1, 19, i);
return 0;
}2.初始化列表的优势
使用和不使用初始化列表区别在哪呢？通过下面的代码的运行结果，来进行总结：
class A
{
public:
A(int a = 0)//如果这里没有显示定义A（int a）
{
cout << "int a = 0" << endl;
_a = a;
}
A(const A& aa)
{
cout << "const A& aa" << endl;
_a = aa._a;
}
A& operator=(const A& aa)
{
cout << "operator=(const A& aa)" << endl;
_a = aa._a;
return *this;
}
private:
int _a;
};
class Date
{
public:
//不使用初始化列表
Date(int year, int month, int day,const A& aa)
{
//进入函数体内时，成员变量已经定义出来了
_aa = aa;
_year = year;
_month = month;
_day = day;
}
//使用初始化列表
//Date(int year, int month, int day, const A& aa)
// :_aa(aa)
//{
// //进入函数体内时，成员变量已经定义出来了
// _year = year;
// _month = month;
// _day = day;
//}
private:
int _year;
int _month;
int _day;
A _aa;
};
int main()
{
A aa(10);
Date d1(2022, 1, 18, aa);
return 0;
} 
所以，使用初始化列表能在一定程度上提高效率，因此也是得到了广泛的应用；
注意：
成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关；也就是说你编写的初始化列表不是按照成员变量的声明顺序进行初始化，但是程序运行时是按照成员变量的声明顺序进行初始化的；
例如：判断下面的代码的运行结果？
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 ，但是初始化列表的顺序是 _a1 、_a2；按照我们刚才所讲的，编译器会先初始化 _a2，再初始化 _a1；所以_a2就是随机值，_a1 是1；
3.explicit关键字
构造函数不仅可以构造与初始化对象，对于单个参数的构造函数，还具有类型转换的作用；
class Date
{
public:
Date(int year)
:_year(year)
{}
//如果不想让Date d1 = 2022;转换发生 需要加上explicit关键字
explicit Date(int year)
:_year(year)
{}
private:
int _year;
};
int main()
{
Date d1(2022);
d1 = 2023;
//用2023构造一个临时对象Date(2023)，再用这个对象拷贝构造d2
return 0;
}上述代码可读性不是很好，用explicit修饰构造函数，将会禁止单参构造函数的隐式转换；
二、static成员
1.定义
声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用static修饰的成员函数，称之为静态成员函数。静态的成员变量一定要在类外进行初始化；
class A
{
public:
A(int a = 0)
:_a(a)
{
++_scount;
}
A(const A& aa)
:_a(aa._a)
{
++_scount;
}
//没有this指针，只能访问静态的成员变量和成员函数
static int GetCount()
{
return _scount;
}
private:
int _a;
//静态成员变量属于整个类，所有对象，生命周期在整个程序运行器件
//类的成员函数中可以随便访问
static int _scount;//声明
};
int A::_scount = 0;//在类外定义初始化
int main()
{
A a1;
A a2 = 1;
//类外面访问---建立在public
//cout << A::_scount << endl;
//cout << a1._scount << endl;
//cout << a2._scount << endl;
cout << A::GetCount() << endl;
cout << a1.GetCount() << endl;
return 0;
}2.特性
1. 静态成员为所有类对象所共享，不属于某个具体的实例
2. 静态成员变量必须在类外定义，定义时不添加static关键字3. 类静态成员即可用类名 :: 静态成员或者对象 . 静态成员来访问4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员5. 静态成员和类的普通成员一样，也有public、protected、private3种访问级别，也可以具有返回值
3.计算1+2+3+...+n的值
class Solution {
private:
class Sum
{
public:
Sum()
{
_ret += _i;
++_i;
}
static int GetRet()
{
return _ret;
}
private:
/*静态变量的声明*/
static int _i;
static int _ret;
};
public:
int Sum_Solution(int n) {
Sum a[n];//创建了n个对象的数组
return Sum::GetRet();//访问静态变量 _ret
}
};
/*静态变量的定义*/
int Sum::_i = 1;
int Sum::_ret = 0;三、C++11 的成员初始化新玩法
C++11支持非静态成员变量在声明时进行初始化赋值，但是要注意这里不是初始化，这里是给声明的成员变量缺省值。
class B
{
public:
B(int b = 0)
:_b(b)
{
}
private:
int _b;
};
//C++11 --- 打补丁
class A
{
public:
//如果你在初始化列表阶段，没有对成员初始化，这里就会使用缺省值初始化
A(int a = 0)
:_a(a)
{
}
private: //要注意的是这里不是初始化，因为这里是声明，不能初始化
int _a = 0;//这里给的是缺省值
B _bb;
B _bb1 = 10;//自定义类型也可以给缺省值，
B _bb2 = B(10);//先进行构造函数-->拷贝构造-->然后给_bb2
int* p = (int*)malloc(4 * 10);
int arr[10] = { 1,2,3,4,5 };
//但是静态的成员变量不可以给缺省值，构造函数不对静态成员变量进行处理，需要在类外面全局位置定义初始化
//static int _sCount = 0;
};四、友元
友元分为： 友元函数 和 友元类友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用 。
1.友元函数
在类和对象【中】里，我们在流插入和流提取上实现了操作符的重载，只是顺带说了一下，没有详细解释；
我们尝试去重载operator<<，然后发现我们没办法将operator<<重载成成员函数。因为cout的 输出流对象和隐含的this指针在抢占第一个参数的位置。this指针默认是第一个参数也就是左操作数了。但是实际使用中cout需要是第一个形参对象，才能正常使用。所以我们要将operator<<重载成全局函数。但是这 样的话，又会导致类外没办法访问成员，那么这里就需要友元来解决。operator>>同理。
class Date
{
/*友元函数---在重载函数前加friend*/
//流插入<<
friend ostream& operator<<(ostream& _cout, const Date& d);
//流提取>>
friend istream& operator>>(istream& _cin, Date& d);
public:
//初始化列表
Date(int year, int month, int day)
: _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;
}
int main()
{
Date d;
cin>>d;
cout<<d<<endl;
return 0;
}特性：
友元函数可访问类的私有和保护成员，但不是类的成员函数；
友元函数不能用const修饰；友元函数可以在类定义的任何地方声明，不受类访问限定符限制；一个函数可以是多个类的友元函数 友元函数的调用与普通函数的调用和原理相同；
2.友元类
友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。友元关系是单向的，不具有交换性。比如下面的Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time； 类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。友元关系不能传递如果B是A的友元，C是B的友元，则不能说明C时A的友元。
class Date;//前置声明
//时间类
class Time
{
friend class Date; // 声明日期类为时间类的友元类，则在日期类中就直接访问Time类中的私有成
//员变量
public:
Time(int hour = 0, int minute = 0, int second = 0)
: _hour(hour)
, _minute(minute)
, _second(second)
{}
void f(Date d);
private:
int _hour;
int _minute;
int _second;
};
//日期类
class Date
{
friend class Time;
public:
Date(int year = 1900, int month = 1, int day = 1)
: _year(year)
, _month(month)
, _day(day)
{
_t._hour = 0;
_t._minute = 0;
_t._second = 0;
}
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;
};
void Time::f(Date d)
{
d._year;
}
int main()
{
Date d1;
return 0;
}如果想要Time类去访问Date类的函数void f(Date d);，给Date类加上Time 的友元还是访问不了的，需要加上前置声明；
五、内部类
1.概念
如果一个类定义在另一个类的内部，这个内部类就叫做内部类。注意此时这个内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去调用内部类。外部类对内部类没有任何优越的访问权限。注意：内部类就是外部类的友元类。内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。
class A
{
private:
static int k;
int h;
//内部类
//1.内部类B和在全局定义是类基本一样，只是他受外部类A类域的限制,定义在A的类域中
//2.B天生就是A的友元，也就是B中可以访问A的私有，A不能访问B的私有
public:
class B
{
//friend class A;
public:
void foo(const A& a)
{
cout << k << endl;//OK
cout << a.h << endl;//OK
}
private:
int _b;
};
void f(B bb)
{
//A不是B的友元，不能访问B
//bb._b;
}
};
int A::k = 1;
int main()
{
A::B b;//这里不能直接定义b，需要指定类域
b.foo(A());
cout << sizeof(A) << endl;
return 0;
}2.特性
特性：
1. 内部类可以定义在外部类的public、protected、private都是可以的。2. 注意内部类可以直接访问外部类中的static、枚举成员，不需要外部类的对象/类名。3. sizeof(外部类)=外部类，和内部类没有任何关系