C++必修：类与对象(三)

✨✨ 欢迎大家来到贝蒂大讲堂✨✨

🎈🎈养成好习惯，先赞后看哦~🎈🎈

所属专栏：C++学习

贝蒂的主页：Betty’s blog

1. 隐式类型转换

在学习C语言时我们就明白，当我们进行赋值时，如果赋值两边的类型不同时就可能发生隐式类型转换。

1.1. 内置类型

在发生隐式类型转换时，如果都是内置类型就会先开辟一个临时变量，再将右操作数强制类型转换为左操作数的类型，最后用这个临时变量对左操作数进行赋值。注意：这个临时变量具有常性，不可修改。

int main()
{
	double j = 1.1;
	int i = j;//隐式类型转换
	int& a = j;//error
	const int& b = j;//ok
	return 0;
}

因为临时变量具有常性，所以无法被修改。如果赋值给普通引用就会造成权限的放大，所以只能用常引用。

1.2. 自定义类型

如果将一个内置赋值给自定义类型，那么编译器也会先创造一个自定义类型的**临时变量，**然后用这个内置类型调用构造函数对临时变量初始化，最后用这个临时变量对左操作数进行拷贝构造。。注意：这个临时变量也具有常性，不可修改。

class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	Date(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	void Print()
	{
		cout 
	Date d1 = 2023;//发生隐式类型转换
	Date d2 = { 2023,2 };
	d1.Print();
	d2.Print();
	return 0;
}

public:
	explicit Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	Date(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	void Print()
	{
		cout 
	Date d1 = 2023;//发生隐式类型转换
	Date d2 = { 2023,2 };
	d1.Print();
	d2.Print();
	return 0;
}

public:
    static int Print()//静态成员函数
	{
		cout 
public:
	static void Print()//静态成员函数
	{
		cout 
	A a;
	a.Print();
	A::Print();
	return 0;
}

		cout 
		return x + y;
	}

		cout 
		return x + y;
		Print();
	}

	friend void Print(const Date& d);//友元函数
public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	Date(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
private:
	int _year;
	int _month;
	int _day;
};
void Print(const Date&d)
{
	cout 
public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	Date(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	int GetYear()const
	{
		return _year;
	}
	int GetMonth()const
	{
		return _month;
	}
	int GetDay()const
	{
		return _day;
	}
private:
	int _year;
	int _month;
	int _day;
};
void Print(const Date& d)
{
	cout 
	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;
};

public:
	class B//B是A的友元
	{
	private:
		int _m;
	};
private:
	int _a;
	int _b;
};

private:
	static int k;
	int h;
public:
	class B // B天生就是A的友元
	{
	public:
		void foo()
		{
			cout 
	A::B b;
	b.foo();
	return 0;
}

private:
	int k;
	int h;
public:
	class B // B天生就是A的友元
	{
	public:
		int _a;
	};
};
int main()
{
	A a;
	cout 
public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		cout 
		cout 
		cout 
		cout 
	Date();//匿名对象
	Date d;
	return 0;
}

	const Date& dc = Date();//匿名对象也具有常性
	Date d;
	return 0;
}

public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		cout 
		cout 
		cout 
		cout 
	int months[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
	int day = months[month];
	if (month == 2 && (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0))
	{
		day++;
	}
	return day;
}

	assert(month  0 && month