C++11的简单介绍(下)

1.lambda表达式

1.1lambda表达式

我们直接用代码进行演示:

复制代码
int main()
{
 vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2, 
3 }, { "菠萝", 1.5, 4 } };
 sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2){
 return g1._price < g2._price; });
 sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2){
 return g1._price > g2._price; });
 sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2){
 return g1._evaluate < g2._evaluate; });
 sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2){
 return g1._evaluate > g2._evaluate; });
}

上述代码就是使用C++11中的lambda表达式来解决,可以看出lambda表达式实际是一个匿名函数。

1.2lambda表达式语法

lambda表达式书写格式:[capture-list] (parameters) mutable -> return-type { statement }

1 lambda表达式各部分说明

1 [capture-list] : 捕捉列表 ,该列表总是出现在lambda函数的开始位置,编译器根据[]来判断接下来的代码是否为lambda函数,捕捉列表能够捕捉上下文中的变量供lambda函数使用。

2 (parameters):参数列表 。与普通函数的参数列表一致,如果不需要参数传递,则可以连同()一起省略

3 mutable:默认情况下,lambda函数总是一个const函数,mutable可以取消其常量性。使用该修饰符时,参数列表不可省略(即使参数为空)。

4 ->returntype:返回值类型 。用追踪返回类型形式声明函数的返回值类型,没有返回值时此部分可省略。返回值类型明确情况下,也可省略,由编译器对返回类型进行推导。

5 {statement}:函数体。在该函数体内,除了可以使用其参数外,还可以使用所有捕获到的变量。

注意:

在lambda函数定义中,参数列表和返回值类型都是可选部分 ,而捕捉列表和函数体可以为空。因此C++11中最简单的lambda函数为:[]{}; 该lambda函数不能做任何事情

复制代码
int main()
{
    // 最简单的lambda表达式, 该lambda表达式没有任何意义
   []{}; 
    
    // 省略参数列表和返回值类型,返回值类型由编译器推导为int
    int a = 3, b = 4;
   [=]{return a + 3; }; 
    
    // 省略了返回值类型,无返回值类型
    auto fun1 = [&](int c){b = a + c; }; 
    fun1(10)
    cout<<a<<" "<<b<<endl;
    
    // 各部分都很完善的lambda函数
    auto fun2 = [=, &b](int c)->int{return b += a+ c; }; 
    cout<<fun2(10)<<endl;
    
    // 赋值捕捉x
    int x = 10;
    auto add_x = [x](int a) mutable { x *= 2; return a + x; }; 
    cout << add_x(10) << endl; 
    return 0;
}

通过上述例子可以看出,lambda表达式实际上可以理解为无名函数 ,该函数无法直接调用,如果想要直接调用,可借助auto将其赋值给一个变量。其实lambda函数就和仿函数差不多,在编译器中它会被认为是一个仿函数对象!

2. 捕获列表说明

捕捉列表描述了上下文中哪些数据可以被lambda使用,以及使用的方式传值还是传引用。

