C++11

1.匿名函数：lambda表达式

一般的lambda表达式语法是

[捕获列表] (参数列表) -> 返回类型 {函数体}

->返回类型可以省略；如果是无参的，(参数列表)也可以省略，真是各种省。匿名函数是个lambda对象，和函数指针有区别，但一般不用关心它。如果你想把一个匿名函数赋给一个函数指针类似物以待后续使用，可以用auto

auto func = [](int arg) { ... };

2.Strongly-typed enums强类型枚举

传统的C++枚举类型存在一些缺陷：它们会将枚举常量暴露在外层作用域中（这可能导致名字冲突，如果同一个作用域中存在两个不同的枚举类型，但是具有相同的枚举常量就会冲突），而且它们会被隐式转换为整形，无法拥有特定的用户定义类型。在C++11中通过引入了一个称为强类型枚举的新类型，修正了这种情况。强类型枚举由关键字enum class标识。它不会将枚举常量暴露到外层作用域中，也不会隐式转换为整形，并且拥有用户指定的特定类型（传统枚举也增加了这个性质）。

enum class Options {None, One, All};
Options o = Options::All;

3.Override和final

时至今日仍然没有一个强制的机制来标识虚函数会在派生类里被改写。vitual关键字是可选的，这使得阅读代码变得很费劲。因为可能需要追溯到继承体系的源头才能确定某个方法是否是虚函数。为了增加可读性，我总是在派生类里也写上virtual关键字，并且也鼓励大家都这么做。即使这样，仍然会产生一些微妙的错误。看下面这个例子：

class B 
{
public:
   virtual void f(short) {std::cout << "B::f" << std::endl;}
};
 
class D : public B
{
public:
   virtual void f(int) {std::cout << "D::f" << std::endl;}
};

D::f 按理应当重写 B::f。然而二者的声明是不同的，一个参数是short，另一个是int。因此D::f只是拥有同样名字的另一个函数（重载）而不是重写。当你通过B类型的指针调用f()可能会期望打印出D::f，但实际上则会打出 B::f 。

另一个很微妙的错误情况：参数相同，但是基类的函数是const的，派生类的函数却不是。

class B 
{
public:
   virtual void f(int) const {std::cout << "B::f " << std::endl;}
};
 
class D : public B
{
public:
   virtual void f(int) {std::cout << "D::f" << std::endl;}
};

同样，这两个函数是重载而不是重写，所以你通过B类型指针调用f()将打印B::f，而不是D::f。

幸运的是，现在有一种方式能描述你的意图。新标准加入了两个新的标识符（不是关键字）:：

override，表示函数应当重写基类中的虚函数。

final，表示派生类不应当重写这个虚函数。

第一个的例子如下：

class B 
{
public:
   virtual void f(short) {std::cout << "B::f" << std::endl;}
};
 
class D : public B
{
public:
   virtual void f(int) override {std::cout << "D::f" << std::endl;}
};

现在这将触发一个编译错误（后面那个例子，如果也写上override标识，会得到相同的错误提示）：

'D::f' : method with override specifier 'override' did not override any base class methods

另一方面，如果你希望函数不要再被派生类进一步重写，你可以把它标识为final。

可以在基类或任何派生类中使用final。在派生类中，可以同时使用override和final标识。

class B 
{
public:
   virtual void f(int) {std::cout << "B::f" << std::endl;}
};
 
class D : public B
{
public:
   virtual void f(int) override final {std::cout << "D::f" << std::endl;}
};
 
class F : public D
{
public:
   virtual void f(int) override {std::cout << "F::f" << std::endl;}
};

被标记成final的函数将不能再被F::f重写。

4.Smart Pointers 智能指针

智能指针在C++11版本之后提供，包含在头文件<memory>中，shared_ptr、unique_ptr、weak_ptr

shared_ptr多个指针指向相同的对象。shared_ptr使用引用计数，每一个shared_ptr的拷贝都指向相同的内存。每使用他一次，内部的引用计数加1，每析构一次，内部的引用计数减1，减为0时，自动删除所指向的堆内存。shared_ptr内部的引用计数是线程安全的，但是对象的读取需要加锁。

