C++11Lambda表达式|智能指针

Lambda表达式:

定义：

        可以理解为一个匿名函数。和函数一样，lambda表达式具有一个返回类型、一个参数列表和一个函数体。

语法：[capture list] (parameter list) -> return type {function body}

capture list：表示捕获列表，捕获的是lambda所在函数中定义的局部变量
parameter list：表示参数列表
return type：返回类型
function body：函数体

捕获列表：

1.  auto func = [](int a) {return a; };//捕获列表为空，即什么都不捕获

2.  int b=10;

     auto func = [b]() {return b; };//值捕获，仅获取值，不获取指针

3   int b=10;

     auto func = [&b]() { b=99;return b; };//引用捕获，获取值，获取指针(可修改值),调用func()后，b变为99。

---------------------------------------------------------------------------------------------------

4  int i = 10;
    int j = 20;
    int k = 30;

    auto test1 = [=]() { cout <<"i为："<< i << endl <<"j为：" << j << endl<< "k为：" << k << endl; };// 捕获列表中的”=“表示，获取Lambda表达式所在函数体内的所有局部变量，叫默认值捕获，仅可获取值，不获取指针

5  int i = 10;
    int j = 20;
    int k = 30;

    auto test3 = [&]() { i=k=j = 999; cout << "i为：" << i << endl << "j为：" << j << endl << "k为：" << k << endl; };// i，j和k的值都被修改为999，因为捕获列表中的"="表示获取Lambda表达式所在函数体内所有局部变量的引用，叫默认引用捕获。获取指针和值，可修改值。

代码实现验证：

#include<iostream>
using namespace std;
int main()
{
	int i = 10;
	int j = 20;
	int k = 30;
	auto func = [](int a) {return a; };
	cout << "func为：" << func(10) << endl;

	auto max = [](int a, int b) {if (a > b) { return a; } else return b; };
	cout << endl<< "max为：" << max(4, 44) << endl;

	auto test1 = [=]() { cout <<"i为："<< i << endl <<"j为：" << j << endl<< "k为：" << k << endl; };
	auto test2 = [=, &i]() { i = 99; cout << "i为：" << i << endl << "j为：" << j << endl << "k为：" << k << endl; };
	auto test3 = [&, i]() { k=j = 999; cout << "i为：" << i << endl << "j为：" << j << endl << "k为：" << k << endl; };

	cout << endl << "test1----------------" << endl;
	test1();

	cout << endl << "test2----------------" << endl;
	test2();
	cout << "i的值为：" << i << endl;

	cout << endl << "test3----------------" << endl;
	test3();
	cout << "i的值为：" << i << endl;

	return 0;
}

测试：

 i的值在test2()和test3()中不一样，但是在main函数体内，调用test2()后i的值一直是99，说明了Lambda表达式在预编译阶段完成。

function及bind函数：

#include<iostream>
using namespace std;
#include<functional>

class Test
{
public:
	static int myTest(int n)
	{
		return n;
	}

	int operator()(int n)
	{
		return n;
	}
};
int test(int n)
{
	return n;
}
void foo(int a,int b, int c)
{
	cout << a << b << c << endl << endl;
}
int main() 
{
	//函数对象包装器
	//为函数提供容器（即封装）

	//支持四种函数
	//1.普通函数
	function<int(int)> f1= test;
	cout << "f1=" << f1(100) << endl;

	auto f2 = test;
	cout << "f2=" << f2(200) << endl;;

	//2.匿名函数
	function<int(int)> f3 = [](int n)->int {return n; };
	cout << "f3=" << f3(300) << endl;

	function<int(int)> f4 = [](int n) {return n; };
	cout << "f4=" << f4(400) << endl;

	//3.成员函数
	function<int(int)> f5 =Test::myTest;
	//auto f5 = &Test::myTest;
	Test t1;
	cout << "f5=" << f5(500) << endl;


	//4.仿函数
	function<int(Test*, int)> f6 = &Test::operator();
	cout << "f6=" << f6(&t1, 600) << endl;

	auto f7=bind(foo, 10, 20, 30);
	f7();

	auto f8 = bind(foo, 10, placeholders::_1, 30);
	f8(20);

	auto f9 = bind(foo, placeholders::_2, placeholders::_1, 30);
	f9(10,20);
	return 0;
}

   auto f9 = bind(foo, 10, placeholders::_1, 30);

   //error! 因为第一个参数还没使用就使用第二个参数了
   f9(20);//error! 

测试：

智能指针：

unique_ptr:

        有且仅有一个，不能拷贝，不能赋值。假设两个引用指向同一个指针，如果一个引用销毁了该指针，那么另一个引用则为空，会导致内存泄露，因此编译器不让unique指针进行赋值或拷贝操作。

unique_ptr<Test> t1 = make_unique<Test>();

unique_ptr<Test> t1(new Test());// 可能会出现异常安全问题

unique_ptr<Test> t2 = t1；//error!

 shared_ptr:

        该指针可共享，（都为共享指针时）赋值或拷贝一次会增加引用数，当引用数为零时，内存释放。什么情况下，引用减少呢？就是共享指针脱离作用域时减少一次引用数。

shared_ptr<Test> t2 = make_shared<Test>();//进行一次内存分配

shared_ptr<Test> t3 (new Test());//会进行两次内存分配，new了后再拷贝，共两次。

shared_ptr<Test> t4；

t4=t3;//引用数+1。

 weak_ptr:

        目的是为配合 shared_ptr 而引入的一种智能指针来协助 shared_ptr 工作, 它只可以从一个 shared_ptr 或另一个 weak_ptr 对象构造。不会增加共享指针的引用数，也是在作用域内生存，脱离生存期立即死亡。