C++11部分我将分为两个部分进行讲述，本篇文章将要讲述统一的列表初始化、声明、范围for、智能指针、STL中的一些变化、右值引用、移动语义以及新的类功能，下一篇文章将要讲述可变参数模板、lambda表达式、包装器以及线程库。
一、C++11简介
在2003年C++标准委员会曾经提交了一份技术勘误表(简称TC1)，使得C++03这个名字已经取代了C++98称为C++11 之前的最新C++标准名称。不过由于C++03(TC1)主要是对C++98标准中的漏洞进行修复，语言的核心部分则没有改动，因此人们习惯性的把两个标准合并称为C++98/03标准。从C++0x到C++11，C++标准10年磨一剑，第二个真正意义上的标准珊珊来迟。相比于C++98/03，C++11则带来了数量可观的变化，其中包含了约140个新特性，以及对C++03标准中约600个缺陷的修正，这使得C++11更像是从C++98/03中孕育出的一种新语言。相比较而言，C++11能更好地用于系统开发和库开发、语法更加泛华和简单化、更加稳定和安全，不仅功能更强大，而且能提升程序员的开发效率，公司实际项目开发中也用得比较多，所以我们要作为一个重点去学习。C++11增加的语法特性非常篇幅非常多，这里没办法一 一讲解，所以本篇文章主要讲解实际中比较实用的语法。
二、统一的列表初始化
2.1 ｛｝初始化
在C++98中，标准允许使用花括号{}对数组或者结构体元素进行统一的列表初始值设定。比如：
struct A
{
public:
A(int a1 , int a2)
:_a1(a1)
,_a2(a2)
{}
private:
int _a1 = 2;
int _a2 = 1;
};
int main()
{
int arr[] = { 1,3,5,7,9 };
A aa1 = { 2,4 };
return 0;
}
C++11扩大了用大括号括起的列表(初始化列表)的使用范围，使其可用于所有的内置类型和用户自定义的类型，使用初始化列表时，可添加等号(=)，也可不添加。
struct A
{
public:
A(int a1, int a2)
:_a1(a1)
, _a2(a2)
{}
private:
int _a1 = 2;
int _a2 = 1;
};
int main()
{
int x = { 10 };
int y = 10;
int arr[] = { 1,3,5,7,9 };
A aa1 = { 2,4 };
// C++11中列表初始化也可以适用于new表达式中
int* parr = new int[4]{ 0 };
return 0;
}
创建对象时也可以使用列表初始化方式调用构造函数初始化
class Date
{
public:
Date(int year, int month, int day)
:_year(year)
, _month(month)
, _day(day)
{
cout << "Date(int year, int month, int day)" << endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1(2024, 3, 1);
// C++11支持的列表初始化，这里会调用构造函数初始化
Date d2{ 2022, 3, 2 };
Date d3 = { 2022, 3, 3 };
return 0;
}
2.2 std::initializer_list
std::initializer_list是什么类型：
int main()
{
auto il = { 10, 20, 30 };
cout << typeid(il).name() << endl;
return 0;
}
std::initializer_list使用场景：
std::initializer_list一般是作为构造函数的参数，C++11对STL中的不少容器就增加std::initializer_list作为参数的构造函数，这样初始化容器对象就更方便了。也可以作为operator=的参数，这样就可以用大括号赋值。
下面是C++标准库中的能使用initializer_list作为参数调用operator=的部分容器。
https://legacy.cplusplus.com/reference/vector/vector/operator=/
https://legacy.cplusplus.com/reference/list/list/operator=/
https://legacy.cplusplus.com/reference/set/set/operator=/
https://legacy.cplusplus.com/reference/map/map/operator=/
int main()
{
vector<int> v;
// 使用vector调用initializer_list为参数的operator=函数
v = { 2024,3,1 };
// 使用list调用initializer_list为参数的operator=函数
list<pair<string, string>> l;
l = { {"love","爱"},{"want","想要"} };
return 0;
}
模拟实现的vector也支持{}初始化和赋值
#pragma once
#include <iostream>
#include <assert.h>
using namespace std;
namespace aj
{
template<class T>
class vector
{
public:
vector(initializer_list<T> l)
{
_start = new T[l.size()];
_finish = _start + l.size();
_endOfStorage = _start + l.size();
size_t i = 0;
for (auto ch : l)
{
*(_start + i) = ch;
i++;
}
}
vector<T>& operator= (initializer_list<T>& l)
{
_start = new T[l.capacity()];
_finish = _start + l.size();
_endOfStorage = _start + l.capacity();
for (size_t i = 0; i < l.size(); i++)
{
*(_start + i) = l[i];
}
return *this;
}
private:
iterator _start = nullptr; // 指向数据块的开始
iterator _finish = nullptr; // 指向有效数据的尾
iterator _endOfStorage = nullptr; // 指向存储容量的尾
};
}
三、声明
c++11提供了多种简化声明的方式，尤其是在使用模板时。
3.1 auto
在C++98中auto是一个存储类型的说明符，表明变量是局部自动存储类型，但是局部域中定义局部的变量默认就是自动存储类型，所以auto就没什么价值了。C++11中废弃auto原来的用法，将其用于实现自动类型推断。这样要求必须进行显示初始化，让编译器将定义对象的类型设置为初始化值的类型。
namespace aj
{
void swap(int& x, int& y)
{
int tmp = x;
x = y;
y = tmp;
}
}
int main()
{
int x = 0;
auto pa = &x;
auto ps = aj::swap;
cout << typeid(pa).name() << endl << endl;
cout << typeid(ps).name() << endl << endl;
map<string, string> m({ {"love","爱"},{"want","想要"} });
auto it = m.begin();
cout << typeid(it).name() << endl;
return 0;
}
3.2 decltype
关键字decltype将变量的类型声明为表达式指定的类型。
int main()
{
int x = 2;
double y = 2.2;
// 如果这里我们想将 x 与 y乘积类型作为容器的模版参数
// 会发现，auto不能完成这一任务
// 那么这里使用 decltype
vector<decltype(x* y)> v;
cout << typeid(decltype(x * y)).name() << endl;
return 0;
}
3.3 nullptr
由于C++中NULL被定义成字面量0，这样就可能回带来一些问题，因为0既能指针常量，又能表示整形常量。所以出于清晰和安全的角度考虑，C++11中新增了nullptr，用于表示空指针。
#ifndef NULL
#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
#endif
#endif
四、范围for
范围for在【C++】C++入门这篇文章中的第九点中有详细讲解，那么这里不再做讲解，不太熟悉的可以跳转到这篇文章看一下。
五、智能指针
由于智能指针的内容的篇幅不少，加在这里会使这篇文章的内容太长，那么智能指针的内容会在后面的文章讲述到。
六、STL中一些变化
-
新容器
下面圈起来是C++11中的一些几个新容器，但是实际最有用的是unordered_map和unordered_set。这两个我们前面已经进行了非常详细的讲解，其他的大家了解一下即可。
-
新的构造：
initializer_list的构造
关于initializer_list的内容已经在上面第二点中讲述到了。 -
移动构造和移动赋值
移动构造和移动赋值的相关内容在下面第八点中讲到。 -
右值引用的引入
右值引用的相关内容在下面第七点中讲到。 -
容器中的一些新方法
比如提供了cbegin和cend方法返回const迭代器等等，但是实际意义不大，因为begin和end也是可以返回const迭代器的，并且大家也已经习惯了使用begin和end，所以cbegin和cend的出现实践意义不大。
七、右值引用和移动语义
7.1 左值引用和右值引用
而C++11中新增了的右值引用语法特性，之前学习的引用叫做左值引用。无论左值引用还是右值引用，都是给对象取别名。
什么是左值？什么是左值引用？
左值是一个表示数据的表达式(如变量名或解引用的指针)，**我们可以获取它的地址+可以对它赋值，左值可以出现赋值符号的左边，右值不能出现在赋值符号左边。**定义时const修饰符后的左值，不能给他赋值，但是可以取它的地址。左值引用就是给左值的引用，给左值取别名。
int main()
{
// 左值
int x = 0;
int* p = new int(x);
const int y = 1;
// 左值引用
int& rx = x;
int*& rp = p;
const int& ry = y;
return 0;
}
什么是右值？什么是右值引用？
右值也是一个表示数据的表达式，如：字面常量、表达式返回值，函数返回值(这个不能是左值引用返回)等等，右值可以出现在赋值符号的右边，但是不能出现出现在赋值符号的左边，右值不能取地址。右值引用就是对右值的引用，给右值取别名。
int add(int x, int y)
{
return x + y;
}
int main()
{
// 右值有下面几种情况
// 常数
int&& x = 0;
int m = 1, n = 2;
// 表达式返回值
int&& y = m + n;
// 函数的返回值
int&& z = add(m , n);
return 0;
}
总结：左值引用和右值引用的区别就是能不能取地址，左值引用的对象可以取地址，而右值引用的对象不可以取地址。
7.2 左值引用与右值引用比较
左值引用总结：
- 左值引用只能引用左值，不能引用右值。
- 但是const左值引用既可引用左值，也可引用右值。
int main()
{
int x = 0;
const int y = 1;
// 左值引用左值
int& ra = x;
// 左值引用右值报错
// int& ry = y;
// const左值引用左值
const int& ry2 = x;
// const左值引用右值
const int& rsum = x + y;
return 0;
}
右值引用总结：
- 右值引用只能右值，不能引用左值。
- 但是右值引用可以move以后的左值。
move函数文档介绍
move函数能够将对象的属性从左值转化为右值返回。
int main()
{
int x = 0;
const int y = 1;
// 右值引用右值
int&& ry = 520;
// 右值引用左值报错
// 无法将右值引用绑定到左值
// C2440 初始化 : 无法从int转换为int &&
// int&& rx = x;
// 右值引用move后的左值
int&& rx = move(x);
// const右值引用左值报错
// const int&& rx = x;
// const左值引用右值
const int&& rsum = x + y;
return 0;
}
7.3 右值引用使用场景和意义
前面我们可以看到左值引用既可以引用左值和又可以引用右值，那为什么C++11还要提出右值引用呢？是不是化蛇添足呢？下面我们来看看左值引用的短板，右值引用是如何补齐这个短板的！
#pragma once
#include <iostream>
#include <assert.h>
using namespace std;
#include <string>
namespace aj
{
class string
{
public:
typedef char* iterator;
public:
// 这里缺省值给""的原因是空字符串本身就带一个'\0'
// 而不是初始化的时候_str为nullptr
// 初始化列表的顺序应该与声明相同
string(const char* str = "")
:_capacity(strlen(str))
, _size(_capacity)
{
// 多开一个空间用来存放'\0'
_str = new char[_capacity + 1];
strcpy(_str, str);
}
// 拷贝构造函数现代写法
string(const string& s)
:_str(nullptr)
, _capacity(0)
,_size(0)
{
cout << "string(const string& s)---深拷贝" << endl;
string tmp(s._str);
swap(tmp);
}
// 移动构造
string(string&& s)
:_str(nullptr)
, _capacity(0)
, _size(0)
{
cout << "string(string&& s)---移动语义" << endl;
swap(s);
}
string& operator=(string tmp)
{
cout << "string& operator=(string tmp)---深拷贝" << endl;
swap(tmp);
return *this;
}
// 移动赋值
string& operator=(string&& tmp)
{
cout << "string& operator=(string&& tmp)---移动语义" << endl;
swap(tmp);
return *this;
}
~string()
{
delete[] _str;
_str = nullptr;
_size = _capacity = 0;
}
iterator begin()
{
return _str;
}
iterator end()
{
return _str + _size;
}
void push_back(char c)
{
if (_size + 1 > _capacity)
{
// 这里不能盲目的开二倍，因为string可能是空字符串，
// _capacity = 0 , 那么这里的二倍就没有意义，继续下面的操作会报错
reserve(_capacity == 0 ? 4 : 2 * _capacity);
}
_str[_size] = c;
_size++;
_str[_size] = '\0';
}
string& operator+=(char c)
{
push_back(c);
return *this;
}
void append(const char* str)
{
int len = strlen(str);
if (_size + len > _capacity)
{
reserve(_size + len);
}
strcpy(_str + _size, str);
_size += len;
}
string& operator+=(const char* str)
{
append(str);
return *this;
}
void clear()
{
_str[0] = '\0';
_size = 0;
}
void swap(string& s)
{
std::swap(_str, s._str);
std::swap(_capacity, s._capacity);
std::swap(_size, s._size);
}
const char* c_str()const
{
return _str;
}
size_t size()const
{
return _size;
}
size_t capacity() const
{
return _capacity;
}
bool empty()const
{
return _size == 0;
}
void resize(size_t n, char c = '\0')
{
if (n <= _size)
{
_str[n] = '\0';
_size = n;
}
else
{
reserve(n);
_capacity = n;
while (_size < n)
{
_str[_size] = c;
_size++;
}
// 到这里 _size = n
_str[_size] = '\0';
}
}
void reserve(size_t n)
{
if (n > _capacity)
{
// _capacity 记录的是需要存储有效数据的个数
// 所以我们这里要多开一个空间用来记录'\0'
char* tmp = new char[n + 1];
strcpy(tmp, _str);
delete[] _str;
_str = tmp;
_capacity = n;
}
}
private:
char* _str;
size_t _capacity;
size_t _size;
const static size_t npos;
};
const size_t string::npos = -1;
};
左值引用的使用场景：做参数和做返回值都可以提高效率。
void func1(aj::string s)
{}
void func2(const aj::string& s)
{}
int main()
{
aj::string s1("hello world");
// func1和func2的调用我们可以看到左值引用做参数减少了拷贝，提高效率的使用场景和价值
func1(s1);
func2(s1);
// string operator+=(char ch) 传值返回存在深拷贝
// string& operator+=(char ch) 传左值引用没有拷贝提高了效率
s1 += '!';
return 0;
}
左值引用的短板：
但是当函数返回对象是一个局部变量，出了函数作用域就不存在了，就不能使用左值引用返回，只能传值返回。例如：aj::string to_string(int value)函数中可以看到，这里只能使用传值返回，传值返回会导致至少1次拷贝构造(如果是一些旧一点的编译器可能是两次拷贝构造)。
namespace aj
{
aj::string to_string(int value)
{
bool flag = true;
if (value < 0)
{
flag = false;
value = 0 - value;
}
aj::string ret;
while (value > 0)
{
int x = value % 10;
value /= 10;
ret+= ('0' + x);
}
if (flag == false)
{
ret+= '-';
}
aj::reverse(ret.begin(), ret.end());
return ret;
}
}
int main()
{
// 在aj::string to_string(int num)函数中可以看到，这里
// 只能使用传值返回，传值返回会导致至少1次拷贝构造
// (如果是一些旧一点的编译器可能是两次拷贝构造)。
aj::string ret1 = aj::to_string(1234);
aj::string ret2 = aj::to_string(-1234);
return 0;
}
namespace aj
{
string(const string& s)
:_str(nullptr)
, _capacity(0)
, _size(0)
{
cout << "string(const string& s)---深拷贝" << endl;
string tmp(s._str);
swap(tmp);
}
string to_string(int num)
{
string ret;
// ...
return ret;
}
}
右值引用和移动语义解决上述问题：
在aj::string中增加移动构造，移动构造本质是将参数右值的资源窃取过来，占位已有，那么就不用做深拷贝了，所以它叫做移动构造，就是窃取别人的资源来构造自己。
#pragma once
#include <iostream>
using namespace std;
#include <string>
namespace aj
{
class string
{
// 移动构造
string(string&& s)
:_str(nullptr)
, _capacity(0)
, _size(0)
{
cout << "string(string&& s)---移动语义" << endl;
swap(s);
}
private:
char* _str;
size_t _capacity;
size_t _size;
const static size_t npos;
};
const size_t string::npos = -1;
aj::string to_string(int num)
{
aj::string ret;
// ...
return ret;
}
};
不仅仅有移动构造，还有移动赋值：
在aj::string类中增加移动赋值函数，再去调用aj::to_string(1234)，不过这次是将aj::to_string(1234)返回的右值对象赋值给ret对象，这时调用的是移动构造。
这里运行后，我们看到调用了一次移动构造和一次移动赋值。因为如果是用一个已经存在的对象接收，编译器就没办法优化了。aj::to_string函数中会先用str生成构造生成一个临时对象，但是我们可以看到，编译器很聪明的在这里把str识别成了右值，调用了移动构造。然后在把这个临时对象做为aj::to_string函数调用的返回值赋值给ret，这里调用的移动赋值。
STL中的容器都是增加了移动构造和移动赋值:
https://legacy.cplusplus.com/reference/vector/vector/
https://legacy.cplusplus.com/reference/list/list/
https://legacy.cplusplus.com/reference/set/set/
https://legacy.cplusplus.com/reference/map/map/
7.4 右值引用引用左值及其一些更深入的使用场景分析
按照语法，右值引用只能引用右值，但右值引用一定不能引用左值吗？因为：有些场景下，可能真的需要用右值去引用左值实现移动语义。当需要用右值引用引用一个左值时，可以通过move函数将左值转化为右值。C++11中，std::move()函数位于 头文件中，该函数名字具有迷惑性，它并不搬移任何东西，唯一的功能就是将一个左值强制转化为右值引用，然后实现移动语义。
// move底层的实现
template<class _Ty>
inline typename remove_reference<_Ty>::type&& move(_Ty&& _Arg) _NOEXCEPT
{
// forward _Arg as movable
return ((typename remove_reference<_Ty>::type&&)_Arg);
}
int main()
{
aj::string s1("hello world");
// 这里s1是左值，调用的是拷贝构造
aj::string s2(s1);
// 这里我们把s1 move处理以后, 会被当成右值，调用移动构造
// 但是这里要注意，一般是不要这样用的，因为我们会发现s1的
// 资源被转移给了s3，s1被置空了。
aj::string s3(std::move(s1));
cout << "s1: " << s1 << endl;
cout << "s2: " << s2 << endl;
cout << "s3: " << s3 << endl;
return 0;
}
STL容器插入接口函数也增加了右值引用版本：
https://legacy.cplusplus.com/reference/list/list/push_back/
// list --> void push_back(value_type&& val);
int main()
{
list<aj::string> lt;
aj::string s1("1111");
// 这里调用的是拷贝构造
lt.push_back(s1);
// 下面调用都是移动构造
lt.push_back("2222");
lt.push_back(std::move(s1));
return 0;
}
7.5 完美转发
模板中的&& 万能引用
若对象的属性为右值被右值引用后，对象的属性会退化为左值。
void Fun(int& x) { cout << "左值引用" << endl; }
void Fun(const int& x) { cout << "const 左值引用" << endl; }
void Fun(int&& x) { cout << "右值引用" << endl; }
void Fun(const int&& x) { cout << "const 右值引用" << endl; }
// 模板中的&&不代表右值引用，而是万能引用，其既能接收左值又能接收右值。
// 模板的万能引用只是提供了能够接收同时接收左值引用和右值引用的能力，
// 但是引用类型的唯一作用就是限制了接收的类型，后续使用中都退化成了左值，
// 我们希望能够在传递过程中保持它的左值或者右值的属性, 就需要用我们下面学习的完美转发
template<typename T>
void PerfectForward(T&& t)
{
Fun(t);
}
int main()
{
PerfectForward(10); // 右值
int a;
PerfectForward(a); // 左值
PerfectForward(std::move(a)); // 右值
const int b = 8;
PerfectForward(b); // const 左值
PerfectForward(std::move(b)); // const 右值
return 0;
}
std::forward 完美转发在传参的过程中保留对象原生类型属性
完美转发实际中的使用场景：
namespace aj
{
// List的节点类
template<class T>
struct ListNode
{
ListNode(const T& val = T())
:_val(val)
{}
ListNode<T>* _prev = nullptr;
ListNode<T>* _next = nullptr;
T _val;
};
//list类
template<class T>
class list
{
public:
typedef ListNode<T> Node;
typedef Node* PNode;
public:
// typedef ListIterator<T> iterator;
typedef ListIterator<T, T&, T*> iterator;
typedef ListIterator<T, const T&, const T&> const_iterator;
public:
// List的构造
list()
{
CreateHead();
}
iterator begin()
{
// return iterator(_head->_next);
return _head->_next;
}
iterator end()
{
// return iterator(_head);
return _head;
}
const_iterator begin()const
{
return _head->_next;
}
const_iterator end()const
{
return _head;
}
// List Modify
void push_back(const T&& val) { insert(end(), forward<T>(val)); }
void pop_back() { erase(--end()); }
void push_front(const T&& val) { insert(begin(), forward<T>(val); }
void pop_front() { erase(begin()); }
// 在pos位置前插入值为val的节点,返回插入新节点的位置
iterator insert(iterator pos, const T& val)
{
// 通过迭代器找到所需的节点指针
Node* cur = pos._pNode;
Node* prev = cur->_prev;
// 创建新的节点
Node* newnode = new Node(val);
// 节点间相互连接
newnode->_prev = prev;
prev->_next = newnode;
cur->_prev = newnode;
newnode->_next = cur;
// 节点数量++
_size++;
//return iterator(newnode);
return newnode;
}
iterator insert(iterator pos, const T&& val)
{
// 通过迭代器找到所需的节点指针
Node* cur = pos._pNode;
Node* prev = cur->_prev;
// 创建新的节点
Node* newnode = new Node(forward<T>(val));
// 节点间相互连接
newnode->_prev = prev;
prev->_next = newnode;
cur->_prev = newnode;
newnode->_next = cur;
// 节点数量++
_size++;
//return iterator(newnode);
return newnode;
}
private:
void CreateHead()
{
_head = new Node();
_head->_next = _head;
_head->_prev = _head;
_size = 0;
}
PNode _head; // 头结点
int _size; // 记录链表中节点的个数
};
};
八、新的类功能
8.1 默认成员函数
原来C++类中，有6个默认成员函数：
- 构造函数
- 析构函数
- 拷贝构造函数
- 拷贝赋值重载
- 取地址重载
- const 取地址重载
最后重要的是前4个，后两个用处不大。默认成员函数就是我们不写编译器会生成一个默认的。C++11 新增了两个：移动构造函数和移动赋值运算符重载
针对移动构造函数和移动赋值运算符重载有一些需要注意的点如下：
-
如果你没有自己实现移动构造函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个。那么编译器会自动生成一个默认移动构造。默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动构造，如果实现了就调用移动构造，没有实现就调用拷贝构造。
-
如果你没有自己实现移动赋值重载函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个，那么编译器会自动生成一个默认移动赋值。默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动赋值，如果实现了就调用移动赋值，没有实现就调用拷贝赋值。(默认移动赋值跟上面移动构造完全类似)
-
如果你提供了移动构造或者移动赋值，编译器不会自动提供拷贝构造和拷贝赋值。
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:
aj::string _name;
int _age;
};
int main()
{
Person p1;
Person p2 = s1;
Person p3 = std::move(p1);
Person p4;
p4 = std::move(p2);
return 0;
}
8.2 类成员变量初始化
C++11允许在类定义时给成员变量初始缺省值，默认生成构造函数会使用这些缺省值初始化，类和对象(中)中的构造函数和类和对象(下)中的初始化列表讲了，这里就不再细讲了。
8.3 强制生成默认函数的关键字default
C++11可以让你更好的控制要使用的默认函数。假设你要使用某个默认的函数，但是因为一些原因这个函数没有默认生成。比如：我们提供了拷贝构造，就不会生成移动构造了，那么我们可以使用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;
Person& operator=(const Person& p)
{
if(this != &p)
{
_name = p._name;
_age = p._age;
}
return *this;
}
~Person()
{}
private:
aj::string _name;
int _age;
};
int main()
{
Person p1;
Person p2 = s1;
Person p3 = std::move(p1);
return 0;
}
8.4 禁止生成默认函数的关键字delete
如果能想要限制某些默认函数的生成，在C++98中，是该函数设置成private，并且只声明补丁已，这样只要其他人想要调用就会报错。在C++11中更简单，只需在该函数声明加上=delete即可，该语法指示编译器不生成对应函数的默认版本，称=delete修饰的函数为删除函数。
class Person
{
public:
Person(const char* name = "", int age = 0)
:_name(name)
, _age(age)
{}
~Person() = delete;
private:
aj::string _name;
int _age;
};
int main()
{
// 无法引用 函数 "Person::~Person()" (已声明 所在行数 : 447)
// --它是已删除的函数 C++11
// Person s1;
return 0;
}
8.5 继承和多态中的final与override关键字
这个我们在多态章节已经进行了详细讲解这里就不再进行讲解。
结尾
如果有什么建议和疑问，或是有什么错误，大家可以在评论区中提出。
希望大家以后也能和我一起进步！！🌹🌹
如果这篇文章对你有用的话，希望大家给一个三连支持一下！！🌹🌹
