1、初始化列表

1、初始化列表的格式

Date(int year = 1, int month = 1, int day = 1):_year(year), _month(month)//在冒号后用这种格式初始化就叫初始化列表初始化{_day = day;//在括号内初始化就是在函数体内初始化}//初始化列表和函数体内初始化两者可以混用

2、初始化列表的价值

1、初始化列表可以认为就是对象的成员变量定义的地方（下面举个例子）

int value = 10;
class A
{
public://由于我们自己写了构造函数，编译器就不会自动生成默认构造函数//A(int x = 0)A(int x):_x(x){}
private:int _x;
};class Date
{
public:// 初始化列表可以认为就是对象的成员变量定义的地方Date(int year, int n, int a):_n(n)//只能在初始化列表初始化, _ref(value), _aa(a)//,_year(year){_year = year;//可以再函数体内初始化，也可以在初始化列表初始化}private:// 定义时初始化// 也可以定义时不初始化，后面再赋值修改int _year; // 声明// 只能在定义初始化const int _n;int& _ref;A _aa;//调不动自己的默认构造函数，只能在初始化列表初始化//如果A类型中有默认构造函数，则也可以在函数体内初始化
};

3、初始化列表使用注意事项

• 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)

• 类中包含以下成员，必须放在初始化列表位置进行初始化：
  引用成员变量
  const成员变量
  自定义类型成员(该类没有默认构造函数)
  其他的变量既可以在初始化列表初始化，也可以在函数体内初始化

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

• 总结：建议都在初始化列表初始化

2、静态成员变量

• 声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用static修饰的成员函数，称之为静态成员函数。静态的成员变量一定要在类外进行初始化
• 面试题：实现一个类，计算中程序中创建出了多少个类对象。

class A
{
public:A()//无参构造函数{++_count1;}A(const A& aa)//拷贝构造{++_count2;}// 成员函数也可以是静态，static成员函数没有this指针static int GetCount1(){//_a = 0; // 不能访问非静态成员，因为没有this指针/*	A aa;aa._a = 0;*/return _count1;}static int GetCount2(){return _count2;}
private:// 静态成员变量属于整个类，所以类的所有对象static int _count1;static int _count2; // 声明int _a;
};// 定义
int A::_count1 = 0;
int A::_count2 = 0;A Func(A a)
{A copy(a);return copy;
}int main()
{A a1;A a2 = Func(a1);cout << a1.GetCount1() << endl;cout << a2.GetCount2() << endl;cout << A::GetCount1() << endl;cout << A::GetCount2() << endl;
}

静态成员的特性

• 静态成员为所有类对象所共享，不属于某个具体的实例
• 静态成员变量必须在类外定义，定义时不添加static关键字
• 类静态成员即可用类名::静态成员或者对象.静态成员来访问
• 静态成员函数没有隐藏的this指针，不能访问任何非静态成员
• 静态成员和类的普通成员一样，也有public、protected、private3种访问级别，也可以具有返回值
• 静态成员变量不在初始化列表初始化

3、友元函数

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

1、问题：现在我们尝试去重载operator<<，然后发现我们没办法将operator<<重载成成员函数。因为cout的输出流对象和隐含的this指针在抢占第一个参数的位置。this指针默认是第一个参数也就是左操作数了。但是实际使用中cout需要是第一个形参对象，才能正常使用。所以我们要将operator<<重载成全局函数。但是这样的话，又会导致类外没办法访问成员那么这里就需要友元来解决。operator>>同理。

class Date
{
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;
}

• 友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需要加friend关键字。

4、友元类

• 友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。
• 友元关系是单向的，不具有交换性。
• 友元关系不能传递

5、内部类

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

特性：

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

// 内部类
class A
{
private:static int k;int h;//public:// 内部类class B // B天生就是A的友元{public:void foo(const A& a){cout << k << endl;//OKcout << a.h << endl;//OK}private:int _b;};// A不是B的友元/*void Print(const B& b){b._b = 0;}*/
};int main()
{A aa;cout << sizeof(A) << endl;//大小是4，内部类的大小并不计入在外部类中//A::B bb;return 0;
}

6、匿名对象

int main()
{/*Weight x;f(x);*/f(Weight());//Weight()匿名对象，声明周期只在这一行，会在这一行之内构造并且析构A a1(1);A a2 = 2; // A(2)  -> A a2(A(2))  -- 优化--直接构造//隐式类型转化相当于，用2构造了一个匿名对象，然后用A(2)拷贝构造A a2return 0;
}