【C++基础篇】学习C++就看这篇---＞类和对象之const成员、取地址及const取地址操作符重载、初始化列表、explicit关键字

    void Print() const //实际上编译器会处理成void Print(const Date* this)
	{
		cout << _hour << ":" << _minute << ":" << _second << endl;
	}

const Time* p1;//const修饰的是 p1指向的对象
Time const* p2;//const修饰的是 p2指向的对象
Date* const p3;//const修饰的是 p3指针本身

class Time
{
public:
	//void Print()  
	void Print() const//因此，print成员函数被const修饰一下就解决下述问题。实际上编译器会处理成void Print(const Date* this)
	{
		cout << _hour << ":" << _minute << ":" << _second << endl;
	}
private:
	int _hour;
	int _minute;
	int _second;
};

int main()
{
	const Time t1;
	t1.Print();//由于Print成员函数是非const所以这里会报错
	return 0;
}

//下述函数均是类成员函数
	void f1()//void f1(Date* this)
	{
		f2();//this->f2(this)
	}
	void f2()
	{}

	//void f3() //由于f3是一个普通的类成员函数，即函数体内是可以对this指向的内容做修改的
	//{}		 //但是你f4调用的时候是const的是不能修改的，这就涉及到了权限放大的问题了，所以想调用必须使f3成为const成员函数
	void f3() const
	{}
	void f4() const//void f4(const Date* this)
	{
		f3();//this->f3(this)
	}

class Time
{
public:
	Time(int hour = 0, int minute = 0, int second = 1)//全缺省参数
	{
		_hour = hour;
		_minute = minute;
		_second = second;
	}
private:
	int _hour;
	int _minute;
	int _second;
};

int main()
{
	const Time t1;
	Time t2;
	cout << &t1 << endl;
	cout << &t2 << endl;
	return 0;
}

class Time
{
public:
	Time(int hour = 0, int minute = 0, int second = 1)//全缺省参数
	{
		_hour = hour;
		_minute = minute;
		_second = second;
	}

	Time* operator&()
	{
		return this;
	}
	const Time* operator&() const
	{
		return this;
	}
private:
	int _hour;
	int _minute;
	int _second;
};

int main()
{
	const Time t1;
	Time t2;
	cout << &t1 << endl;
	cout << &t2 << endl;
	return 0;
}

	Time* operator&()
	{
		return nullptr;
	}
	const Time* operator&() const
	{
		return nullptr;
	}

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

//三种必须在初始化列表进行初始化定义的变量，这也是初始化列表存在的意义		
class A
{
public:
	A(int a)
		:_a(a)
	{}
private:
	int _a;
};
class B
{
public:
	B(int a, int ref)//这里会报错的原因就是对于下面三个成员变量的初始化定义是发生在函数体执行之前（这也是为什么单独它们三个就必须在初始化列表当中）
		: _aobj(1)//即只能是在初始化列表当中进行初始化定义
		,_ref(ref)
		,_n(a)
	{				 
	}
private:
	A _aobj;
	// 没有默认构造函数
	int& _ref;
	// 引用
	const int _n; // const 
};

class Time
{
public:
	Time(int hour = 0)
		:_hour(hour)
	{
		cout << "Time()" << endl;
	}
private:
	int _hour;
};
class Date
{
public:
	//Date(int day)//这里为了验证就是自定义成员类的初始化构造是发生在函数体执行之前，无论你有没有提到它都会是自动调用的
	//{}			 //这也就证实了上篇博客所讲述的自定义类调用它的拷贝构造并不是编译器自己生成的构造函数里面的函数体内容去调用的
				//不过也可以认为是它生成的构造函数去调的吧，实际是初始化列表进行初始化的
	Date(int day)
	{
		Time t(1);
		_t = t;//如果非要在函数体内进行初始化只能是这样进行，先实例化一个t再2赋值给_t，因为此时_t已经完成了定义
	}
private:		 
	int _day;
	Time _t;
};
int main()
{
	Date d(1);
}

class A
{
public:
    A(int a)
        :_a1(a)
        , _a2(_a1)//一般建议定义与声明一致
    {}
    void Print() {
        cout << _a1 << " " << _a2 << endl;
    }
private:
    int _a2;
    int _a1;
};
int main() {
    A aa(1);
    aa.Print();//答案是_a1是具体值，_a2是随机值。
               //成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后
                //次序无关
}

int main()
{
	Time t1(11, 5, 59);//构造
	Time t2 = t1;//拷贝构造
	Time t3 = 5;//涉及隐式类型转换，编译器后台会先Time temp(5)，再Time t3(temp)，但是临时变量不是必须的，看编译器的优化
				//这里就会直接去调用构造
	//Time t3& = 5加入引用就会报错，因为临时变量具有常性必须加入const

	return 0;
}

int i = 1;
double& d = i;

const double& d = i;

class Time
{
public:
	explicit Time(int hour = 0, int minute = 0, int second = 1)//全缺省参数
	{
		_hour = hour;
		_minute = minute;
		_second = second;
	}
	Time(const Time& t)
	{
		_hour = t._hour;
		_minute = t._minute;
		_second = t._second;
	}
	void Print()
	{
		cout << _hour << ":" << _minute << ":" << _second << endl;
	}
private:
	int _hour;
	int _minute;
	int _second;
};

int main()
{
	Time t1(11, 5, 59);//构造
	Time t2 = t1;//拷贝构造
	Time t3 = 5;//涉及隐式类型转换，编译器后台会先Time temp(5)，再Time t3(temp)，但是临时变量不是必须的，看编译器的优化
				//这里就会直接去调用构造
	//如果不想让上述情况发生，在构造函数前加explicit关键字就可以解决，可以发现就会报错

	return 0;
}

int main()
{
	Time t1(11, 5, 59);//构造
	Time t2 = t1;//拷贝构造
	Time t3 = { 2020, 5, 20 };//对于多参数，是这样定义的,当然和上面一样，如果不希望这样的情况发生加explicit关键字
							  //这是C++11里面新添的，C++98不支持
	return 0;
}