构造函数赋值和初始化列表

构造函数复制和初始化列表

构造函数赋值

格式：

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

在创建对象时，编译器通过调用构造函数，给对象中各个成员变量一个合适的初始值。
虽然经过构造函数调用后对象已经有了一个初始值，但是只能称之为赋值不能称之为初始化，原因是因为构造函数赋值可以赋值多次，而初始化只能进行一次

初始化列表

格式：

class Date
{
public:
	Date(int year, int month, int day)
	: _year(year)
	, _month(month)
	, _day(day)
	{}
private:
	int _year;
	int _month;
	int _day;
};

初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式。

1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)
2. 类中包含以下成员，必须放在初始化列表位置进行初始化：
   1.引用成员变量
   2.const成员变量
   3.自定义类型成员(且该类没有默认构造函数时)

class A
{
	public:
	A(int a)
	:_a(a)
	{}
	private:
	int _a;
};
class B
{
	public:
	B(int a, int ref)
	:_aobj(a)
	,_ref(ref)
	,_n(10)
	{}
private:
	A _aobj; // 没有默认构造函数
	int& _ref; // 引用
	const int _n; // const
};

成员变量的初始化顺序是变量在类中的声明次序，比如：在以上代码中，先初始化*_aobj*,再初始化*_ref*，最后初始化*_n*

explicit

explicit关键字会禁止隐式类型的转换

#include <iostream>
using namespace std;
class Test1
{
public :
	Test1(int num)
	:n(num)
	{}
private:
	int n;
};
class Test2
{
public :
	explicit Test2(int num)
	:n(num)
	{}
private:
	int n;
};
 
int main()
{
	Test1 t1 = 12;
	Test2 t2(13);
	Test2 t3 = 14;
		
	return 0;
}

编译时，会指出 t3那一行error:无法从“int”转换为“Test2”。而t1却编译通过。注释掉t3那行，调试时，t1已被赋值成功。

static静态成员

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

class A
{
public:
	A(int a)
	{
		_a++;
	}

private:
	static int _a;
};

int A::_a = 1;//需要在类外进行初始化

和const的区别：

static

static局部变量 将一个变量声明为函数的局部变量，那么这个局部变量在函数执行完成之后不会被释放，而是继续保留在内存中
static 全局变量 表示一个变量在当前文件的全局内可访问
static 函数 表示一个函数只能在当前文件中被访问
static 类成员变量 表示这个成员为全类所共有
static 类成员函数 表示这个函数为全类所共有，而且只能访问静态成员变量

const

const 常量：定义时就初始化，以后不能更改。
const 形参：func(const int a){};该形参在函数里不能改变
const修饰类成员函数：该函数对成员变量只能进行只读操作

static关键字的作用：

（1）函数体内static变量的作用范围为该函数体，该变量的内存只被分配一次，因此其值在下次调用时仍维持上次的值；
（2）在模块内的static全局变量和函数可以被模块内的函数访问，但不能被模块外其它函数访问；
（3）在类中的static成员变量属于整个类所拥有，对类的所有对象只有一份拷贝；
（4）在类中的static成员函数属于整个类所拥有，这个函数不接收this指针，因而只能访问类的static成员变量。

const关键字的作用：

（1）阻止一个变量被改变
（2）声明常量指针和指针常量
（3）const修饰形参，表明它是一个输入参数，在函数内部不能改变其值；
（4）对于类的成员函数，若指定其为const类型，则表明其是一个常函数，不能修改类的成员变量；
（5）对于类的成员函数，有时候必须指定其返回值为const类型，以使得其返回值不为”左值”。

友元

友元会破环封装，不建议使用，如果一个类声明了许多的友元函数，则相当于在黑盒子上开了许多洞，显然这将破坏数据的隐蔽性和类的封装性，降低程序的可维护性，这与面向对象设计程序设计思想是背道而驰的。

友元函数

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

#include<iostream>
using namespace std;
class A
{
public:
	friend void Add(A& d);
	
	A(int a=1)
		:_a(a)
	{}

private:
	int _a;

};

void Add(A& d)
{
	d._a++;
}

int main()
{
	A a;
	Add(a);
	return 0;
}

1.友元函数可访问类的私有和保护成员，但不是类的成员函数
2.友元函数不能用const修饰
3.友元函数可以在类定义的任何地方声明，不受类访问限定符限制
4.一个函数可以是多个类的友元函数
5.友元函数的调用与普通函数的调用原理相同

友元类

1.友元关系是单向的，不具有交换性。
2.比如A类和B类，在A类中声明B类为其友元类，那么可以在B类中直接访问A类的私有成员变量，但想在A类中访问B类中私有的成员变量则不行。
3.友元关系不能传递
如果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;
};

匿名对象

匿名对象提供了一个较为方便的调用类中函数的方法
例如：

#include<iostream>
using namespace std;
class A
{
public:
	void Print(int num)
	{
		printf("%d\n", num);
	}
};

int main()
{
	A().Print(10);

	return 0;
}

这是一种比较简单的用法。