c++类和对象（下）

再谈构造函数

初始化列表

类里面的成员变量都是声名
而初始化列表里面就可以对变量进行定义（初始化）

需要在初始化列表中进行初始化的：

• const ：const变量必须初始化，因为const就是一个常量，把一个变量用一个常量来替代

• 引用 ：引用初始化

• 类成员变量，必须要在构造函数的初始化列表中调用其自身的构造函数

  初始化列表就是他们定义的地方，

而对于像其他类型的成员变量，如int year,int month在哪里初始化都可以，影响不大，

class Date
{
private:
	int _year;
	int _month;
	int _day;
	const int _N;//必须要初始化，但是不能在这里（声名）初始化，
	int& _ref;//引用，必须要初始化
	A _aa;//没有默认构造函数的自定义类型的成员变量
	//自定义类型会在定义的时候调用构造函数


public:
	//初始化列表 - 只有构造函数才可以，
	//每个对象的成员变量定义的地方
	//用;开始，用，进行间隔，括号就是其定义的值
	Date(int year, int month, int day,int i)//：开始，间隔
		:_year(year)
		, _month(month)
		, _day(day)
		,_N(10)//这样就可以用了
		,_ref(i)//在定义的地方初始化，
		,_aa(1)//这样初始化也行
	{	}

	//这样也可以用
	//Date(int year, int month, int day)
	//	:_N(10)
	//{
	//	_year = year;
	//	_month = month;
	//	_day = day;
	//}
};

void initlist()//初始化列表
{
	//Date d(2022, 1, 19);//对象实例化，对象定义
	const int j = 2;//常量必须才定义的时候初始化，
	int i = 2;
	Date s(2022, 12, 3, i);

}

补充：static必须要在类外进行初始化，不能在类里面进行初始化

explicit

class Date1
{
public:
	/* Date1(int year)
		 :_year(year)
	 {}*/
	 explicit Date1(int year)
		 :_year(year)
	 {}
private:
	int _year;
};

void explicit_test()
{
	Date1 d(2022);
	Date1 d2 = 2022;//也允许这样的事情发生，并且都是去调用构造函数
	//叫做隐式类型转换，
	//d2的实际过程是2022先构造一个临时变量Date tmp(2022)，再用这个对象去拷贝构造d2
	//但是c++编译器对于连续过程中的构造会合二为一
	//所以这里就只有一个构造
	//但是如果不想这样实现，我们前面加一个explicit就不会发生这样的转换了


	//类比c语言
//	隐式类型转换--相近的类型---表示意义相似的类型
	double d = 101;
	int ii = d;//

	//强制类型转换--把不相关的类型---
	int* p = ⅈ
	int k = (int)p;//
	

	//如我们以后学习的string类
	string s1("hello world");
	string s2 = "hell";
	//这也是这种情况

}

static

static修饰类对象，必须要在类外进行初始化

1. 静态成员变量属于整个类，只属于这个类，所有的对象
2. 生命周期再整个程序运行期间

static修饰类的成员函数
可以使用类名加作用域来进行访问

class B
{
private:
	int _a=0;//这里可以用，这个是给个缺省值，并不是初始化的地方

	static int _Scount;//声名
public:
	B(int a=0)
		:_a(a)

		++_Scount;
	}
	B(const B&b)
		:_a(b._a)
	{
		++_Scount;
	}
	//静态的成员函数，没有this指针，只能访问静态的的成员变量和成员函数
	//不能访问那些_a这些成员变量，
	static int Getcount()
	{
		return _Scount;
	}
};


int B::_Scount = 0;//定义初始化，

void f(B b)
{

}

//类外面访问
void static_test()
{
	B b1;
	B b2 = 1;
	f(b1);
	//cout <<B::_Scount  << endl;//值都是一样的，属于所有的对象
	//cout << b1._Scount << endl;
	cout << b1.Getcount() << endl;
}

练习

计算1+2+……+n

class sum
{
public:
	sum()//sum是构造函数，每次调用构造函数，_ret就会加上，_i也会自增
	{
		_ret += _i;
		++_i;
	}
	static int GetRet()
	{
		return _ret;
	}
private:
	//使用静态成员变量
	//声名
	//静态成员变量
	static int _i;//i是每次的加的数
	static int _ret;//ret用来记录总数d
};

//定义
int sum::_i = 1;
int sum::_ret = 0;


class Solution {
public:
	int sumNums(int n) {
		sum a[n];//对数组里面每个成员都要初始化，去调用构造函数，
		return sum::GetRet();
	}
};class sum
{
public:
	sum()//sum是构造函数，每次调用构造函数，_ret就会加上，_i也会自增
	{
		_ret += _i;
		++_i;
	}
	static int GetRet()
	{
		return _ret;
	}
private:
	//使用静态成员变量
	//声名
	//静态成员变量
	static int _i;//i是每次的加的数
	static int _ret;//ret用来记录总数d
};

//定义
int sum::_i = 1;
int sum::_ret = 0;


class Solution {
public:
	int sumNums(int n) {
		sum a[n];//对数组里面每个成员都要初始化，去调用构造函数，
		return sum::GetRet();
	}
};