初始化。智能指针是个模板类，可以指定类型，传入指针通过构造函数初始化。也可以使用make_shared函数初始化。不能将指针直接赋值给一个智能指针，一个是类，一个是指针。例如std::shared_ptr p4 = new int(1);的写法是错误的

拷贝和赋值。拷贝使得对象的引用计数增加1，赋值使得原对象引用计数减1，当计数为0时，自动释放内存。后来指向的对象引用计数加1，指向后来的对象。

get函数获取原始指针

注意不要用一个原始指针初始化多个shared_ptr，否则会造成二次释放同一内存

#include <iostream>
#include <memory>

int main() {
	{   
		int a = 10; 
		std::shared_ptr<int> ptra = std::make_shared<int>(a);
		std::shared_ptr<int> ptra2(ptra); //copy
		std::cout << ptra.use_count() << std::endl;

		int b = 20; 
		int *pb = &a; 
		//std::shared_ptr<int> ptrb = pb;  //error
		std::shared_ptr<int> ptrb = std::make_shared<int>(b);
		ptra2 = ptrb; //assign
		pb = ptrb.get(); //获取原始指针

		std::cout << ptra.use_count() << std::endl;
		std::cout << ptrb.use_count() << std::endl;
		std::cout << *pb << std::endl;                                                                                                                                                                   
	}   
}

unique_ptr“唯一”拥有其所指对象，同一时刻只能有一个unique_ptr指向给定对象（通过禁止拷贝语义、只有移动语义来实现）。

相比与原始指针unique_ptr用于其RAII的特性，使得在出现异常的情况下，动态资源能得到释放。 unique_ptr指针本身的生命周期：从unique_ptr指针创建时开始，直到离开作用域。离开作用域时，若其指向对象，则将其所指对象销毁(默认使用delete操作符，用户可指定其他操作)。

unique_ptr指针与其所指对象的关系：在智能指针生命周期内，可以改变智能指针所指对象，如创建智能指针时通过构造函数指定、通过reset方法重新指定、通过release方法释放所有权、通过移动语义转移所有权。

#include <iostream>
#include <memory>

int main() {
	{
		std::unique_ptr<int> uptr(new int(10));  //绑定动态对象
		//std::unique_ptr<int> uptr2 = uptr;  //不能賦值
		//std::unique_ptr<int> uptr2(uptr);  //不能拷貝
		std::unique_ptr<int> uptr2 = std::move(uptr); //轉換所有權
		uptr2.release(); //释放所有权
	}
	//超過uptr的作用域，內存釋放
}

weak_ptr是为了配合shared_ptr而引入的一种智能指针，因为它不具有普通指针的行为，没有重载operator*和->, 它的最大作用在于协助shared_ptr工作，像旁观者那样观测资源的使用情况。

weak_ptr可以从一个shared_ptr或者另一个weak_ptr对象构造，获得资源的观测权。但weak_ptr没有共享资源，它的构造不会引起指针引用计数的增加。

使用weak_ptr的成员函数use_count()可以观测资源的引用计数，另一个成员函数expired()的功能等价于use_count()==0,但更快，表示被观测的资源(也就是shared_ptr的管理的资源)已经不复存在。

weak_ptr可以使用一个非常重要的成员函数lock()从被观测的shared_ptr获得一个可用的shared_ptr对象，从而操作资源。但当expired()==true的时候，lock()函数将返回一个存储空指针的shared_ptr。

#include <iostream>
#include <memory>

int main() {
	{
		std::shared_ptr<int> sh_ptr = std::make_shared<int>(10);
		std::cout << sh_ptr.use_count() << std::endl;

		std::weak_ptr<int> wp(sh_ptr);
		std::cout << wp.use_count() << std::endl;

		if(!wp.expired()){
			std::shared_ptr<int> sh_ptr2 = wp.lock(); //get another shared_ptr
			*sh_ptr = 100;
			std::cout << wp.use_count() << std::endl;
		}
	}
	//delete memory
}	

循环引用

在C++ 里边就要为资源管理费一番脑筋。如果使用原始指针作为成员， Child和Parent由谁释放？那么如何保证指针的有效性？如何防止出现空悬指针？这些问题是C++面向对象编程麻烦的问题，

