C++类和对象（下）

目录

前言：

构造函数的初始化列表

static成员

static修饰局部变量（静态局部变量）

static修饰全局变量（静态全局变量）

static修饰成员函数（静态成员函数）

explicit关键字

扩展：编译器优化

前言：

C++类与对象的收尾工作，构造函数的初始化列表，static成员函数，explicit关键字 ，拷贝对象的编译器优化问题；

构造函数的初始化列表

class Date
{
private:
	int _year;
	int _month;
	int _day;
public:
	//构造函数
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;//函数体内赋初值
		_day = day;
	}
};
int main()
{
	Date d(2000,12,20);
	return 0;
}

构造函数的函数体内赋初值不能称为对对象中成员变量的初始化， 构造函数体中的语句只能将其称为赋初值 ，而不能称作初始化，因为 初始化只能初始化一次，而构造函数体内可以多次赋值；

初始化列表 ：以一个 冒号开始 ，以 逗号分隔的数据成员列表 ，每个" 成员变量 "后面跟 一个 放在括号中的初始值或表达式 ；

class Date
{
private:
	int _year;
	int _month;
	int _day;
public:
	//构造函数
	Date(int year, int month, int day)
	//初始化列表为每个成员变量定义的地方;
		: _year(year)
		, _month(month)
		, _day(day)
	{

	}
};
int main()
{
	//类型创建对象的位置是对象整体定义的位置,对象中每个成员变量在何处定义？
	Date d(2000,12,20);
	return 0;
}

class Date
{
private:
	int _year;
	int _month;
	int _day;
	const int _n;
	int& _ref;
public:
	//构造函数
	Date(int year, int month, int day)
		//初始化列表为每个成员变量定义的地方;
		: _n(10)      //const成员变量
		, _ref(year)  //引用变量	
	{
		_year = year;
		_month = month;
		_day = day;
	}
};
int main()
{
	Date d(2000,12,20);
	return 0;
}

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

	}
};
class Date
{
private:
	int _year;
	int _month;
	int _day;
	const int _n;
	int& _ref;
	A _aa;//自定义类型
public:
	//构造函数
	Date(int year, int month, int day)
		//初始化列表为每个成员变量定义的地方;
		: _n(10)      //const成员变量
		, _ref(year)  //引用变量	
	{

	}
};
int main()
{
	Date d(2000,12,20);
	return 0;
}

3. 自定义类型成员（且该类没有默认构造函数）必须在初始化列表位置初始化；

class A
{
private:
	int _a;
public:
	//构造函数,非默认构造函数
	A(int a )
		:_a(a)
	{

	}
};
class Date
{
private:
	int _year;
	int _month;
	int _day;
	const int _n;
	int& _ref;
	A _aa;//自定义类型
public:
	//构造函数
	Date(int year, int month, int day)
		//初始化列表为每个成员变量定义的地方;
		: _n(10)      //const成员变量
		, _ref(year)  //引用变量	
		, _aa(10)  //自定义类型成员
	{

	}
};

尽量使用初始化列表初始化，但是若禁用函数体内赋初值的方式，只使用初始化列表，可以吗？

