C++11特性补充

目录

lambda表达式

定义

捕捉的方式

可变模板参数

递归函数方式展开参数包

数组展开参数包

移动构造和移动赋值

包装器

绑定bind

智能指针

RAII

auto_ptr

unique_ptr

shared_ptr

循环引用

weak_ptr

补充

总结

特殊类的设计

不能被拷贝的类

只能在堆上创建类

将构造函数私有

将析构函数私有

只能在栈上创建对象

 只能创建一个对象（单例模式）

饿汉模式

懒汉模式

单例对象的释放

---

本文是对上一篇文章《C++11新特性》的补充，将会介绍过很多的C++11特性。

C++11新特性-CSDN博客文章浏览阅读987次，点赞30次，收藏30次。本文对C++11重要特性进行介绍，重点解析了C++中的左值引用和右值引用的区别，帮助读者快速了解C++11新特性以及这些特性的使用方法。https://blog.csdn.net/2401_87944878/article/details/147116766

lambda表达式

定义

C++中可调用对象有三种：函数，仿函数，以及lambda表达式。

函数的类型写起来太繁琐了，所以一般都会使用仿函数来替代函数，但是对于实现简单的函数实现，使用仿函数代码长，比较笨重；因此引出了lambda表达式来解决这一问题。

lambda表达式包含三个部分：1）捕捉列表；2）函数参数；3）函数返回值类型；4）函数体。

struct Add1
{int operator()(int x, int y){return x + y;}
};
auto Add2 = [](int x, int y)->int {return x + y  ;};
Add1()(1, 1);
Add2(1, 1);

以上分别是仿函数和lambda表达式实现加法函数，可以看出lambda表达式的使用更简约。

对于lambda表达式，如果没有参数，参数部分可以省略；返回值类型也可以不写，让编译器自动推导。

auto Add3 = [](int x, int y) {return x + y; };

函数指针---在C++中人不用就不用，其类型写起来不太方便；

仿函数---是一个类，重载了operator()； 

lambda---表达本质上是一个局部匿名函数对象。

lambda表达式的函数体内可以直接调用全局变量，但是不能直接调用局部变量或局部函数。如果需要使用局部对象就要将其添加至捕捉列表中。

void test_02()
{double rate = 0.5;auto Add3 = [rate](int x, int y) {return (x + y)*rate; };}

如上图，rate就实现了捕捉，在lambda表达式中可以只用rate。

捕捉的方式

捕捉的方式有四种：

1）[var]，对var进行值捕捉；

2）[&var]，对var进行引用捕捉，lambda表达式中var的改变会影响其外部的var；

3）[ = ]，对局部变量和函数进行全部值捕捉；

4）[ & ]，对局部变量和函数进行全部引用捕捉。

当然捕捉列表也可以混合起来使用。

int a = 1, b = 2;
int c = 10;
auto Add4 = [&, c] { a++, b++;cout << c; };

以上就是混合捕捉：对所有局部变量进行引用捕捉，除了c使用值捕捉。

lambda表达式的底层实际上还是仿函数。

lambda表达式在进行值捕捉的时候，默认捕捉后的类型是const修饰的，也就是说进行值捕捉后的参数是不能进行修改的，如果想要修改需要添加mutable关键字。

int a = 1, b = 2;
auto Add4 = [a, b]()mutable { a++, b++;cout << a << b; };

 使用mutable后，值捕捉的变量就就可以实现修改了。

---

可变模板参数

在C语言中就已经有可变参数的概念了，比如printf和scnaf的参数都属于可变参数；C++引入了模板概念，自然也有了可变模板参数概念。 

在C++11新增了可变模板参数，使得模板中参数可以不是固定的了，但是可变模板参数使用起来不太方便，此处我们进行简略介绍。

模板的参数是类型，函数的参数是对象，要将这两点分开。

template<class ... Args>
void Show(Args ... args)
{sizeof...(args);//....
}

模板中的Args指的是模板参数包，函数中的args指的是函数参数包；其中...表示其是可变参数，此处需要注意省略号的位置；通过sizeof...(args)可以打印出参数的个数。

参数包的语法不支持直接使用args[i]，所以参数包是不能直接使用的，需要先展开再使用；

递归函数方式展开参数包

通过递归依次减少参数，直到参数为零，其与参数递归类似，只不过递归停止的条件是参数。

template<class T>
void Show(T val)
{cout << val << endl;
}
template<class T ,class ... Args> 
void Show(T val ,Args ... args)
{cout << val << " ";Show(args...);
}
void test_03()
{Show(1);Show(1,"x");Show(1, "x", 1.3);
}

如图，上面通过两个重载函数来实现参数包的展开，参数大于1会优先匹配void Show(T val ,Args ... args)；当参数等于1的时候就去匹配void Show(T val)，此时递归结束。

