C++入门（类和对象知识补充）

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;//OK
			cout << 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 a2
	return 0;
}