类和对象（下）

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

	}
private:
	int _year;
	int _month;
	int _day;
};
这里初始化的顺序为，先初始化_year,然后是_month,最后是_day。

如果是下面这种情况

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

	}
private:
	int _day;
	int _month;
	int _year;
};
那么先初始化_day,然后是_month,最后是_year

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

class B
{
private:
	A _aobj;//没有默认构造函数，因为对于类A，定义了构造函数，但是不是默认的
	int& _ref;//引用，需要初始化，但是类B中没有初始化列表
	const int _i;//const  需要初始化，但是类B中没有初始化列表
};

class Date
{
	
public:
	//1.单参构造函数，没有使用explicit修饰，具有类型转换作用
	explicit Date(int year)
		:_year(year)
	{}
	//2虽然有多个参数，但是创建对象时后两个参数可以不传递，没有使用explicit修饰，具有类型转换作用
	explicit Date(int year, int month, int day)
		: _year(year)
		, _month(month)
		, _day(day)
	{

	}
private:
	int _year;
	int _month;
	int _day;
};

void Test()
{
	Date d1(2022);
	d1 = 2012;
	//在类型转换的时候，实际编译器背后会用2012构造一个无名对象，最后用无名对象给d1对象进行赋值
	//2012是int类型，由于我使用了explicit，因此，不能强行转换。

}

class Date
{
public:
    friend istream& operator>>(istream& in, Date& d);

    friend ostream& operator<<(ostream& out, Date& d);

    Date(int year = 2022, int month = 10, int day = 1);

    Date(const Date& d);

private:
    int _year;
    int _month;
    int _day;
};
istream& operator>>(istream& in, Date& d)
{
    in >> d._year >> d._month >> d._day;
    return in;
}
ostream& operator<<(ostream& out, Date& d)
{
    out << d._year << d._month << d._day;
    return out;
}

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

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
		}
	};
};
int A::k = 1;
int main()
{
	A::B b; // 需要通过A才能访问到B
	b.foo(A());
	return 0;
}

class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A(int a)" << endl;
	}
	A(const A& aa)
		:_a(aa._a)
	{
		cout << "A(const A& aa)" << endl;
	}
	A& operator=(const A& aa)
	{
		cout << "A& operator=(const A& aa)" << endl;
		if (this != &aa)
		{
			_a = aa._a;
		}
		return *this;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};

void test1(A aa)
{}

A test2()
{
	A aa;
	return aa;
}

int main()
{
	// 传值传参
	A aa1;
	test1(aa1);
	cout << endl;
	// 传值返回
	test2();
	cout << endl;
	// 隐式类型，连续构造+拷贝构造->优化为直接构造
	test1(1);
	// 一个表达式中，连续构造+拷贝构造->优化为一个构造
	test1(A(2));
	cout << endl;
	// 一个表达式中，连续拷贝构造+拷贝构造->优化一个拷贝构造
	A aa2 = test2();
	cout << endl;
	// 一个表达式中，连续拷贝构造+赋值重载->无法优化
	aa1 = test2();
	cout << endl;
	return 0;
}