【C++11】final与override关键字和类的新功能

目录

一、final与override关键字

1.1 final 

1.2 override

二、类的新功能

2.1 默认成员函数

2.2 类成员变量初始化

2.3 default关键字

2.4 delete关键字

---

一、final与override关键字

这两个关键字用于继承和多态

1.1 final 

测试代码

//基类
class Person {
public:
	//被final修饰，该虚函数不能再被重写
	virtual void BuyTicket() final
	{ 
		cout << "Person-买票-全价" << endl; 
	}
};
//派生类
class Student : public Person {
public:
	//派生类的虚函数重写了父类的虚函数
	virtual void BuyTicket() { cout << "Student-买票-半价" << endl; }
};

编译直接报错

如何实现一个不能被继承的类？？

1. 把构造函数进行私有，这是 C++98 的做法
2.  类定义时 加 final 关键字，这是 C++11的做法

 测试代码

//基类使用 final 修饰
class A final
{};
//派生类无法进行继承基类
class B : public A
{};

编译直接报错

1.2 override

测试代码

//基类
class Person {
public:
	//基类的虚函数
	virtual void BuyTicket() { cout << "Person-买票-全价" << endl; }
};
//派生类
class Student : public Person {
public:
	//派生类完成了虚函数的重写，编译通过
	virtual void BuyTicket()override
	{ 
		cout << "Student-买票-半价" << endl; 
	}
};
//派生类
class Soldier : public Person
{
public:
	//派生类没有完成虚函数的重写，编译报错
	virtual void BuyTicket(int n)override
	{ 
		cout << "Soldier-优先-买票" << endl;
	}
};

 编译直接报错

二、类的新功能

2.1 默认成员函数

在C++11之前，一个类中有如下六个默认成员函数

• 1. 构造函数
• 2. 析构函数
• 3. 拷贝构造函数
• 4. 拷贝赋值重载
• 5. 取地址重载
• 6. const 取地址重载

最后重要的是前4个，后两个用处不大。默认成员函数就是我们不写编译器会生成一个默认的

C++11 新增了两个：移动构造函数和移动赋值运算符重载

默认移动构造的生成条件

移动构造的默认行为： 

• 默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动构造，如果实现了就调用移动构造，没有实现就调用拷贝构造 

默认移动赋值的生成条件

移动赋值的默认行为：  

默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动赋
值，如果实现了就调用移动赋值，没有实现就调用拷贝赋值。(默认移动赋值跟上面移动构造完全类似)

注意：如果提供了移动构造或者移动赋值，编译器不会自动提供拷贝构造和拷贝赋值

测试代码，需要使用简化版模拟实现的string

namespace fy
{
	class string
	{
	public:
		//构造函数
		string(const char* str = "")
		{
			_size = strlen(str);//字符串大小
			_capacity = _size;//构造时，容量大小默认与字符串大小相同
			_str = new char[_capacity + 1];//为字符串开辟空间（多开一个用于存放'\0'）
			strcpy(_str, str);//将C字符串拷贝到已开好的空间
		}	
		//拷贝构造 -- 现代写法
		string(const string& s)
			:_str(nullptr)
			, _size(0)
			,_capacity(0)
		{
			cout << "string(const string& s) -- 深拷贝" << endl;
			string tmp(s._str);//复用构造函数，构造 tmp对象
			swap(tmp);//交换
		}
		//赋值重载 -- 现代写法1
		string& operator=(const string& s)
		{
			cout << "string& operator=(const string& s) -- 深拷贝" << endl;
			if (this == &s)//检查自我赋值
			{
				return *this;
			}
			string tmp(s);//复用拷贝构造函数，用s拷贝构造出对象tmp
			swap(tmp);
			return *this;//返回左值，目的是为了支持连续赋值
		}
		// 移动构造
		string(string&& s)
			:_str(nullptr)
			, _size(0)
			, _capacity(0)
		{
			cout << "string(string&& s) -- 移动语义" << endl;//更明显观察是否调用了该函数
			swap(s);//与右值的资源进行直接交换，不进行深拷贝
		}
		// 移动赋值
		string& operator=(string&& s)
		{
			cout << "string& operator=(string&& s) -- 移动语义" << endl;//使更明显观察是否调用了该函数
			swap(s);//与右值的资源进行直接交换，不进行深拷贝
			return *this;//支持连续赋值
		}
		//析构函数
		~string()
		{
			delete[] _str; //释放_str指向的空间
			_str = nullptr;
			_size = _capacity = 0;
		}
		//交换两个字符串
		void swap(string& s)
		{
			std::swap(_str, s._str);
			std::swap(_size, s._size);
			std::swap(_capacity, s._capacity);
		}
	private:
		char* _str;
		size_t _size;
		size_t _capacity;
	};
}

 然后再编写一个简单的 Person类，该类使用了我们模拟实现的string