var\]:表示**值传递方式捕捉变量var** \[=\]:表示**值传递方式捕获所有父作用域中的变量** (包括this) \[\&var\]:表示**引用传递捕捉变量var** \[\&\]:表示**引用传递捕捉所有父作用域中的变量** (包括this) \[this\]:表示**值传递方式捕捉当前的this指针** 注意: a. **父作用域指包含lambda函数的语句块** b. **语法上捕捉列表可由多个捕捉项组成,并以逗号分割** 。 比如:\[=, \&a, \&b\]:以引用传递的方式捕捉变量a和b,值传递方式捕捉其他所有变量 \[\&,a, this\]:值传递方式捕捉变量a和this,引用方式捕捉其他变量 c. 捕捉列表**不允许变量重复传递,否则就会导致编译错误** 。 比如:\[=, a\]:=已经以值传递方式捕捉了所有变量,捕捉a重复 d. 在块作用域以外的lambda函数捕捉列表必须为空。 e. 在块作用域中的lambda函数仅能捕捉父作用域中局部变量,**捕捉任何非此作用域或者非局部变量都会导致编译报错** 。 f. **lambda表达式之间不能相互赋值**,即使看起来类型相同 void (*PF)(); int main() { auto f1 = []{cout << "hello world" << endl; }; auto f2 = []{cout << "hello world" << endl; }; // 此处先不解释原因,等lambda表达式底层实现原理看完后,大家就清楚了 //f1 = f2; // 编译失败--->提示找不到operator=() // 允许使用一个lambda表达式拷贝构造一个新的副本 auto f3(f2); f3(); // 可以将lambda表达式赋值给相同类型的函数指针 PF = f2; PF(); return 0; } ##### 1.3函数对象与lambda表达式 函数对象,又称为仿函数,即可以想**函数一样使用的对象,就是在类中重载了operator()运算符的类对象**。 大家记住,**空的仿函数的大小就是一个字节,空的lambda表达式也是,因为仿函数类没有成员变量,故大小为一个字节,我们在上面也提到了lambda表达式会被识别为仿函数对象!** 例如: class Rate { public: Rate(double rate) : _rate(rate) {} double operator()(double money, int year) { return money * _rate * year; } private: double _rate; }; class x { public: double operator()() { return 0; } }; int main() { // 函数对象 double rate = 0.49; Rate r1(rate); r1(10000, 2); // lambda auto r2 = [=](double monty, int year)->double {return monty * rate * year;}; r2(10000, 2); cout << sizeof(r1) << endl; cout << sizeof(r2) << endl; auto r3 = []{}; x r4; cout << sizeof(r3) << endl; cout << sizeof(r4) << endl; return 0; } ![在这里插入图片描述](https://file.jishuzhan.net/article/1768200026967773185/3b3cd36226745424ad80a64c990db5ea.webp) 从使用方式上来看,函数对象与lambda表达式完全一样。 **函数对象将rate作为其成员变量,在定义对象时给出初始值即可,lambda表达式通过捕获列表可以直接将该变量捕获到。** 实际在底层编译器对于lambda表达式的处理方式,完全就是按照函数对象的方式处理的,即:如果定义了一个lambda表达式,编译器会自动生成一个类,在该类中重载了operator()。 #### 2.包装器 ##### 2.1 function包装器 function包装器 也叫作适配器。C++中的function本质是一个类模板,也是一个包装器。那么我们来看看,我们为什么需要function呢? 先来看一段代码: ret = func(x); template T useF(F f, T x) { static int count = 0; cout << "count:" << ++count << endl; cout << "count:" << &count << endl; return f(x); } double f(double i) { return i / 2; } struct Functor { double operator()(double d) { return d / 3; } }; int main() { // 函数名 cout << useF(f, 11.11) << endl; // 函数对象 cout << useF(Functor(), 11.11) << endl; // lambda表达式 cout << useF([](double d)->double{ return d/4; }, 11.11) << endl; return 0; } 通过上面的程序验证,我们会发现useF函数模板实例化了三份。 这样实例化很麻烦 包装器可以很好的解决上面的问题: 包装器的模板如下: std::function在头文件 // 类模板原型如下 template function; // undefined template class function; 模板参数说明: Ret: 被调用函数的返回类型 Args...:被调用函数的形参 使用方法如下: // 使用方法如下: #include int f(int a, int b) { return a + b; } struct Functor { public: int operator() (int a, int b) { return a + b; } }; class Plus { public: static int plusi(int a, int b) { return a + b; } double plusd(double a, double b) { return a + b; } }; int main() { // 函数名(函数指针) std::function func1 = f; cout << func1(1, 2) << endl; // 函数对象 std::function func2 = Functor(); cout << func2(1, 2) << endl; // lambda表达式 std::function func3 = [](const int a, const int b) {return a + b; }; cout << func3(1, 2) << endl; // 类的成员函数 std::function func4 = &Plus::plusi; cout << func4(1, 2) << endl; std::function func5 = &Plus::plusd; cout << func5(Plus(), 1.1, 2.2) << endl; return 0; } 有了包装器,如何解决第一段代码中的模板的效率低下,实例化多份的问题呢? 我们直接使用function统一类型 #include template T useF(F f, T x) { static int count = 0; cout << "count:" << ++count << endl; cout << "count:" << &count << endl; return f(x); } double f(double i) { return i / 2; } struct Functor { double operator()(double d) { return d / 3; } }; int main() { // 函数名 std::function func1 = f; cout << useF(func1, 11.11) << endl; // 函数对象 std::function func2 = Functor(); cout << useF(func2, 11.11) << endl; // lambda表达式 std::function func3 = [](double d)->double{ return d / 4; }; cout << useF(func3, 11.11) << endl; return 0; } ##### 2.2 bind std::bind函数定义在头文件中,是一个函数模板,它就像一个函数包装器(适配器),接受一个可调用对象(callable object),生成一个新的可调用对象来"适应"原对象的参数列表。一般而言,我们用它可以把一个原本接收N个参数的函数fn,通过绑定一些参数,返回一个接收M个(M可以大于N,但这么做没什么意义)参数的新函数。同时,使用std::bind函数还可以**实现参数顺序调整等操作**。 原型如下: template bind (Fn&& fn, Args&&... args); template bind (Fn&& fn, Args&&... args); 可以将bind函数看作是**一个通用的函数适配器** ,它接受一个可调用对象,生成一个新的可调用对象来"适应"原对象的参数列表。 调用bind的一般形式:**auto newCallable = bind(callable,arg_list);** 其中,**newCallable本身是一个可调用对象,arg_list是一个逗号分隔的参数列表,对应给定的callable的参数。当我们调用newCallable时newCallable会调用callable,并传给它arg_list中的参数。** arg_list中的参数可能包含**形如_n的名字,其中n是一个整数,这些参数是"占位符",表示newCallable的参数,它们占据了传递给newCallable的参数的"位置"。数值n表示生成的可调用对象中参数的位置:_1为newCallable的第一个参数,_2为第二个参数,以此类推**。 例如: void print(int a, int b) { cout << a << " "; cout << b << endl; } int main() { print(10, 20); auto rprint = bind(print, placeholders::_2, placeholders::_1); rprint(10, 20); } ![在这里插入图片描述](https://file.jishuzhan.net/article/1768200026967773185/9411da544061164601a6b4632a693da5.webp) #### 3.线程库 ##### 3.1线程库的简单介绍 在C++11之前,涉及到多线程问题,都是和平台相关的,比如windows和linux下各有自己的接口,这使得代码的可移植性比较差。C++11中最重要的特性就是对线程进行支持了,使得C++在并行编程时不需要依赖第三方库,而且在原子操作中还引入了原子类的概念。要使用标准库中的线程,必须包含\< thread \>头文件。 由于博主的能力有限,所以放入一个链接供大家学习参考: [http://www.cplusplus.com/reference/thread/thread/?kw=thread](https://www.csdn.net/) ![在这里插入图片描述](https://file.jishuzhan.net/article/1768200026967773185/7156c636eb7c78ee9702319caab2d4b9.webp) 注意: 1. 线程是操作系统中的一个概念,**线程对象可以关联一个线程,用来控制线程以及获取线程的状态**。 2. **当创建一个线程对象后,没有提供线程函数,该对象实际没有对应任何线程。** 例如: 下面代码中的线程就没有线程函数,所以他的id为0 #include int main() { std::thread t1; cout << t1.get_id() << endl; return 0; } ![在这里插入图片描述](https://file.jishuzhan.net/article/1768200026967773185/8e55947d8cba4394ac1451e9329dd322.webp) get_id()的返回值类型为id类型,id类型实际为std::thread命名空间下封装的一个类,该类中包含了一个结构体 3. 当创建一个线程对象后,并且给线程关联线程函数,该线程就被启动,与主线程一起运行。线程函数一般情况下可按照以下三种方式提供: **函数指针 lambda表达式 函数对象** #include using namespace std; #include void ThreadFunc(int a) { cout << "Thread1" << a << endl; } class TF { public: void operator()() { cout << "Thread3" << endl; } }; int main() { // 线程函数为函数指针 thread t1(ThreadFunc, 10); // 线程函数为lambda表达式 thread t2([]{cout << "Thread2" << endl; }); // 线程函数为函数对象 TF tf; thread t3(tf); t1.join(); t2.join(); t3.join(); cout << "Main thread!" << endl; return 0; } 4. thread类是防拷贝的,**不允许拷贝构造以及赋值,但是可以移动构造和移动赋值,即将一个线程对象关联线程的状态转移给其他线程对象,转移期间不意向线程的执行**。 5. 可以通过jionable()函数判断线程是否是有效的,如果是以下任意情况,则线程无效: **采用无参构造函数构造的线程对象 线程对象的状态已经转移给其他线程对象 线程已经调用jion或者detach结束** ##### 3.2线程函数参数 **线程函数的参数是以值拷贝的方式拷贝到线程栈空间中的** ,因此:即使**线程参数为引用类型,在线程中修改后也不能修改外部实参,因为其实际引用的是线程栈中的拷贝,而不是外部实参**。 但是在vs21中的检查更加严格,所以编译会有错误 #include void ThreadFunc1(int& x) { x += 10; } void ThreadFunc2(int* x) { *x += 10; } int main() { int a = 10; // 在线程函数中对a修改,不会影响外部实参,因为:线程函数参数虽然是引用方式,但其实际 //引用的是线程栈中的拷贝 thread t1(ThreadFunc1, a); t1.join(); cout << a << endl; // 如果想要通过形参改变外部实参时,必须借助std::ref()函数 thread t2(ThreadFunc1, std::ref(a)); t2.join(); cout << a << endl; // 地址的拷贝 thread t3(ThreadFunc2, &a); t3.join(); cout << a << endl; return 0; } 注意:**如果是类成员函数作为线程参数时,必须将this作为线程函数参数**。 ##### 3.3原子性操作库 **多线程最主要的问题是共享数据带来的问题(即线程安全)** 。如果共享数据都是只读的,那么没问题,因为只读操作不会影响到数据,更不会涉及对数据的修改,所以所有线程都会获得同样的数据。但是,当**一个或多个线程要修改共享数据时,就会产生很多潜在的麻烦**。 例如: 下面这段代码的输出结果就和我们想象中的不一样,这就是线程共享数据所带来的麻烦 #include using namespace std; #include unsigned long sum = 0L; void fun(size_t num) { for (size_t i = 0; i < num; ++i) sum++; } int main() { cout << "Before joining,sum = " << sum << std::endl; thread t1(fun, 10000000); thread t2(fun, 10000000); t1.join(); t2.join(); cout << "After joining,sum = " << sum << std::endl; return 0; } ![在这里插入图片描述](https://file.jishuzhan.net/article/1768200026967773185/3d72b9e9c5a6e96ddc680af134713688.webp) C++98中传统的解决方式:可以对共享修改的数据可以加锁保护。 #include using namespace std; #include #include std::mutex m; unsigned long sum = 0L; void fun(size_t num) { for (size_t i = 0; i < num; ++i) { m.lock(); sum++; m.unlock(); } } int main() { cout << "Before joining,sum = " << sum << std::endl; thread t1(fun, 10000000); thread t2(fun, 10000000); t1.join(); t2.join(); cout << "After joining,sum = " << sum << std::endl; return 0; } ![在这里插入图片描述](https://file.jishuzhan.net/article/1768200026967773185/c1eb8da8117a8ffe4459a20015ad3461.webp) 虽然加锁可以解决,但是加锁有一个缺陷就是:**只要一个线程在对sum++时,其他线程就会被阻塞,会影响程序运行的效率,而且锁如果控制不好,还容易造成死锁**。 因此C++11中引入了原子操作。所谓原子操作:**即不可被中断的一个或一系列操作,C++11引入的原子操作类型,使得线程间数据的同步变得非常高效** 。 ![在这里插入图片描述](https://file.jishuzhan.net/article/1768200026967773185/d7062f345b55d04805ead8eb226b690d.webp) 注意:**需要使用以上原子操作变量时,必须添加头文件** 用法如下: #include using namespace std; #include #include atomic_long sum{ 0 }; void fun(size_t num) { for (size_t i = 0; i < num; ++i) sum ++; // 原子操作 } int main() { cout << "Before joining, sum = " << sum << std::endl; thread t1(fun, 1000000); thread t2(fun, 1000000); t1.join(); t2.join(); cout << "After joining, sum = " << sum << std::endl; return 0; } 在C++11中,**程序员不需要对原子类型变量进行加锁解锁操作,线程能够对原子类型变量互斥的访问**。 更为普遍的,程序员可以使用atomic类模板,定义出需要的任意原子类型。 atmoic t; // 声明一个类型为T的原子类型变量t 注意:原子类型通常属于"资源型"数据,**多个线程只能访问单个原子类型的拷贝** ,因此在C++11中,**原子类型只能从其模板参数中进行构造,不允许原子类型进行拷贝构造、移动构造以及operator=等,为了防止意外,标准库已经将atmoic模板类中的拷贝构造、移动构造、赋值运算符重载默认删除掉了**。 #include int main() { atomic a1(0); //atomic a2(a1); // 不允许拷贝构造编译失败 atomic a2(0); //a2 = a1; // 不允许赋值编译失败 return 0; } ##### 3.4lock_guard与unique_lock 在多线程环境下,如果想要保证某个变量的安全性,只要将其设置成对应的原子类型即可,即高效又不容易出现死锁问题。但是有些情况下,我们可能需要保证一段代码的安全性,那么就只能通过锁的方式来进行控制。 #include #include int number = 0; mutex g_lock; int ThreadProc1() { for (int i = 0; i < 100; i++) { g_lock.lock(); ++number; cout << "thread 1 :" << number << endl; g_lock.unlock(); } return 0; } int ThreadProc2() { for (int i = 0; i < 100; i++) { g_lock.lock(); --number; cout << "thread 2 :" << number << endl; g_lock.unlock(); } return 0; } int main() { thread t1(ThreadProc1); thread t2(ThreadProc2); t1.join(); t2.join(); cout << "number:" << number << endl; system("pause"); return 0; } 上述代码的缺陷:**锁控制不好时,可能会造成死锁,最常见的比如在锁中间代码返回,或者在锁的范围内抛异常** 。因此:**C++11采用RAII的方式对锁进行了封装,即lock_guard和unique_lock**。 ###### mutex的种类 在C++11中,Mutex总共包了四个互斥量的种类: **1. std::mutex** C++11提供的最基本的互斥量,该类的对象之间不能拷贝,也不能进行移动。mutex最常用的三个函数: ![在这里插入图片描述](https://file.jishuzhan.net/article/1768200026967773185/779eaf13c0559be9dc516c98b223ff87.webp) **注意,线程函数调用lock()时,可能会发生以下三种情况:** **如果该互斥量当前没有被锁住,则调用线程将该互斥量锁住,直到调用 unlock之前,该线程一直拥有该锁 如果当前互斥量被其他线程锁住,则当前的调用线程被阻塞住 如果当前互斥量被当前调用线程锁住,则会产生死锁(deadlock) 线程函数调用try_lock()时,可能会发生以下三种情况: 如果当前互斥量没有被其他线程占有,则该线程锁住互斥量,直到该线程调用 unlock 释放互斥量 如果当前互斥量被其他线程锁住,则当前调用线程返回 false,而并不会被阻塞掉 如果当前互斥量被当前调用线程锁住,则会产生死锁(deadlock)** 2. std::recursive_mutex **其允许同一个线程对互斥量多次上锁(即递归上锁),来获得对互斥量对象的多层所有权,释放互斥量时需要调用与该锁层次深度相同次数的 unlock()**,除此之外,std::recursive_mutex 的特性和 std::mutex 大致相同。 3. std::timed_mutex 比 std::mutex 多了两个成员函数,try_lock_for(),try_lock_until() 。 **try_lock_for() 接受一个时间范围,表示在这一段时间范围之内线程如果没有获得锁则被阻塞住(与std::mutex 的 try_lock() 不同,try_lock 如果被调用时没有获得锁则直接返回false),如果在此期间其他线程释放了锁,则该线程可以获得对互斥量的锁,如果超时(即在指定时间内还是没有获得锁),则返回 false。 try_lock_until() 接受一个时间点作为参数,在指定时间点未到来之前线程如果没有获得锁则被阻塞住,如果在此期间其他线程释放了锁,则该线程可以获得对互斥量的锁,如果超时(即在指定时间内还是没有获得锁),则返回 false。** ###### lock_guard std::lock_gurad 是 C++11 中定义的模板类。定义如下: template class lock_guard { public: // 在构造lock_gard时,_Mtx还没有被上锁 explicit lock_guard(_Mutex& _Mtx) : _MyMutex(_Mtx) { _MyMutex.lock(); } // 在构造lock_gard时,_Mtx已经被上锁,此处不需要再上锁 lock_guard(_Mutex& _Mtx, adopt_lock_t) : _MyMutex(_Mtx) {} ~lock_guard() _NOEXCEPT { _MyMutex.unlock(); } lock_guard(const lock_guard&) = delete; lock_guard& operator=(const lock_guard&) = delete; private: _Mutex& _MyMutex; }; 通过上述代码可以看到,lock_guard类模板主要是通过RAII的方式,**对其管理的互斥量进行了封装,在需要加锁的地方,只需要用上述介绍的任意互斥体实例化一个lock_guard,调用构造函数成功上锁,出作用域前,lock_guard对象要被销毁,调用析构函数自动解锁,可以有效避免死锁 问题** 。 lock_guard的缺陷:**太单一,用户没有办法对该锁进行控制**,因此C++11又提供了unique_lock。 用法如下: #include using namespace std; #include #include std::mutex m; unsigned long sum = 0L; void fun(size_t num) { for (size_t i = 0; i < num; ++i) { /*m.lock(); sum++; m.unlock();*/ std::lock_guard lock(m); sum++; } } int main() { cout << "Before joining,sum = " << sum << std::endl; thread t1(fun, 10000000); thread t2(fun, 10000000); t1.join(); t2.join(); cout << "After joining,sum = " << sum << std::endl; return 0; } ![在这里插入图片描述](https://file.jishuzhan.net/article/1768200026967773185/0158957d9423d01d68e4dc5b2cd05962.webp) ###### unique_lock 与lock_gard类似,unique_lock类模板也是采用RAII的方式对锁进行了封装,并且也是以独占所有权的方式管理mutex对象的上锁和解锁操作,即其对象之间不能发生拷贝。在构造(或移动(move)赋值)时,**unique_lock 对象需要传递一个 Mutex 对象作为它的参数,新创建的unique_lock 对象负责传入的 Mutex 对象的上锁和解锁操作**。使用以上类型互斥量实例unique_lock的对象时,自动调用构造函数上锁,unique_lock对象销毁时自动调用析构函数解锁,可以很方便的防止死锁问题。 好了,今天的分享到这里就结束了,感谢大家的支持! 博主个人能力有限,希望大家指正!

相关推荐
算AI14 小时前
人工智能+牙科:临床应用中的几个问题
人工智能·算法
我不会编程55515 小时前
Python Cookbook-5.1 对字典排序
开发语言·数据结构·python
懒羊羊大王&15 小时前
模版进阶(沉淀中)
c++
owde16 小时前
顺序容器 -list双向链表
数据结构·c++·链表·list
第404块砖头16 小时前
分享宝藏之List转Markdown
数据结构·list
GalaxyPokemon16 小时前
Muduo网络库实现 [九] - EventLoopThread模块
linux·服务器·c++
W_chuanqi16 小时前
安装 Microsoft Visual C++ Build Tools
开发语言·c++·microsoft
hyshhhh16 小时前
【算法岗面试题】深度学习中如何防止过拟合?
网络·人工智能·深度学习·神经网络·算法·计算机视觉
蒙奇D索大16 小时前
【数据结构】第六章启航:图论入门——从零掌握有向图、无向图与简单图
c语言·数据结构·考研·改行学it
A旧城以西17 小时前
数据结构(JAVA)单向,双向链表
java·开发语言·数据结构·学习·链表·intellij-idea·idea