C++之类和对象：初始化列表，static成员，友元，const成员 ……

const成员函数：

前置++和后置++重载：

取地址及const取地址操作符重载：

初始化列表：

explicit关键字：

static成员：

友元：

友元函数：

友元类：

内部类：

匿名对象：

拷贝对象时的一些编译器优化：

const成员函数：

const修饰的成员函数是const成员函数，修饰成员函数，实际上修饰的是成员函数隐藏的this指针，表明在该函数中不能对类的任何成员进行修改。

1. const对象可以调用非const成员函数吗？不可以

2. 非const对象可以调用const成员函数吗？可以

3. const成员函数内可以调用其它的非const成员函数吗？不可以

4. 非const成员函数内可以调用其它的const成员函数吗？可以

总结来说：权限只可缩小和平移，不可以放大。const调用非const就是一种权限放大。

前置++和后置++重载：

C++规定：后置++重载时多增加一个int 类型的参数，但是调用函数时该参数不用传递，编译器自动传递。

//前置++：
Data& Data::operator++()
{*this += 1;// += 这里是在类中重载过的新 += 。return *this;
}
//后置++：注意后置++是先使用再加1，因此需要返回+1之前的旧值
Data Data::operator++(int)
{Data d(*this);*this += 1;return d;
}

取地址及const取地址操作符重载：

这两个默认成员函数一般不需要管，编译器自动生成，只有特殊情况，才需要自己写，比如：让别人获取指定的内容。

class Dat
{ 
public :Date* operator&(){return this ;}const Date* operator&()const{return this ;}
private :int _year ; // 年int _month ; // 月int _day ; // 日
}

初始化列表：

构造函数体内给对象赋值，但是还不能叫做初始化，只有叫赋初值，初始化只能初始化一次，而构造函数体内可以多次赋值，所以就引出了初始化列表。

初始化列表以冒号开始，逗号分隔，括号里是初始值或者表达式。每个成员变量定义初始化的地方，初始化列表定义的时候需要值，缺省值就是给它的。

class Data
{
public:Data(int year = 2025, int month = 1, int day = 1): _year(year), _month(month), _day(day){}
private:int _year;int _month;int _day;
};

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

2.类中包含以下成员，必须放在初始化列表位置进行初始化：1.引用成员变量 2.const成员变量 3.自定义类型成员（且该类没有默认构造函数）

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

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

总结：能用初始化列表就用。

explicit关键字：

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

单参数的构造函数支持隐式类型转换（隐式类型转换会产生临时变量）。

上述可以编译成功，实际就是隐式类型转换，转换时编译器产生一个临时变量，用临时变量对d1进行赋值，临时变量是一个无名对象。

用explicit修饰后就失败了。禁止了隐式类型转换。要支持隐式类型转换需要赋值运算符重载，因为我没写，所以编译器自动生成了一个。

static成员：

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

特性：
1. 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区

2. 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明

3. 类静态成员即可用类名::静态成员或者对象.静态成员来访问

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

5. 静态成员也是类的成员，受public、protected、private 访问限定符的限制

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

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;void TestA()
{cout << A::GetACount() << endl;A a1, a2;A a3(a1);cout << A::GetACount() << endl;
}int main()
{TestA();
}

这个例子很好的说明了，静态类成员是所有对象共享的，静态成员函数只可访问静态成员变量（因为没有this指针）。

非静态成员函数可以调用静态成员函数，但是反之不行，因为非静态成员必须是对象定义之后才有实际空间，才可以使用成员函数，不然都只是模型而已。

友元：

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

友元函数：

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

下面看个实例：重载 operator<< 和 >> ，因为重载成成员函数，cout的输出流对象和隐含的this指针在抢占第一个参数的位置，所以重载函数必须成全局函数，但是又会导致类外无法访问成员，就需要友元：

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;
}int main()
{Date d;cin >> d;cout << d << endl;
}

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

注意：

1.友元函数可访问类的私有和保护成员，但不是类的成员函数。

2.友元函数不能用const修饰。

3.友元函数可以在类定义的任何地方声明，不受类访问限定符限制。

4.一个函数可以是多个类的友元函数。

5.友元函数的调用与普通函数的调用原理相同

友元类：

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

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

比如下述Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。

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

class Time
{friend class Date;// 声明日期类为时间类的友元类，则在日期类中就直接访问Time类中的私有成员变量
public:Time(int hour = 0, int minute = 0, int second = 0): _hour(hour), _minute(minute), _second(second){}
private:int _hour;int _minute;int _second;
};class Date
{
public:Date(int year = 1900, int month = 1, int day = 1):_year(year), _month(month), _day(day){}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;
};

内部类：

概念：如果一个类定义在另一个类的内部，这个内部类就叫做内部类。内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。内部类也受访问限制符的限制。

注意：内部类就是外部类的友元类，参见友元类的定义，内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。（内可以访问外部，外部不能访问内部）

特性： 1. 内部类可以定义在外部类的public、protected、private都是可以的。

2. 注意内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。

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

匿名对象：

匿名对象的生命周期只有一行。

class A
{
public:A(int a = 0):_a(a){cout << "A(int a)" << endl;}
private:int _a;
};int main()
{A aa1;// 定义普通对象不能 A aa1();因为编译器分不清是函数声明，还是对象定义//定义匿名对象,匿名对象的特点就是不用取名字，生命周期只有这一行，接下来就会调用析构函数。A();
}