现在可以借助smart pointer把对象语义（pointer）转变为值（value）语义， shared_ptr轻松解决生命周期的问题，不必担心空悬指针。但是这个模型存在循环引用的问题，注意其中一个指针应该为weak_ptr。

智能指针的设计和实现

下面是一个简单智能指针的demo。智能指针类将一个计数器与类指向的对象相关联，引用计数跟踪该类有多少个对象共享同一指针。

每次创建类的新对象时，初始化指针并将引用计数置为1；当对象作为另一对象的副本而创建时，拷贝构造函数拷贝指针并增加与之相应的引用计数；对一个对象进行赋值时，赋值操作符减少左操作数所指对象的引用计数（如果引用计数为减至0，则删除对象），并增加右操作数所指对象的引用计数；调用析构函数时，构造函数减少引用计数（如果引用计数减至0，则删除基础对象）。智能指针就是模拟指针动作的类。

所有的智能指针都会重载 -> 和 * 操作符。智能指针还有许多其他功能，比较有用的是自动销毁。这主要是利用栈对象的有限作用域以及临时对象（有限作用域实现）析构函数释放内存。

#include <iostream>
#include <memory>

template<typename T>
class SmartPointer {
private:
	T* _ptr;
	size_t* _count;
public:
	SmartPointer(T* ptr = nullptr) :
			_ptr(ptr) {
		if (_ptr) {
			_count = new size_t(1);
		} else {
			_count = new size_t(0);
		}
	}

	SmartPointer(const SmartPointer& ptr) {
		if (this != &ptr) {
			this->_ptr = ptr._ptr;
			this->_count = ptr._count;
			(*this->_count)++;
		}
	}

	SmartPointer& operator=(const SmartPointer& ptr) {
		if (this->_ptr == ptr._ptr) {
			return *this;
		}

		if (this->_ptr) {
			(*this->_count)--;
			if (this->_count == 0) {
				delete this->_ptr;
				delete this->_count;
			}
		}

		this->_ptr = ptr._ptr;
		this->_count = ptr._count;
		(*this->_count)++;
		return *this;
	}

	T& operator*() {
		assert(this->_ptr == nullptr);
		return *(this->_ptr);

	}

	T* operator->() {
		assert(this->_ptr == nullptr);
		return this->_ptr;
	}

	~SmartPointer() {
		(*this->_count)--;
		if (*this->_count == 0) {
			delete this->_ptr;
			delete this->_count;
		}
	}

	size_t use_count(){
		return *this->_count;
	}
};

int main() {
	{
		SmartPointer<int> sp(new int(10));
		SmartPointer<int> sp2(sp);
		SmartPointer<int> sp3(new int(20));
		sp2 = sp3;
		std::cout << sp.use_count() << std::endl;
		std::cout << sp3.use_count() << std::endl;
	}
	//delete operator
}

C++11中智能指针的原理、使用、实现 https://www.cnblogs.com/wxquare/p/4759020.html

5.std::function

#include <iostream>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <string>
#include <algorithm>
#include <functional>
#include <memory>
using namespace std;
 
//声明一个模板
typedef std::function<int(int)> Functional;
 
 
//normal function
int TestFunc(int a)
{
	return a;
}
 
//lambda expression
auto lambda = [](int a)->int{return a;};
 
//functor仿函数
class Functor
{
public:
	int operator() (int a)
	{
		return a;
	}
};
 
 
//类的成员函数和类的静态成员函数
class CTest
{
public:
	int Func(int a)
	{
		return a;
	}
	static int SFunc(int a)
	{
		return a;
	}
};
 
 
int main(int argc, char* argv[])
{
	//封装普通函数
	Functional obj = TestFunc;
	int res = obj(0);
	cout << "normal function : " << res << endl;
 
	//封装lambda表达式
	obj = lambda;
	res = obj(1);
	cout << "lambda expression : " << res << endl;
 
	//封装仿函数
	Functor functorObj;
	obj = functorObj;
	res = obj(2);
	cout << "functor : " << res << endl;
 
	//封装类的成员函数和static成员函数
	CTest t;
	obj = std::bind(&CTest::Func, &t, std::placeholders::_1);
	res = obj(3);
	cout << "member function : " << res << endl;
 
	obj = CTest::SFunc;
	res = obj(4);
	cout << "static member function : " << res << endl;
 
	return 0;
}