数组展开参数包

template<class T>
int Show(T val)
{cout << val << " ";return 0;
}
template<class ... Args> 
void Show(Args ... args)
{int arr[] = { Show(args)... };cout << endl;
}
void test_03()
{Show(1);Show(1,"x");Show(1, "x", 1.3);
}

int arr[] = { Show(args)... }；数组元素个数是没有给定的所以需要通过对数组元素进行计数，此时就需要将参数包展开；

---

移动构造和移动赋值

C++11新增了两个默认成员函数：移动构造和移动赋值。

移动构造和移动赋值都属于移动语义，其是为了解决对于返回值的参数无法直接引用问题。

在无析构函数+无拷贝构造+无赋值重载+无移动构造的情况下，编译器会生成默认移动构造：对于内置类型进行浅拷贝，对于内置类型会去调用其自己的拷贝构造。

移动赋值也同理。

一般要写析构函数的内是深拷贝的类，需要写拷贝构造和赋值重载；

---

包装器

C++11引入了包装器function，通过包装器可以实现将函数，仿函数以及lambda表达式类型统一。

void Print1()
{cout << "hello world" << endl;
}
struct Print2
{void operator()(){cout << "hello world" << endl;}
};
void test_04()
{auto Print3 = [] {cout << "hello world" << endl; };cout << typeid(Print1).name() << endl;cout << typeid(Print2()).name() << endl;cout << typeid(Print3).name() << endl;
}

以上三个可调用对象实现的功能都是一样的，此处可以使用typeid().name打印出其三个可调用对象的类型。

可以看出三者类型是完全不同的，C++11引入了包装器function使得可以通过函数返回值，参数将不同的可调用对象类型统一。

function<void()> arr[] = { Print1,Print2(),Print3 };

以上将三个可调用对象都放入到了数组中，其类型都是function<void()>，关于function的使用方法就是：function<函数返回值(函数参数)>，function使用时的头文件是<functional>。

包装器function的本质是一个适配器，可以对函数指针，仿函数以及lambda表达式进行包装。

---

绑定bind

对于库中的有些接口，参数传递很多并且有些参数是固定的；此时就可以通过bind绑定将接口参数进行绑定。

double RAdd(int x, int y, double rate)
{return (x + y) * rate;
}void test_05()
{//如果rate始终是固定的，不需要进行修改次数就可以使用绑定bindauto RAdd2 = bind(RAdd, placeholders::_1, placeholders::_2, 0.54);cout << RAdd2(10, 4) << endl;
}

bind的参数：可调用对象；参数匹配的位置：10就和_1位置匹配，4就和_2位置匹配，_1和_2有分别和函数参数匹配即x和y；

通过对_1和_2位置的调换，可以出现不同的结果。

如下图所示：通过对_1和_2位置的调换可能会导致函数的调用发生变化。

 补充：对于类成员函数的绑定是不同的：对于非静态成员函数要加&，并且要给出对象或对象地址；对于静态成员函数可以不加&，但是建议加上。

class A
{
public:static int Add1(int x, int y){return x + y;}int Add2(int x, int y){return x + y;}private:int _a;
};void test_05()
{//非静态成员函数的绑定auto CAdd1 = bind(&A::Add2, A(), placeholders::_1, placeholders::_2);A aa;auto CAdd2 = bind(&A::Add2, &aa, placeholders::_1, placeholders::_2);//静态成员函数的绑定auto CAdd3 = bind(&A::Add1, placeholders::_1, placeholders::_2);}

---

智能指针

C++中对于错误的处理是使用抛异常的方式解决的，抛异常就会导致进程流被修改，当进程流改变后，原本需要释放的内存没有走到delete就会导致内存泄漏。

为了解决这一问题可以采用多次抛异常，在抛异常前进行空间的释放，如果一个函数中有多个位置进行了空间开辟，当抛异常后还需要考虑哪一个需要释放，这就导致了情况多，代码繁琐的问题。 

能不能一个空间开辟后，出作用域就销毁呢？？？此时就可以使用智能指针来实现。

 智能指针通过将指针交给对象，让对象进行资源的管理，在对象出作用域时调析构函数进行资源的释放。

template<class T>
class Ptr
{
public:Ptr(T* ptr):_ptr(ptr){}Ptr(const Ptr& p):_ptr(p._ptr){}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}~Ptr(){delete _ptr;}
private:T* _ptr;
};

以上是对智能指针的简单模拟实现，但是在使用的时候，对指针进行拷贝构造时就会出现对同一块区域的多次释放。在C++中有不同的智能指针，不同的指针处理方式也是不同的。 

RAII

资源获取即初始化，利用对象生命周期来控制资源，在构造函数时获取资源，在对象析构时销毁资源。

优势：1）不需要显式释放空间，出作用域自动销毁；

