类和对象【下】

---

一、初始化列表

1.初始化列表是定义成员变量的地方，在调用构造函数时自动初始化列表，可以自己写初始化列表，
让成员变量定义时获得初始值
2.初始化列表定义成员变量的顺序是按成员变量声明时的顺序定义的，声明时给的缺省值就是在初始化列表中去初始化

class Date
{
public:
Date(int year, int month, int day)
  : _year(year)//初始化列表
  , _month(month)
  , _day(day)
{}
private:
int _year;
int _month;
int _day;
};

3.初始化只能有一次
4.必须在初始化列表中初始化的成员变量类型

• a.const类型
• b.引用类型
• 没有默认构造函数的自定义类型，有也最好初始化

5.最好使用初始化列表初始化，不初始化也调用初始化列表

二、static成员

static成员都在静态区，但属于类域，访问可以通过类的类型

1.static成员变量

1.static成员变量定义时不加static
2.定义时在类外定义，初始化列表定义成员变量属于对象

class A
{
private:
static int _scount;
};
int A::_scount=1;

2.static成员函数

1.static成员函数没有this指针

class A
{
private:
static int _scount;
static void fuc()
{
	cout<<'a';
}
};
int A::_scount=1;

分享一个跟static成员相关的面试题:
1.声明为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;
void TestA()
{
cout << A::GetACount() << endl;
A a1, a2;
A a3(a1);
cout << A::GetACount() << endl;
}

---

三、友元函数

友元可以突破类的封装，访问类成员

1.友元函数

1.函数前加friend，在想要访问的类里加上friend+函数声明
2.友元函数声明不受访问限定符约束
3.友元函数不能用const修饰
4.一个函数可以是多个类的友元函数，友元函数与普通函数的调用原理相同

class Date
{
friend ostream& operator<<(ostream& _cout, const Date& d);
public:
private:
int _year;
int _month;
int _day;
};
ostream& operator<<(ostream& _cout, const Date& d)
{
_cout << d._year << "-" << d._month << "-" << d._day;
return _cout;
}

2.友元类

1.友元类的成员可以访问那个类的所有成员

class Time
{
frind class Date;
public:
private:
 int _hour;
 int _minute;
 int _second;
};
class Date
{
public:
 void SetTimeOfDate(int hour, int minute, int second)
 {
   // 直接访问时间类私有的成员变量
   _t._hour = hour;
   _t._minute = minute;
   _t._second = second;
 }
private:
 int _year;
 int _month;
 int _day;
 }