class Stack
{
private:
	int* _a;
	int _capacity;
	int _top;
public:
	Stack(int capacity = 4)
		:_a((int*)malloc(sizeof(int)*capacity))
		, _capacity(4)
		, _top(4)
	{
		if (_a == nullptr)
		{
			perror("malloc failed");
			exit(-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();
}

void Func()
{
	int a = 0;
    static int b = 0;
	a++;
	b++;
	cout << "a=" << a << "b=" << b << endl;
}
int main()
{
	for (int i = 0; i < 2; i++)
	{
		Func();
	}
	return 0;
}

//data.cpp文件
 int k=10;

//test.cpp文件
extern int k;//外部声明
int main()
{
	cout << "k=" << k << endl;
	return 0;
}

当使用static修饰全局变量k时，发生链接错误，全局变量k无法被test.cpp文件调用，static修饰全局变量使得全局变量的作用域变小，全局变量无法被其他文件使用；

//data.cpp文件
static int k=10;

//test.cpp文件
extern int k;//外部声明
int main()
{
	cout << "k=" << k << endl;
	return 0;
}

运行结果：

全局变量本身具有外部链接属性，在A文件定义的全局变量，在B文件中可以通过"链接"使用；但是全局变量被static修饰，全局变量的外部链接属性被修改为内部链接属性，此时全局变量只能在定义时的源文件中使用；

static修饰成员函数（静态成员函数）

声明为 static的类成员称为 类的静态成员，用 static修饰的 成员变量，称之为 静态成员变量；用 static修饰的 成员函数，称之为 静态成员函数；

class A
{
private:

public:
    //构造函数
	A()
	{}
	//拷贝构造函数
	A(const A& t)
	{}
	//析构函数
	~A()
	{}
};
A func()
{
	A aa;
	return aa;
}
int main()
{
	A aa;
	func();
	return 0;
}

namespace zbw
{
	int count = 0;
}
class A
{
private:
public:
	//构造函数
	A()
	{
		zbw::count++;
	}
	//拷贝构造函数
	A(const A& t)
	{
		zbw::count++;
	}
	//析构函数
	~A()
	{}
};
A func()
{
	A aa;
	return aa;
}
int main()
{
	A aa;
	func();
	cout << "count=" << zbw::count << endl;
	return 0;
}

但是全局变量可以被任意修改，而普通成员变量是类中某个对象所独有的，在类的作用域发挥作用，不会被任意修改，相比于全局变量更加安全，将全局变量count修改为A类的成员变量，但是每个对象均存在count，根本无法完成计数；

class A
{
private:
	int count = 0;//成员变量
public:
	//构造函数
	A()
	{
	   count++;
	}
	//拷贝构造函数
	A(const A& t)
	{
		count++;
	}
	//析构函数
	~A()
	{}
};
A func()
{
	A aa;
	return aa;
}
int main()
{
	A aa;
	func();
	return 0;
}

C++为了支持全局变量成为某个类的专属，在成员变量前加上static，此时这个成员变量属于所有对象，但是不再支持成员变量处给缺省值，因为缺省值是给初始化列表，初始化列表只是初始化某一个对象，static所修饰的成员变量并不是只属于一个对象；静态成员变量必须在类外定义，定义时不添加static关键字，类中声明；静态成员变量还受访问限定符的限制；

class A
{
private:
	//静态成员变量声明
	static int count;
public:
	//构造函数
	A()
	{
	   count++;
	}
	//拷贝构造函数
	A(const A& t)
	{
		count++;
	}
	//析构函数
	~A()
	{}
};
//静态成员变量定义
int A::count = 0;
A func()
{
	A aa;
	return aa;
}
int main()
{
	A aa;
	func();
    //count++; //静态成员变量受访问限定符的限制
	return 0;
}

若访问限定符为 public ，静态成员变量可用 类名::静态成员 或者 对象.静态成员 访问；

class A
{
//private:
	
public:
	//静态成员变量声明
	static int count;
	//构造函数
	A()
	{
	   count++;
	}
	//拷贝构造函数
	A(const A& t)
	{
		count++;
	}
	//析构函数
	~A()
	{}
};
//静态成员变量定义
int A::count = 0;

int main()
{
	A aa;
	cout << A::count << endl; //类名::静态成员
	cout << aa.count << endl; //对象.静态成员
	return 0;
}

class A
{
private:
	//静态成员变量声明
	static int count;
public:
	//构造函数
	A()
	{
	   count++;
	}
	//拷贝构造函数
	A(const A& t)
	{
		count++;
	}
	//析构函数
	~A()
	{}
};
//静态成员变量定义
int A::count = 0;
int main()
{
	A aa;
	cout << A::count << endl;
	cout << aa.count << endl;
	return 0;
}

class A
{
private:
	//静态成员变量声明
	static int count;
public:
	//函数接口
	int GetCount()//只读不写
	{
		return count;
	}
	//构造函数
	A()
	{
	   count++;
	}
	//拷贝构造函数
	A(const A& t)
	{
		count++;
	}
	//析构函数
	~A()
	{}
};
//静态成员变量定义
int A::count = 0;
int main()
{
	A aa;
	cout << aa.GetCount()<< endl;
	return 0;
}

普通的成员函数必须使用对象调用，如aa.GetCount()函数，此种调用方式具有两种意义，其一是成员函数GetCount()属于对象aa的类，其二是成员函数具有一个隐藏的参数(this指针），传递对象aa的地址；而静态成员函数没有隐藏的this指针，效率更高；

class A
{
private:
	//静态成员变量声明
	static int count;
public:
	//静态成员函数，特点:没有this指针
	static int GetCount()
	{
		return count;
	}
	//构造函数
	A()
	{
	   count++;
	}
	//拷贝构造函数
	A(const A& t)
	{
		count++;
	}
	//析构函数
	~A()
	{}
};
//静态成员变量定义
int A::count = 0;
int main()
{
	A aa;
	cout <<A::GetCount()<< endl;
	return 0;
}

静态成员函数可以访问非静态的成员变量吗？

不可以，因为静态成员函数没有this指针，无论成员变量还是成员函数皆通过this指针进行访问；

总结：

静态成员函数与静态成员变量本质为受限制的全局变量与全局函数；

explicit关键字

构造函数不仅可以构造与初始化对象， 单个参数的构造函数 或者 第一个参数无默认值其余均有默认值的构造函数 或者 全缺省参数的构造函数 ，还具有 类型转换 的作用；

class A
{
private:
	int _a = 0;
public:
	//单参数的构造函数,参数类型为int,支持int转换为A类
	A(int a)
		:_a(a)
	{

	}
};
int main()
{
	//A为自定义类型,10为整型-->内置类型对象隐式类型转换为自定义类型对象
	A aa = 10;
	return 0;
}

?explicit修饰构造函数，禁止隐式类型转换；显式转换（强制类型转换）explicit不起作用；

class A
{
private:
	int _a = 0;
public:
	//构造函数
	explicit A(int a)
		:_a(a)
	{

	}
};
int main()
{
	A aa = 3;
	return 0;
}

?运行结果：

class Date
{
private:
	int _year;
	int _month;
	int _day;
public:
	//多参数的构造函数
	Date(int year, int month=1, int day=1)
		:_year(year)
		, _month(month)
		, _day(day)
	{

	}
};
int main()
{
	Date d = 2000;
	return 0;
}

监视窗口：

扩展：编译器优化

编译器在进行构造优化时，会尽可能地减少不必要的构造函数调用，以提高程序的性能和效率，具体来说，编译器会尝试进行以下优化：

1. 复制消除（Copy elision）：编译器会尝试避免不必要的拷贝构造函数调用，在某些情况下，编译器会直接将构造函数的参数传递给目标对象，而不是通过中间的临时对象进行拷贝，这样可以减少构造函数的调用次数；

2. 返回值优化（Return value optimization）：当函数返回一个临时对象时，编译器会尝试将临时对象直接构造在函数调用的目标对象中，而不是通过拷贝构造函数进行拷贝，这样可以减少拷贝构造函数的调用次数；

注：编译器的构造优化是基于编译器的实现和优化策略的，不同的编译器可能会有不同的优化行为；

 //A类
class A
{
public:
	//构造函数
	A(int a = 0)
		:_a(a)
	{
		cout << "调用构造函数" << endl;
	}
	//拷贝构造函数
	A(const A& aa)
		:_a(aa._a)
	{
		cout << "调用拷贝构造函数" << endl;
	}
	//析构函数
	~A()
	{
		cout << "调用析构函数" << endl;
	}
private:
	int _a;
};

int main()
{
	// 1.先用10构造一个临时对象 2.再用临时对象拷贝构造aa1
	// 3.同一个表达式中，连续构造+构造/构造+拷贝构造/拷贝构造+拷贝构造会合二为一
	A aa1 = 10;  
	return 0;
}

运行结果：

?a. 构造+构造---->构造
?b.构造+拷贝构造---->构造
?c.拷贝构造+拷贝构造---->拷贝构造

A Func()
{
	A aa;
	return aa;
}
int main()
{
	// 拷贝构造+拷贝构造->拷贝构造
	A aa1 = Func();//Func()函数运行到返回时先将aa拷贝构造到临时对象中，
                   //再将临时对象中拷贝构造到aa1中
	return 0;
}

• 注：编译器优化时，无论a,b,c哪种情形，必须在同一表达式中执行；

A Func()
{
	A aa;
	return aa;
}
int main()
{
	A aa2;
	//aa2对象已经存在
	//Func()函数运行到返回时先将aa拷贝构造到临时对象中，
	//由于aa2对象已存在,再将临时对象中赋值拷贝到aa2中
	aa2 = Func();
	return 0;
}

运行结果：