class Person
{
public:
	//构造函数
	Person(const char* name = "", int age = 0)
		:_name(name)
		, _age(age)
	{}
private:
	fy::string _name;
	int _age;
};

int main()
{
	Person s1;
	Person s2 = s1;
	Person s3 = std::move(s1);
	Person s4;
	s4 = std::move(s2);
	return 0;
}

注意：这里的 Person类没有实现拷贝构造、赋值重载、析构函数，只实现了构造函数，即满足移动赋值和移动拷贝函数的生成条件

运行结果如下

 默认生成的移动构造和移动赋值函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动赋
值，如果实现了就调用移动赋值，没有实现就调用拷贝赋值，这里完全符合

下面进行测试

一但 Person类的拷贝构造、拷贝赋值和析构函数实现了任意一个或者多个，不满足移动赋值和移动拷贝函数的生成条件，移动赋值和移动拷贝函数就不会生成

测试代码

class Person
{
public:
	//构造函数
	Person(const char* name = "", int age = 0)
		:_name(name)
		, _age(age)
	{}
	拷贝构造
	//Person(const Person& p)
	// :_name(p._name)
	// ,_age(p._age)
	//{}
	赋值重载
	//Person& operator=(const Person& p)
	//{
	//	if(this != &p)
	//	{
	//		_name = p._name;
	//		_age = p._age;
	//	}
	//	return *this;
	//}
	//析构函数
	~Person()
	{}
private:
	fy::string _name;
	int _age;
};

int main()
{
	Person s1;
	Person s2 = s1;
	Person s3 = std::move(s1);
	Person s4;
	s4 = std::move(s2);
	return 0;
}

运行结果

由于默认的移动赋值和移动拷贝函数没有生成，此时 Person类只能调用 string的深拷贝函数，调不到移动赋值和移动构造函数

2.2 类成员变量初始化

C++11允许在类定义时给成员变量初始缺省值，默认生成构造函数会使用这些缺省值初始化，这里在类和对象的篇章已经谈过

class Person
{
public:
	//...
private:
	//非静态成员变量，可以在成员声明时给缺省值
	string _name = "张三"; //缺省值
	int _age = 22;         //缺省值

	static int _n; //静态成员变量不能给缺省值
};

注意：这里不是初始化，给的的值是缺省值

2.3 default关键字

C++11可以让你更好的控制要使用的默认函数。假设你要使用某个默认的函数，但是因为一些原因这个函数没有默认生成。比如：我们提供了拷贝构造，就不会生成移动构造了，那么我们可以使用default关键字显示指定移动构造生成

使用：在需要强制生成默认函数的声明后面加上 =default 即可

测试代码

class Person
{
public:
	//构造函数
	Person(const char* name = "", int age = 0)
		:_name(name)
		, _age(age)
	{}
	//拷贝构造
	Person(const Person& p)
	 :_name(p._name)
	 ,_age(p._age)
	{}
	//移动构造
	Person(Person&& p) = default;
private:
	fy::string _name;
	int _age;
};

int main()
{
	Person s1;
	Person s2 = s1;
	Person s3 = std::move(s1);
	return 0;
}

运行结果，使用了 default关键字后默认的移动构造可以生成，即便实现了拷贝构造函数

2.4 delete关键字

使用：在需要禁止生成默认函数的声明后面加上 =delete 即可 

如果能想要限制某些默认函数的生成：

• 在C++98中，是该函数设置成private，并且只用声明不用定义，这样只要其他人想要调用就会报错。
• 在C++11中更简单，只需在该函数声明加上 =delete 即可，该语法指示编译器不生成对应函数的默认版本，称 =delete 修饰的函数为删除

测试代码：

要让一个类不能被拷贝，可以用 =delete 修饰将该类的拷贝构造和赋值重载

class A
{
public:
	A()
	{}
private:
	//强制不允许生成
	A(const A&) = delete;
	A& operator=(const A&) = delete;
};

int main()
{
	A a1;
	A a2(a1);
	return 0;
}

编译报错

----------------我是分割线---------------

文章到这里就结束了，下一篇即将更新