C++类与对象（四）：再谈构造函数（详解初始化列表）、Static成员

class Date
{
public:
	Date(int year = 2024, int month = 1, int day = 1)//使用全缺省，也是默认构造函数
	{
		//函数体内初始化，在函数体内进行赋值
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;//变量声明
	int _month;
	int _day;
};

class Date
{
public:
	Date(int year = 2024, int month = 1, int day = 1)//使用全缺省，也是默认构造函数
		:_year(year)
		,_month(month)
		,_day(day)  //初始化列表
	{

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

class Date
{
public:
	Date(int year = 2024, int month = 1, int day = 1)
		:_year(year)
		,_month(month)
		,_day(day)  //这三个可以在这，也可以在函数体内
		,_ref(year)
		,_n(1)  //这两个必须在这里
	{

	}
    //两个地方可以混着用，这样也行  
	//Date(int year = 2024, int month = 1, int day = 1)
	//	: _ref(year)
	//	, _n(1)  //这两个必须在这里
	//{
	//	_year = year;//没有在初始化列表显示出来定义，但是也会定义和初始化，不过内置类型随机值。
                                            //自定义类型调用自己的默认构造函数
	//	_month = month;
	//	_day = day;//这三个可以在这，也可以在初始化列表内
	//}
    
private:
	int _year;//这些都是声明，还没有空间
	int _month;
	int _day;

	int& _ref;//引用，必须在定义的时候初始化
	const int _n;//常量，必须在定义的时候初始化
};

int main()
{
	//实例化对象
	Date d1;//此时才定义，但是对象整体定义； 那每个成员在哪里定义呢？——就在初始化列表
	return 0;
}

class Date
{
public:
	//两个地方可以混着用，这样也行
	Date(int year = 2024, int month =1, int day = 1)
		: _ref(year)
		, _n(1)  //这里给1，看结果
	{
		_year = year;
		_month = month;
		_day = day;//这三个可以进行赋值
	}
private:
	int _year=1;//只给_year缺省值
	int _month;
	int _day;

	int& _ref;//引用，必须在定义的时候初始化
	const int _n=2;//这里给2
};

class Stack
{
public:
	Stack(int capacity)
	{
		//.......
	}
	//没有默认构造函数了
private:
	int* _a;
	int _top;
	int _capacity;
};

class MyQueue
{
public:
	//此时都是自定义类型，但是又没有默认构造函数；或者有但是不想用。就要自己初始化
	MyQueue()
		:_s1(4)//自己显示地初始化
		, _s2(5)
	{

	}
private:
	Stack _s1;
	Stack _s2;
};

class Stack
{
public:
	Stack(int capacity=3)
	{
		cout << "调用了Stack的默认构造函数";
		//.......
	}
private:
	int* _a;
	int _top;
	int _capacity;
};

class MyQueue
{
public:

private:
	Stack _s1;
	Stack _s2;//这俩可调用Stack类的默认构造
	int _size = -1;//给了缺省值
	//此时可以简单点理解：该类的默认构造函数对于自定义就去调用他们的，对于内置使用缺省或随机值
};

class Stack
{
public:
	Stack(int capacity=3)
	{
		cout << "调用了Stack的默认构造函数";
		//.......
	}
	//没有默认构造函数了
private:
	int* _a;
	int _top;
	int _capacity;
};

class MyQueue
{
public:
	MyQueue()//有没有效果一样，没写就按照默认构造函数那老一套
	{ }  //写了初始化列表一定会走，但没有显示的写那也是老一套
private:
	Stack _s1;
	Stack _s2;//这俩可调用Stack类的默认构造
	int _size = -1;//给了缺省值
	
};

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

int main()
{
	A a1(1);//这样创建对象大家都知道

	A a2 = 2;//这样也可以：内置类型对象隐式转换为自定义类型对象
	         //能这样做，是A的int单参数构造函数支持的
			 //其实隐式转换中间产生一个临时变量，临时变量是A类型的

	const A& ra = 3;//给临时变量起别名，这时临时变量会在引用的作用域结束时销毁
	return 0;
}

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

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

int main()
{
	Date d1(2024, 1, 6);
    Date d2=2024;//
    //Date d2 = { 2024,1,1 };这样也行
	Date d3 = (2024, 1, 1);//这样是逗号表达式子<==> Date d3=1 <==> Date d3=(Date)1 <==> Date d3(1)
	return 0;
}

class Date
{
public:
	// explicit修饰构造函数，禁止类型转换
	 Date(int year=1, int month = 1, int day = 1)
		:_year(year)
		,_month(month)
		,_day(day)
	{ }

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

int main()
{
	Date d1;
	Date d2 = { 2024,2 };//从左到右依次赋值
	Date d3 = { 2024,2,2 }; //这样也行
	Date d4 = 2024;
	return 0;
}

#include<iostream>
using namespace std;
class A
{
public:
	A()//无参构造
	{
		count++;
	}
	A(A& a)//拷贝构造
	{
		count++;
	}

	static int count;//类内声明，属于整体（公有）
};
int A::count = 0;//类外定义，就类似于成员函数声明和定义分离

int main()
{
	A aa;
	cout << A::count << endl;//正常大家会想到这样访问
	cout << aa.count << endl;//这样也可以，类比调用成员函数：告诉编译器去那个类里找
}

using namespace std;
class A
{
public:
	A()//无参构造
	{
		count++;
	}
	A(A& a)//拷贝构造
	{
		count++;
	}
	int getCount()
	{
		return count;
	}
private:
	static int count;//类内声明，属于整体（私有）
};
int A::count = 0;//类外定义

int main()
{
	A aa;
	cout << aa.getCount()-1 << endl;//因为为了得到count而特地创建了一个对象来调用get函数，要-1；
}

class A
{
public:
	A()//无参构造
	{
		count++;
	}
	A(A& a)//拷贝构造
	{
		count++;
	}
	static int getCount()//静态成员函数，没有this指针，所以不能访问非静态成员变量
	{
		return count;
	}
private:
	static int count;//类内声明，属于整体（公有）
};
int A::count = 0;//类外定义

int main()
{
	A aa;
	cout << A::getCount()-1 << endl;//可以直接用类名调用
    cout << aa.getCount << endl;//这样也行
}