|
// move构造函数 CMyString（CMyString &&s） { cout 《 "CMyString（CMyString &&s）" 《 endl; m_pData = s.m_pData; s.m_pData = NULL; } // 析构函数 ~CMyString（） { cout 《 "~CMyString（）" 《 endl; delete [] m_pData; m_pData = NULL; } // 拷贝赋值函数 CMyString &operator =（const CMyString &s） { cout 《 "CMyString &operator =（const CMyString &s）" 《 endl; if （this != &s） { delete [] m_pData; m_pData = new char[strlen（s.m_pData）+1]; strcpy（m_pData, s.m_pData）； } return *this; } // move赋值函数 CMyString &operator =（CMyString &&s） { cout 《 "CMyString &operator =（CMyString &&s）" 《 endl; if （this != &s） { delete [] m_pData; m_pData = s.m_pData; s.m_pData = NULL; } return *this; } private: char *m_pData; }; 复制代码 可以看到，上面我们添加了move版本的构造函数和赋值函数。那么，添加了move版本后，对类的自动生成规则有什么影响呢？唯一的影响就是，如果提供了move版本的构造函数，则不会生成默认的构造函数。另外，编译器永远不会自动生成move版本的构造函数和赋值函数，它们需要你手动显式地添加。 当添加了move版本的构造函数和赋值函数的重载形式后，某一个函数调用应当使用哪一个重载版本呢？下面是按照判决的优先级列出的3条规则： 1、常量值只能绑定到常量引用上，不能绑定到非常量引用上。 2、左值优先绑定到左值引用上，右值优先绑定到右值引用上。 3、非常量值优先绑定到非常量引用上。 当给构造函数或赋值函数传入一个非常量右值时，依据上面给出的判决规则，可以得出会调用move版本的构造函数或赋值函数。而在move版本的构造函数或赋值函数内部，都是直接"移动"了其内部数据的指针（因为它是非常量右值，是一个临时对象，移动了其内部数据的指针不会导致任何问题，它马上就要被销毁了，我们只是重复利用了其内存），这样就省去了拷贝数据的大量开销。 一个需要注意的地方是，拷贝构造函数可以通过直接调用*this = s来实现，但move构造函数却不能。这是因为在move构造函数中，s虽然是一个非常量右值引用，但其本身却是一个左值（是持久对象，可以对其取地址），因此调用*this = s时，会使用拷贝赋值函数而不是move赋值函数，而这已与move构造函数的语义不相符。要使语义正确，我们需要将左值绑定到非常量右值引用上，C++(www.cppentry.com) 11提供了move函数来实现这种转换，因此我们可以修改为*this = move（s），这样move构造函数就会调用move赋值函数。 C++(www.cppentry.com)的Lambda表达式在WIN RT的异步编程(www.cppentry.com)中，占有非常重要的作用。但C++(www.cppentry.com)的Lambda表达式又不同于其他语言，比如C#,javascript.本篇旨在讨论C++(www.cppentry.com) Lambda表达式的基本语法和概念，希望大家多多指正。 首先，我们看一下Lambda表达式的基本构成 
1. 是捕获值列表，2.是传入参数列表，3.可修改标示符，4.错误抛出标示符，5.函数返回值，6.是函数体。 在。NET 中，我们认为比较标准的Lambda表达式应该是这个样子 // declaring_lambda_expressions1.cpp #include <functional> int main（） { // Assign the lambda expression that adds two numbers to an auto variable. auto f1 = [] （int x, int y） { return x + y; }; // Assign the same lambda expression to a function object. function<int （int, int）> f2 = [] （int x, int y） { return x + y; }; f1（3,4）； 复制代码 } f1是一个auto的值，也是function<>这个模板类型，我们可以理解成为一个函数指针。然后我们用f1（3,4）去调用他。 如果我们想在函数声明的时候就直接执行他，我们可以在Lambda表达式的最后加传入参数，像这样。 int main（） { using namespace std; int n = [] （int x, int y） { return x + y; }（5, 4）； //assign the return type int n = [] （int x, int y） -> int{ return x + y;}（5, 4）； cout 《 n 《 endl; 复制代码 } 第二个表达式中声明的返回值必须跟随->符号，并且两个必须同时出现。如果返回值唯一的话，我们可以省略->+返回值类型。 Lambda表达式允许返回值不唯一的情况，但必须指定返回值类型。 在以上的例子当中，只是常规的Lambda表达式用法，下面我们要说一说捕获值列表。 捕获值列表，是允许我们在Lambda表达式的函数体中直接使用这些值，捕获值列表能捕获的值是所有在此作用域可以访问的值，包括这个作用域里面的临时变量，类的可访问成员，全局变量。捕获值的方式分两种，一种是按值捕获，一种是按引用捕获。顾名思义，按值捕获是不改变原有变量的值，按引用捕获是可以在Lambda表达式中改变原有变量的值。 [&] 所有的值都是按引用捕获 [=] 所有的值都是按值捕获 如果你不想某些值被按引用或者按值捕获，但其他的值却想那样做的话 [ &, n ] 除了n 所有的值按引用捕获 [ = , &n ]除了n所有的值按值捕获 当然，我们也可以指定某几个值的捕获属性 [ m, n ]m,n按引用捕获 [ &m, &n ]m,n按值捕获 int m = 0, n = 0; [=] （int a） mutable { m = ++n + a; }（4）； [&] （int a） { m = ++n + a; }（4）； [=,&m] （int a） mutable { m = ++n + a; }（4）； [&,m] （int a） mutable { m = ++n + a; }（4）； [m,n] （int a） mutable { m = ++n + a; }（4）； [&m,&n] （int a） { m = ++n + a; }（4）； [=] （int a） mutable { m = ++n + a; }（4）； 复制代码 大家一定好奇为什么这里有很多mutable.在按值引用的情况下，Lambda函数体内部是不能直接修改引用值的。如下面注释代码，是会报错的。这种情况下，我们要在Lambda表达式前加mutable,但是结果m,n 依然没有被修改，维持按值引用的特性。 int main（） { int m = 0, n = 0; // 不加mutable会报错 //[=] （int a）{ m = ++n + a; }（4）； //[m,n] （int a）{ m = ++n + a; }（4）； [=] （int a） mutable { m = ++n + a; }（4）； // // [=] （int m, int n, int a）{m=++n+a; }（m, n, 4）； // 下面这个函数m,n的值依然会被修改，因为m,n是按引用传入的 // [=] （int &m, int &n, int a）{m=++n+a; }（m, n, 4）； cout 《 m 《 endl 《 n 《 endl; 复制代码 } 在这个例子中捕获值列表[this]中的this是用来指向这个类的，但[this]只有在类的内部，或者是this指针存在的情况下才能使用。 class Scale { public: // The constructor. explicit Scale（int scale） : _scale（scale） { } // Prints the product of each element in a vector object // and the scale value to the console. void ApplyScale（const vector<int>& v） const { for_each（v.begin（）， v.end（）， [this]（int n） { cout 《 n * _scale 《 endl; }）； } private: int _scale; }; |