2）对象所需的资源在其生命周期类持续有效；

auto_ptr

auto_ptr是C++98时推出的一个智能指针；auto_ptr对于指针拷贝的方法是：将空间的管理权转移，在完成拷贝构造之后，将被拷贝对象置空。其底层实现如下：

template<class T>
class auto_ptr
{
public:auto_ptr(T* ptr):_ptr(ptr){}auto_ptr(const auto_ptr& p):_ptr(p._ptr){p._ptr = nullptr;}auto_ptr operator=(const auto_ptr& p){_ptr = p._ptr;p._ptr = nullptr;return *this;}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}~auto_ptr(){delete _ptr;}
private:T* _ptr;
};

可以看到，在拷贝完成后，被拷贝对象悬空导致其无法使用，这使得auto_ptr不被广泛使用。

unique_ptr

unique_ptr对于拷贝和赋值的处理方法更加暴力，unique_ptr不支持赋值和拷贝构造。

所以在实现的时候，需要将拷贝和赋值只声明不定义，并且置为私有防止其在外面被定义，为防止编译器自动生成在函数后面加上delete。

template<class T>
class unique_ptr
{
public:unique_ptr(T* ptr):_ptr(ptr){}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}~unique_ptr(){delete _ptr;}
private:unique_ptr(const unique_ptr& p) = delete;unique_ptr operator=(const unique_ptr& p) = delete;T* _ptr;
};

shared_ptr

shared_ptr通过对指向每个空间的指针进行计数来实现对空间的释放，当一个指向一个空间的指针数量为0是对空间进行释放；

所以shared_ptr需要添加一个成员变量来实现计数。

template<class T>
class shared_ptr
{
public:shared_ptr(T* ptr):_ptr(ptr),_pcount(new int(1)){}shared_ptr(const shared_ptr& p):_ptr(p._ptr),_pcount(p._pcount){++(*_pcount);}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}shared_ptr operator=(const shared_ptr& p){_ptr = p._ptr;_pcount = p._pcount;++(*_pcount);return *this;	}~shared_ptr(){if (--(*_pcount) == 0){delete _ptr;}}
private:T* _ptr;int* _pcount;
};

shared_ptr确实解决了何时释放的问题，但是又出现了循环引用的问题。

循环引用

当一个对象有前后指针的时候就会出现问题，比如一下代码。

template<class T>
struct Node
{Node():_a(T()),_next(nullptr),_prev(nullptr){ }T _a;shared_ptr<Node> _next;shared_ptr<Node> _prev;
};void test_06()
{shared_ptr<Node<int>> aa(new Node<int>);shared_ptr<Node<int>> bb(new Node<int>);aa->_next = bb;bb->_prev = aa;
}

当aa的后继指针指向bb的时候，bb的引用计数就变成了2，同理aa的引用计数也编程了2。当对aa进行销毁的时候，其引用计数是2无法调用Node的析构，也就不能进行_next和_prev的析构了，此时就出现了空间泄露。

为了解决这一问题添加了weak_ptr。

weak_ptr

weak_ptr与shared_ptr的使用是一样的，只是在对shared_ptr拷贝的时候不会对引用计数进行改变。weak_ptr不遵循RAII，其是专门为解决循环引用而出现的。

template<class T>
class weak_ptr
{
public:weak_ptr(T* ptr):_ptr(ptr){}weak_ptr(const shared_ptr<T>& p):_ptr(p._ptr){}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}weak_ptr operator=(const shared_ptr<T>& p){_ptr = p._ptr;return *this;}
private:T* _ptr;
};

上面Node类定义变为：

template<class T>
struct Node
{Node():_a(T()),_next(nullptr),_prev(nullptr){ }T _a;weak_ptr<Node> _next;weak_ptr<Node> _prev;
};

补充

shared_ptr<int> aa(new int[10]);

当我们开辟一个数组的空间时，释放时再使用delete就不能进行空间释放了，所以对于shared_ptr和unique_ptr的参数增加了一个：释放对象。

结合lambda表达式使用起来更加简单。Del的类型可以使用function表示。

template<class T, class Del=function<void(T*)>>
class shared_ptr
{
public:shared_ptr(T* ptr, Del del = [](T* ptr) {delete ptr; }):_ptr(ptr),_pcount(new int(1)),_del(del){}shared_ptr(const shared_ptr<T>& p):_ptr(p._ptr),_pcount(p._pcount){++(*_pcount);}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}shared_ptr operator=(const shared_ptr<T>& p){_ptr = p._ptr;_pcount = p._pcount;++(*_pcount);return *this;}~shared_ptr(){if (--(*_pcount) == 0){_del(_ptr);}}
private:T* _ptr;int* _pcount;Del _del;
};