6.std::bind

//学习bind的用法
void f(int n1, int n2, int n3, const int & n4, int n5)
{
	std::cout << n1 << ' ' << n2 << ' ' << n3 << ' ' << n4 << ' ' << n5 << "\n";
}

int n = 7;
auto f1 = std::bind(f, std::placeholders::_2, std::placeholders::_1, 43, std::cref(n), n);
//第一位置 目标函数（f）的第一个参数 是调用时传的第二个参数
//第二位置 目标函数（f）的第二个参数 是调用时传的第一个参数
//第三位置 目标函数（f）的第三个参数 是43
//第四位置 目标函数（f）的第四个参数 是n的按址传递
//第五位置 目标函数（f）的第五个参数 是n
n = 10;
f1(1, 2);//相当于f(2,1,43,10,7);

#include <iostream>
#include <functional>   //std::cout
using namespace std;
using namespace std::placeholders;    // adds visibility of _1, _2, _3,...

class Test
{
public:
    int i = 0;

    void func(int x, int y)
    {
        cout << x << " " << y << endl;
    }
};

int main()
{
    Test obj; //创建对象

    function<void(int, int)> f1 = bind(&Test::func, &obj, _1, _2);
    f1(1, 2);   //输出：1 2

    function< int &()> f2 = bind(&Test::i, &obj);
    f2() = 123;
    cout << obj.i << endl;//结果为 123

    return 0;
}

#include <random>
#include <iostream>
#include <memory>
#include <functional>
 
void f(int n1, int n2, int n3, const int& n4, int n5)
{
    std::cout << n1 << ' ' << n2 << ' ' << n3 << ' ' << n4 << ' ' << n5 << '\n';
}
 
int g(int n1)
{
    return n1;
}
 
struct Foo {
    void print_sum(int n1, int n2)
    {
        std::cout << n1+n2 << '\n';
    }
    int data = 10;
};
 
int main()
{
    using namespace std::placeholders;  // 对于 _1, _2, _3...
 
    // 演示参数重排序和按引用传递
    int n = 7;
    // （ _1 与 _2 来自 std::placeholders ，并表示将来会传递给 f1 的参数）
    auto f1 = std::bind(f, _2, _1, 42, std::cref(n), n);
    n = 10;
    f1(1, 2, 1001); // 1 为 _1 所绑定， 2 为 _2 所绑定，不使用 1001
                    // 进行到 f(2, 1, 42, n, 7) 的调用
 
    // 嵌套 bind 子表达式共享占位符
    auto f2 = std::bind(f, _3, std::bind(g, _3), _3, 4, 5);
    f2(10, 11, 12); // 进行到 f(12, g(12), 12, 4, 5); 的调用
 
    // 常见使用情况：以分布绑定 RNG
    std::default_random_engine e;
    std::uniform_int_distribution<> d(0, 10);
    std::function<int()> rnd = std::bind(d, e); // e 的一个副本存储于 rnd
    for(int n=0; n<10; ++n)
        std::cout << rnd() << ' ';
    std::cout << '\n';
 
    // 绑定指向成员函数指针
    Foo foo;
    auto f3 = std::bind(&Foo::print_sum, &foo, 95, _1);
    f3(5);
 
    // 绑定指向数据成员指针
    auto f4 = std::bind(&Foo::data, _1);
    std::cout << f4(foo) << '\n';
 
    // 智能指针亦能用于调用被引用对象的成员
    std::cout << f4(std::make_shared<Foo>(foo)) << '\n'
              << f4(std::make_unique<Foo>(foo)) << '\n';
}

附录

1.C++11初探：lambda表达式和闭包 http://www.cnblogs.com/npbool/p/3434757.html

2.C++11初探：类型推导，auto和decltype http://www.cnblogs.com/npbool/p/3433360.html

扫描关注我

（转载本站文章请注明作者和出处 Undefined）