// 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;
};