shared_ptr<int> a(new int[10], [](int* ptr) {delete[] ptr; });
shared_ptr<FILE> b(fopen("test.txt", "w"), [](FILE* ptr) {fclose(ptr); });

总结

auto_ptr：管理权转移，被拷贝的对象会悬空；

unique_ptr：不支持赋值和拷贝构造；

shared_ptr：通过引用计数控制内存的释放；

weak_ptr：解决shared_ptr的循环引用问题，拷贝和赋值的时候不增加引用计数。

---

特殊类的设计

不能被拷贝的类

C++11增加了delete的功能，不仅能对new的空间进行释放，放在默认成员函数后面还能表示：不让编译器生成该函数。

实现：将拷贝和赋值置为私有，且使用delete不让编译器生成即可。

template<class T>
class NoCopy
{
public://...
private:NoCopy(const NoCopy&) = delete;NoCopy operator=(const NoCopy&) = delete;T _val;
};

只能在堆上创建类

也就是不能再栈上创建对象，栈上创建对象必须能够调用构造函数和析构函数，所以对于类的实现有两种方法：1）将构造函数私有；2）将析构函数私有；还需要将拷贝构造和赋值删除。

将构造函数私有

将构造函数私有之后，new也不能调用构造函数了，所以需要增加接口专门返回在对上创建的对象。

template<class T>
class HeapOnly
{static HeapOnly* Get(){return new HeapOnly;}private:HeapOnly(const HeapOnly&) = delete;HeapOnly operator=(const HeapOnly&) = delete;HeapOnly(){//...}T _val;
};

将析构函数私有

将析构函数私有之后，还需要提供接口进行空间的释放。

template<class T>
class HeapOnly
{HeapOnly(){//...}private:~HeapOnly(){//...}HeapOnly(const HeapOnly&) = delete;HeapOnly operator=(const HeapOnly&) = delete;T _val;
};

只能在栈上创建对象

对于只能在栈上创建对象，就需要不能让new正常使用，new分为两步：1）调用operator new；2）调用构造函数；

实现：重载operator new，将其删除并将构造函数私有；向外提供构造接口。

template<class T>
class StackOnly
{static StackOnly Creat(){StackOnly st;return st;}~StackOnly(){//...}
private:void* operator new(size_t size) = delete;StackOnly(){//...}T _val;
};

 只能创建一个对象（单例模式）

创建一个类只能创建一个对象，这中类称为单例模式。

实现方法：1）只创建一个对象，将这个对象设为类的及静态成员，在每次获取的时候都将这一静态成员返回；2）将构造函数设为私有，防构造；3）防拷贝，将拷贝和赋值删除。

该类分为两种：饿汉模式和懒汉模式。

饿汉模式

饿汉模式指的是在main函数之前就创建出对象。

class Hungry_class
{
public:Hungry_class& Get(){return _date;}private:Hungry_class(const Hungry_class&) = delete;Hungry_class operator=(Hungry_class) = delete;Hungry_class(){//...}static Hungry_class _date;
};
Hungry_class Hungry_class::_date;

函数自始至终都只有一个对象_date。

饿汉模式的劣势：

1）在main函数之前就进行对象的创建，当有多个单例模式需要被创建时就会影响程序的启动效率。

2）如果两个单例类A和B之间相互联系，B的创建需要A，如果还是使用饿汉模式就会导致无法控制哪一个单例对象先创建。

懒汉模式

懒汉模式与饿汉不同的是：懒汉模式是在需要单例对象时才去创建。

实现方法：与饿汉模式一样，但是懒汉的成员变量是指针而不是对象。

class Lazy_class
{
public:Lazy_class& Get(){if (_date == nullptr){Lazy_class* _date = new Lazy_class;}return *_date;}private:Lazy_class(const Lazy_class&) = delete;Lazy_class operator=(Lazy_class) = delete;Lazy_class(){//...}T _val;static Lazy_class* _date;
};
Lazy_class* Lazy_class::_date;

单例对象的释放

一般单例对象是不需要进行释放的，但是如果中途需要进行显示释放或程序需要进行一些特殊动作（如持久化）等；

单例对象通常是在多个进程中使用的，所以单例对象的释放不能简单的根据作用域让其自己释放，需要提供专门的接口释放。

单例模式析构可以手动调用，也可以像智能指针一样自动调用。

可以通过设计一个内部类实现自动调用析构函数。

class Lazy_class
{
public:static Lazy_class& Get(){if (_date == nullptr){Lazy_class* _date = new Lazy_class;}return *_date;}static void Destory(){//...}struct GC{~GC(){Lazy_class::Destory();}};private:Lazy_class(const Lazy_class&) = delete;Lazy_class operator=(Lazy_class) = delete;Lazy_class(){//...}static Lazy_class* _date;static GC _gc;
};
Lazy_class* Lazy_class::_date;
Lazy_class::GC Lazy_class::_gc;