C++14 笔记

C++

可变模版参数包

统一初始化语法

#include <iostream>
using namespace std;
struct manStruct {
  string name;
  int age;
};
class manClass {
private:
  string name;
  int age;
public:
  manClass(string s, int a):name(s), age(a){
  }
};
int main() {
  manStruct ms = {"struct",10}; //结构体初始化比11之前方便了
  manClass mc("class",99);
  int i0 = {1}; 
  int i1(1);
  int i2 = 1;
}

std::bind/boost::bind

fun(int,int)
fun1(int,int,int)
function<int,char> aa；

aa = bind（fun,_1,_2）  //即执行aa的时候，重新传入形参,执行aa(1,2)相当于fun（1,2）。

或者

aa = bind(fun1,_1,_2,4)  //即执行aa（2, 3）相当于执行fun1(2,3,4)

占位符(placehodler)

转发(std::forward)

c++中的左值与右值

　　左值 (lvalue)和右值 (rvalue) 是 c/c++ 中一个比较晦涩基础的概念，有的人可能甚至没有听过，但这个概念到了 c++11 后却变得十分重要，它们是理解 move, forward 等新语义的基础。
　　

左值右值的定义

　　左值与右值这两概念是从 c 中传承而来的，在 c 中，左值指的是既能够出现在等号左边也能出现在等号右边的变量(或表达式)，右值指的则是只能出现在等号右边的变量(或表达式).

int a;
int b;
a = 3;
b = 4;
a = b;
b = a;
// 以下写法不合法。
3 = a;
a+b = 4;

　　在 c 语言中，通常来说有名字的变量就是左值(如上面例子中的 a, b)，而由运算操作(加减乘除，函数调用返回值等)所产生的中间结果(没有名字)就是右值，如上的 3 + 4， a + b 等。我们暂且可以认为：左值就是在程序中能够寻值的东西，右值就是没法取到它的地址的东西(不完全准确)，但如上概念到了 c++ 中，就变得稍有不同。

　　具体来说，在 c++ 中，每一个表达式都会产生一个左值，或者右值，相应的，该表达式也就被称作“左值表达式"， "右值表达式"。对于内置的基本数据类型来说(primitive types)，左值 右值的概念和 c 没有太多不同，不同的地方在于自定义的类型，而且这种不同比较容易让人混淆:
　　1) 对于内置的类型，右值是不可被修改的(non-modifiable)，也不可被 const, volatile 所修饰(cv-qualitification ignored)

　　2) 对于自定义的类型(user-defined types)，右值却允许通过它的成员函数进行修改。

　　对于 1)，这和 C 是一致的，2) 却是 C++ 中所独有, 因此，如果你看到 C++ 中如下的写法，千万不要惊讶：

class cs {
    public:
        cs(int i): i_(i)  { cout << "cs(" << i <<") constructor!" << endl; }
        ~cs() { cout << "cs destructor,i(" << i_ << ")" << endl; }
        cs& operator=(const cs& other) {
            i_ = other.i_;
            cout << "cs operator=()" << endl;
            return *this;
        }
        int get_i() const { return i_; }
        void change(int i)  { i_ = i; }
    private:
        int i_;
};
cs get_cs() {
    static int i = 0;
    return cs(i++);
}
int main() {
     // 合法
    (get_cs() = cs(2)).change(323);
    get_cs() = cs(2);// operator=()
    get_cs().change(32);
    return 0;
}

　　这个特性看起来多少有些奇怪，因为通常来说，自定义类型应该设计得和内置类型尽量一样(所谓 value type)，但这个特性却有意无意使得自定义类型特殊化了。对此，我们其实可以这样想，也许会好理解点：自定义类型允许有成员函数，而通过右值调用成员函数是被允许的，但成员函数有可能不是 const 类型，因此通过调用右值的成员函数，也就可能会修改了该右值，done!

左值引用，右值引用

　　关于右值，在 c++11 以前有一个十分值得关注的语言的特性：右值能被 const 类型的引用所指向，所以如下代码是合法的。

const cs& ref = get_cs();

　　而且准确地说，右值只能被 const 类型的 reference 所指向：

// error 
cs& ref = get_cs();

　　当一个右值被 const reference 指向时，它的生命周期就被延长了，这个用法我在前面一篇博客里讲到过它的相关应用。其中暗藏的逻辑其实就是：右值不能当成左值使用(但左值可以当成右值使用).

　　另外值得注意的是，对于前面提到的右值的两个特性：

　　1) 允许调用成员函数。

　　2) 只能被 const reference 指向。

　　它们导致了一些比较有意思的结果，比如：

void func(cs& c) {
   cout << "c:" << c.get_i() << endl;
}
//error
func(get_cs());
//正确
func(get_cs() = get_cs());

　　其中: func(get_cs() = get_cs()); 能够被正常编译执行的原因就在于，cs 的成员函数 operator=() 返回的是 cs&！不允许非 const reference 引用 rvalue 并不是完美的，它事实上也引起了一些问题，比如说拷贝构造函数的接口不一致了，这是什么意思呢？

class cs {
    public:      
        cs& operator=(const cs& c);
};
// 另一种写法
class cs2 {
    public:      
        cs2& operator=(cs2& c);
};

　　上面两种写法的不同之处就在于参数，一个是 const reference，一个是非 const。对于自定义类型的参数，通常来说，如果函数不需要修改传进来的参数，我们往往就按 const reference 的写法，但对于 copy constructor 来说，它经常是需要修改参数的值，比如 auto_ptr。

// 类似auto_ptr
class auto_ptr {
   public:
       auto_ptr(auto_tr& p) {
             ptr_ = p.ptr_;
             p.ptr_ = NULL;
        }
    private:
         void*  ptr_;
};

　　所以，对于 auto_ptr 来说，它的 copy constructor 的参数类型是 non const reference。有些情况下，这种写法应该被鼓励，毕竟 non const reference 比 const reference 更能灵活应对各种情况，从而保持一致的接口类型，当然也有代价，参数的语义表达不准确了。除此更大的问题是如果拷贝构造函数写成这样子，却又对 rvalue 的使用带来了极大的不变，如前面所讲的例子，rvalue 不能被 non const reference 所引用，所以像 auto_ptr 的这样的类的 copy constructor 就不能接受 rvalue.

// 错误
auto_ptr p(get_ptr());
// operator=() 同理，错误。
auto_ptr p = get_ptr();

　　 auto_ptr 很不好用的原因之一，为了解决这个问题，c++11 中引入了一种新的引用类型，该种引用是专门用来指向 rvalue 的，有了这种新类型，对 lvalue 和 rvalue 的引用就能明确区分开来了。因为有了这种新的类型，接着就引出了 c++11 中新的语义，move(), forward() 等，这儿先卖个关子，我们下次再讲。
[参考]

http://accu.org/index.php/journals/227

C++11 标准新特性: 右值引用与转移语义

新特性的目的:
　　右值引用 (Rvalue Referene) 是 C++ 新标准 (C++11, 11 代表 2011 年 ) 中引入的新特性 , 它实现了转移语义 (Move Sementics) 和精确传递 (Perfect Forwarding)。它的主要目的有两个方面：

　　消除两个对象交互时不必要的对象拷贝，节省运算存储资源，提高效率。
　　能够更简洁明确地定义泛型函数。
　　
　　左值与右值的定义

　　C++( 包括 C) 中所有的表达式和变量要么是左值，要么是右值。通俗的左值的定义就是非临时对象，那些可以在多条语句中使用的对象。所有的变量都满足这个定义，在多条代码中都可以使用，都是左值。右值是指临时的对象，它们只在当前的语句中有效。请看下列示例 :

　　简单的赋值语句

如：int i = 0;

　　在这条语句中，i 是左值，0 是临时值，就是右值。在下面的代码中，i 可以被引用，0 就不可以了。立即数都是右值。
右值也可以出现在赋值表达式的左边，但是不能作为赋值的对象，因为右值只在当前语句有效，赋值没有意义。

如：((i>0) ? i : j) = 1;

　　在这个例子中，0 作为右值出现在了"="的左边。但是赋值对象是 i 或者 j，都是左值。

　　在 C++11 之前，右值是不能被引用的，最大限度就是用常量引用绑定一个右值，如 :

const int &a = 1;

　　在这种情况下，右值不能被修改的。但是实际上右值是可以被修改的，如 :

T().set().get();

　　T 是一个类，set 是一个函数为 T 中的一个变量赋值，get 用来取出这个变量的值。在这句中，T() 生成一个临时对象，就是右值，set() 修改了变量的值，也就修改了这个右值。

　　既然右值可以被修改，那么就可以实现右值引用。右值引用能够方便地解决实际工程中的问题，实现非常有吸引力的解决方案。

　　左值和右值的语法符号

左值的声明符号为"&"， 为了和左值区分，右值的声明符号为"&&"。

　　示例程序 :

 void process_value(int& i) { 
  std::cout << "LValue processed: " << i << std::endl; 
 } 
 void process_value(int&& i) { 
  std::cout << "RValue processed: " << i << std::endl; 
 } 
 int main() { 
  int a = 0; 
  process_value(a); 
  process_value(1); 
 }

　　运行结果 :

 LValue processed: 0 
 RValue processed: 1

　　Process_value 函数被重载，分别接受左值和右值。由输出结果可以看出，临时对象是作为右值处理的。

　　但是如果临时对象通过一个接受右值的函数传递给另一个函数时，就会变成左值，因为这个临时对象在传递过程中，变成了命名对象。

　　示例程序 :

 void process_value(int& i) { 
  std::cout << "LValue processed: " << i << std::endl; 
 } 
 void process_value(int&& i) { 
  std::cout << "RValue processed: " << i << std::endl; 
 } 
 void forward_value(int&& i) { 
  process_value(i); 
 } 
 int main() { 
  int a = 0; 
  process_value(a); 
  process_value(1); 
  forward_value(2); 
 }

　　运行结果 :

 LValue processed: 0 
 RValue processed: 1 
 LValue processed: 2

　　虽然 2 这个立即数在函数 forward_value 接收时是右值，但到了 process_value 接收时，变成了左值。

　　转移语义的定义

　　右值引用是用来支持转移语义的。转移语义可以将资源 ( 堆，系统对象等 ) 从一个对象转移到另一个对象，这样能够减少不必要的临时对象的创建、拷贝以及销毁，能够大幅度提高 C++ 应用程序的性能。临时对象的维护 ( 创建和销毁 ) 对性能有严重影响。

　　转移语义是和拷贝语义相对的，可以类比文件的剪切与拷贝，当我们将文件从一个目录拷贝到另一个目录时，速度比剪切慢很多。

　　通过转移语义，临时对象中的资源能够转移其它的对象里。

　　在现有的 C++ 机制中，我们可以定义拷贝构造函数和赋值函数。要实现转移语义，需要定义转移构造函数，还可以定义转移赋值操作符。对于右值的拷贝和赋值会调用转移构造函数和转移赋值操作符。如果转移构造函数和转移拷贝操作符没有定义，那么就遵循现有的机制，拷贝构造函数和赋值操作符会被调用。

　　普通的函数和操作符也可以利用右值引用操作符实现转移语义。

　　实现转移构造函数和转移赋值函数

　　以一个简单的 string 类为示例，实现拷贝构造函数和拷贝赋值操作符。

　　示例程序 :

 class MyString { 
 private: 
  char* _data; 
  size_t   _len; 
  void _init_data(const char *s) { 
    _data = new char[_len+1]; 
    memcpy(_data, s, _len); 
    _data[_len] = '\0'; 
  } 
 public: 
  MyString() { 
    _data = NULL; 
    _len = 0; 
  } 
  MyString(const char* p) { 
    _len = strlen (p); 
    _init_data(p); 
  } 
  MyString(const MyString& str) { 
    _len = str._len; 
    _init_data(str._data); 
    std::cout << "Copy Constructor is called! source: " << str._data << std::endl; 
  } 
  MyString& operator=(const MyString& str) { 
    if (this != &str) { 
      _len = str._len; 
      _init_data(str._data); 
    } 
    std::cout << "Copy Assignment is called! source: " << str._data << std::endl; 
    return *this; 
  } 
  virtual ~MyString() { 
    if (_data) free(_data); 
  } 
 }; 
 int main() { 
  MyString a; 
  a = MyString("Hello"); 
  std::vector<MyString> vec; 
  vec.push_back(MyString("World")); 
 }

　　运行结果 :

 Copy Assignment is called! source: Hello 
 Copy Constructor is called! source: World

　　这个 string 类已经基本满足我们演示的需要。在 main 函数中，实现了调用拷贝构造函数的操作和拷贝赋值操作符的操作。MyString(“Hello”) 和 MyString(“World”) 都是临时对象，也就是右值。虽然它们是临时的，但程序仍然调用了拷贝构造和拷贝赋值，造成了没有意义的资源申请和释放的操作。如果能够直接使用临时对象已经申请的资源，既能节省资源，有能节省资源申请和释放的时间。这正是定义转移语义的目的。

　　我们先定义转移构造函数。

  MyString(MyString&& str) { 
    std::cout << "Move Constructor is called! source: " << str._data << std::endl; 
    _len = str._len; 
    _data = str._data; 
    str._len = 0; 
    str._data = NULL; 
 }

　　和拷贝构造函数类似，有几点需要注意：

1. 参数（右值）的符号必须是右值引用符号，即“&&”。
2. 参数（右值）不可以是常量，因为我们需要修改右值。

3. 参数（右值）的资源链接和标记必须修改。否则，右值的析构函数就会释放资源。转移到新对象的资源也就无效了。

   　　现在我们定义转移赋值操作符。

  MyString& operator=(MyString&& str) { 
    std::cout << "Move Assignment is called! source: " << str._data << std::endl; 
    if (this != &str) { 
      _len = str._len; 
      _data = str._data; 
      str._len = 0; 
      str._data = NULL; 
    } 
    return *this; 
 }

　　这里需要注意的问题和转移构造函数是一样的。

　　增加了转移构造函数和转移复制操作符后，我们的程序运行结果为 :

 Move Assignment is called! source: Hello 
 Move Constructor is called! source: World

　　由此看出，编译器区分了左值和右值，对右值调用了转移构造函数和转移赋值操作符。节省了资源，提高了程序运行的效率。

　　有了右值引用和转移语义，我们在设计和实现类时，对于需要动态申请大量资源的类，应该设计转移构造函数和转移赋值函数，以提高应用程序的效率。

标准库函数 std::move

　　既然编译器只对右值引用才能调用转移构造函数和转移赋值函数，而所有命名对象都只能是左值引用，如果已知一个命名对象不再被使用而想对它调用转移构造函数和转移赋值函数，也就是把一个左值引用当做右值引用来使用，怎么做呢？标准库提供了函数 std::move，这个函数以非常简单的方式将左值引用转换为右值引用。

　　示例程序 :

 void ProcessValue(int& i) { 
  std::cout << "LValue processed: " << i << std::endl; 
 } 
 void ProcessValue(int&& i) { 
  std::cout << "RValue processed: " << i << std::endl; 
 } 
 int main() { 
  int a = 0; 
  ProcessValue(a); 
  ProcessValue(std::move(a)); 
 }

运行结果 :

 LValue processed: 0 
 RValue processed: 0

　　std::move在提高 swap 函数的的性能上非常有帮助，一般来说，swap函数的通用定义如下：

    template <class T> swap(T& a, T& b) 
    { 
        T tmp(a);   // copy a to tmp 
        a = b;      // copy b to a 
        b = tmp;    // copy tmp to b 
    }

　　有了 std::move，swap 函数的定义变为 :

    template <class T> swap(T& a, T& b) 
    { 
        T tmp(std::move(a)); // move a to tmp 
        a = std::move(b);    // move b to a 
        b = std::move(tmp);  // move tmp to b 
     }

　　通过 std::move，一个简单的 swap 函数就避免了 3 次不必要的拷贝操作。

　　精确传递 (Perfect Forwarding)

　　本文采用精确传递表达这个意思。”Perfect Forwarding”也被翻译成完美转发，精准转发等，说的都是一个意思。

　　精确传递适用于这样的场景：需要将一组参数原封不动的传递给另一个函数。

　　“原封不动”不仅仅是参数的值不变，在 C++ 中，除了参数值之外，还有一下两组属性：

　　左值／右值和 const/non-const。 精确传递就是在参数传递过程中，所有这些属性和参数值都不能改变。在泛型函数中，这样的需求非常普遍。

　　下面举例说明。函数 forward_value 是一个泛型函数，它将一个参数传递给另一个函数 process_value。

　　forward_value 的定义为：

 template <typename T> void forward_value(const T& val) { 
  process_value(val); 
 } 
 template <typename T> void forward_value(T& val) { 
  process_value(val); 
 }

　　函数 forward_value 为每一个参数必须重载两种类型，T& 和 const T&，否则，下面四种不同类型参数的调用中就不能同时满足 :

  int a = 0; 
  const int &b = 1; 
  forward_value(a); // int& 
  forward_value(b); // const int& 
  forward_value(2); // int&

　　对于一个参数就要重载两次，也就是函数重载的次数和参数的个数是一个正比的关系。这个函数的定义次数对于程序员来说，是非常低效的。我们看看右值引用如何帮助我们解决这个问题 :

 template <typename T> void forward_value(T&& val) { 
  process_value(val); 
 }

　　只需要定义一次，接受一个右值引用的参数，就能够将所有的参数类型原封不动的传递给目标函数。四种不用类型参数的调用都能满足，参数的左右值属性和 const/non-cosnt 属性完全传递给目标函数 process_value。这个解决方案不是简洁优雅吗？

  int a = 0; 
  const int &b = 1; 
  forward_value(a); // int& 
  forward_value(b); // const int& 
  forward_value(2); // int&&

　　C++11 中定义的 T&& 的推导规则为：

　　右值实参为右值引用，左值实参仍然为左值引用。

　　一句话，就是参数的属性不变。这样也就完美的实现了参数的完整传递。

　　右值引用，表面上看只是增加了一个引用符号，但它对 C++ 软件设计和类库的设计有非常大的影响。它既能简化代码，又能提高程序运行效率。每一个 C++ 软件设计师和程序员都应该理解并能够应用它。我们在设计类的时候如果有动态申请的资源，也应该设计转移构造函数和转移拷贝函数。在设计类库时，还应该考虑 std::move 的使用场景并积极使用它。

总结

　　右值引用和转移语义是 C++ 新标准中的一个重要特性。每一个专业的 C++ 开发人员都应该掌握并应用到实际项目中。在有机会重构代码时，也应该思考是否可以应用新也行。在使用之前，需要检查一下编译器的支持情况。

C++11 标准新特性：Defaulted 和 Deleted 函数

　　本文将介绍 C++11 标准的两个新特性：defaulted 和 deleted 函数。对于 defaulted 函数，编译器会为其自动生成默认的函数定义体，从而获得更高的代码执行效率，也可免除程序员手动定义该函数的工作量。对于 deleted 函数， 编译器会对其禁用，从而避免某些非法的函数调用或者类型转换，从而提高代码的安全性。本文将通过代码示例详细阐述 defaulted 和 deleted 函数的用法及益处。

Defaulted 函数

　　背景问题

　　C++ 的类有四类特殊成员函数，它们分别是：默认构造函数、析构函数、拷贝构造函数以及拷贝赋值运算符。这些类的特殊成员函数负责创建、初始化、销毁，或者拷贝类的对象。如果程序员没有显式地为一个类定义某个特殊成员函数，而又需要用到该特殊成员函数时，则编译器会隐式的为这个类生成一个默认的特殊成员函数。例如：
清单 1

 class X{ 
 private: 
  int a; 
 }; 
 X x;

　　在清单 1 中，程序员并没有定义类 X 的默认构造函数，但是在创建类 X 的对象 x 的时候，又需要用到类 X 的默认构造函数，此时，编译器会隐式的为类 X 生成一个默认构造函数。该自动生成的默认构造函数没有参数，包含一个空的函数体，即 X::X（）{ }。虽然自动生成的默认构造函数仅有一个空函数体，但是它仍可用来成功创建类 X 的对象 x，清单 1 也可以编译通过。

　　但是，如果程序员为类 X 显式的自定义了非默认构造函数，却没有定义默认构造函数的时候，清单 2 将会出现编译错误：
　　清单 2

 class X{ 
 public: 
  X(int i){ 
    a = i; 
  }     
 private: 
  int a; 
 }; 
 X x;  // 错误 , 默认构造函数 X::X() 不存在

　　清单 2 编译出错的原因在于类 X 已经有了用户自定义的构造函数，所以编译器将不再会为它隐式的生成默认构造函数。如果需要用到默认构造函数来创建类的对象时，程序员必须自己显式的定义默认构造函数。例如：
　　清单 3

 class X{ 
 public: 
  X(){};  // 手动定义默认构造函数
  X(int i){ 
    a = i; 
  }     
 private: 
  int a; 
 }; 
 X x;   // 正确，默认构造函数 X::X() 存在

　　从清单 3 可以看出，原本期望编译器自动生成的默认构造函数需要程序员手动编写了，即程序员的工作量加大了。此外，手动编写的默认构造函数的代码执行效率比编译器自动生成的默认构造函数低。类的其它几类特殊成员函数也和默认构造函数一样，当存在用户自定义的特殊成员函数时，编译器将不会隐式的自动生成默认特殊成员函数，而需要程序员手动编写，加大了程序员的工作量。类似的，手动编写的特殊成员函数的代码执行效率比编译器自动生成的特殊成员函数低。
　　Defaulted 函数的提出

　　为了解决如清单 3 所示的两个问题：1. 减轻程序员的编程工作量；2. 获得编译器自动生成的默认特殊成员函数的高的代码执行效率，C++11 标准引入了一个新特性：defaulted 函数。程序员只需在函数声明后加上“=default;”，就可将该函数声明为 defaulted 函数，编译器将为显式声明的 defaulted 函数自动生成函数体。例如：
　　清单 4

 class X{ 
 public: 
  X()= default; 
  X(int i){ 
    a = i; 
  }     
 private: 
  int a; 
 }; 
 X x;

　　在清单 4 中，编译器会自动生成默认构造函数 X::X(){}，该函数可以比用户自己定义的默认构造函数获得更高的代码效率。
　　

Defaulted 函数定义语法

　　Defaulted 函数是 C++11 标准引入的函数定义新语法，defaulted 函数定义的语法如图 1 所示：

　　Defaulted 函数的用法及示例

　　Defaulted 函数特性仅适用于类的特殊成员函数，且该特殊成员函数没有默认参数。例如：
　　清单 5

 class X { 
 public: 
  int f() = default;      // 错误 , 函数 f() 非类 X 的特殊成员函数
  X(int) = default;       // 错误 , 构造函数 X(int, int) 非 X 的特殊成员函数
  X(int = 1) = default;   // 错误 , 默认构造函数 X(int=1) 含有默认参数
 };

　　Defaulted 函数既可以在类体里（inline）定义，也可以在类体外（out-of-line）定义。例如：
清单 6

 class X{ 
 public:  
   X() = default; //Inline defaulted 默认构造函数
   X(const X&); 
   X& operator = (const X&); 
   ~X() = default;  //Inline defaulted 析构函数
 }; 
 X::X(const X&) = default;  //Out-of-line defaulted 拷贝构造函数
 X& X::operator = (const X&) = default;     //Out-of-line defaulted  
     // 拷贝赋值操作符

　　在 C++ 代码编译过程中，如果程序员没有为类 X 定义析构函数，但是在销毁类 X 对象的时候又需要调用类 X 的析构函数时，编译器会自动隐式的为该类生成一个析构函数。该自动生成的析构函数没有参数，包含一个空的函数体，即 X::~X（）{ }。例如：
　　清单 7

 class X { 
 private: 
  int x; 
 }; 
 class Y: public X { 
 private: 
  int y; 
 }; 
 int main(){ 
  X* x = new Y; 
  delete x; 
 }

　　在清单 7 中，程序员没有为基类 X 和派生类 Y 定义析构函数，当在主函数内 delete 基类指针 x 的时候，需要调用基类的析构函数。于是，编译器会隐式自动的为类 X 生成一个析构函数，从而可以成功的销毁 x 指向的派生类对象中的基类子对象（即 int 型成员变量 x）。

　　但是，这段代码存在内存泄露的问题，当利用 delete 语句删除指向派生类对象的指针 x 时，系统调用的是基类的析构函数，而非派生类 Y 类的析构函数，因此，编译器无法析构派生类的 int 型成员变量 y。

　　因此，一般情况下我们需要将基类的析构函数定义为虚函数，当利用 delete 语句删除指向派生类对象的基类指针时，系统会调用相应的派生类的析构函数（实现多态性），从而避免内存泄露。但是编译器隐式自动生成的析构函数都是非虚函数，这就需要由程序员手动的为基类 X 定义虚析构函数，例如：
　　清单 8

 class X { 
 public: 
  virtual ~X(){};     // 手动定义虚析构函数
 private: 
  int x; 
 }; 
 class Y: public X { 
 private: 
  int y; 
 }; 
 int main(){ 
  X* x = new Y; 
  delete x; 
  }

　　在清单 8 中，由于程序员手动为基类 X 定义了虚析构函数，当利用 delete 语句删除指向派生类对象的基类指针 x 时，系统会调用相应的派生类 Y 的析构函数（由编译器隐式自动生成）以及基类 X 的析构函数，从而将派生类对象完整的销毁，可以避免内存泄露。

　　但是，在清单 8 中，程序员需要手动的编写基类的虚构函数的定义（哪怕函数体是空的），增加了程序员的编程工作量。更值得一提的是，手动定义的析构函数的代码执行效率要低于编译器自动生成的析构函数。

　　为了解决上述问题，我们可以将基类的虚析构函数声明为 defaulted 函数，这样就可以显式的指定编译器为该函数自动生成函数体。例如：
　　清单 9

 class X { 
 public: 
  virtual ~X()= defaulted; // 编译器自动生成 defaulted 函数定义体
 private: 
  int x; 
 }; 
 class Y: public X { 
 private: 
  int y; 
 }; 
 int main(){ 
  X* x = new Y; 
  delete x;
}

　　在清单 9 中，编译器会自动生成虚析构函数 virtual X::X(){}，该函数比用户自己定义的虚析构函数具有更高的代码执行效率。

Deleted 函数

　　背景问题

　　对于 C++ 的类，如果程序员没有为其定义特殊成员函数，那么在需要用到某个特殊成员函数的时候，编译器会隐式的自动生成一个默认的特殊成员函数，比如拷贝构造函数，或者拷贝赋值操作符。例如：
　　清单 10

 class X{ 
 public: 
  X(); 
 }; 
 int main(){ 
  X x1; 
  X x2=x1;   // 正确，调用编译器隐式生成的默认拷贝构造函数
  X x3; 
  x3=x1;     // 正确，调用编译器隐式生成的默认拷贝赋值操作符
 }

　　在清单 10 中，程序员不需要自己手动编写拷贝构造函数以及拷贝赋值操作符，依靠编译器自动生成的默认拷贝构造函数以及拷贝赋值操作符就可以实现类对象的拷贝和赋值。这在某些情况下是非常方便省事的，但是在某些情况下，假设我们不允许发生类对象之间的拷贝和赋值，可是又无法阻止编译器隐式自动生成默认的拷贝构造函数以及拷贝赋值操作符，那这就成为一个问题了。
Deleted 函数的提出

　　为了能够让程序员显式的禁用某个函数，C++11 标准引入了一个新特性：deleted 函数。程序员只需在函数声明后加上“=delete;”，就可将该函数禁用。例如，我们可以将类 X 的拷贝构造函数以及拷贝赋值操作符声明为 deleted 函数，就可以禁止类 X 对象之间的拷贝和赋值。
　　清单 11

class X{            
     public: 
       X(); 
       X(const X&) = delete;  // 声明拷贝构造函数为 deleted 函数
       X& operator = (const X &) = delete; // 声明拷贝赋值操作符为 deleted 函数
     }; 
 int main(){ 
  X x1; 
  X x2=x1;   // 错误，拷贝构造函数被禁用
  X x3; 
  x3=x1;     // 错误，拷贝赋值操作符被禁用
 }

　　在清单 11 中，虽然只显式的禁用了一个拷贝构造函数和一个拷贝赋值操作符，但是由于编译器检测到类 X 存在用户自定义的拷贝构造函数和拷贝赋值操作符的声明，所以不会再隐式的生成其它参数类型的拷贝构造函数或拷贝赋值操作符，也就相当于类 X 没有任何拷贝构造函数和拷贝赋值操作符，所以对象间的拷贝和赋值被完全禁止了。
Deleted 函数定义语法

　　Deleted 函数是 C++11 标准引入的函数定义新语法，deleted 函数定义的语法如图 2 所示：

Deleted 函数的用法及示例

　　Deleted 函数特性还可用于禁用类的某些转换构造函数，从而避免不期望的类型转换。在清单 12 中，假设类 X 只支持参数为双精度浮点数 double 类型的转换构造函数，而不支持参数为整数 int 类型的转换构造函数，则可以将参数为 int 类型的转换构造函数声明为 deleted 函数。
　　清单 12

 class X{ 
 public: 
  X(double);              
  X(int) = delete;     
 }; 
 int main(){ 
  X x1(1.2);        
  X x2(2); // 错误，参数为整数 int 类型的转换构造函数被禁用
 }

　　Deleted 函数特性还可以用来禁用某些用户自定义的类的 new 操作符，从而避免在自由存储区创建类的对象。例如：
　　清单 13

 #include <cstddef> 
 using namespace std; 
 class X{ 
 public: 
  void *operator new(size_t) = delete; 
  void *operator new[](size_t) = delete; 
 }; 
 int main(){ 
  X *pa = new X;  // 错误，new 操作符被禁用
  X *pb = new X[10];  // 错误，new[] 操作符被禁用
 }

　　必须在函数第一次声明的时候将其声明为 deleted 函数，否则编译器会报错。即对于类的成员函数而言，deleted 函数必须在类体里（inline）定义，而不能在类体外（out-of-line）定义。例如：
　　清单 14

 class X { 
 public:  
  X(const X&); 
 }; 
 X::X(const X&) = delete;   // 错误，deleted 函数必须在函数第一次声明处声明

　　虽然 defaulted 函数特性规定了只有类的特殊成员函数才能被声明为 defaulted 函数，但是 deleted 函数特性并没有此限制。非类的成员函数，即普通函数也可以被声明为 deleted 函数。例如：
　　清单 15

int add (int,int)=delete; 
int main(){ 
    int a, b; 
    add(a,b); // 错误，函数 add(int, int) 被禁用
}

　　值得一提的是，在清单 15 中，虽然 add(int, int)函数被禁用了，但是禁用的仅是函数的定义，即该函数不能被调用。但是函数标示符 add 仍是有效的，在名字查找和函数重载解析时仍会查找到该函数标示符。如果编译器在解析重载函数时，解析结果为 deleted 函数，则会出现编译错误。例如：
　　清单 16

 #include <iostream>  
 using namespace std;  
 int add(int,int) = delete;    
  double add(double a,double b){ 
  return a+b; 
 }  
 int main(){  
  cout << add(1,3) << endl;    // 错误，调用了 deleted 函数 add(int, int) 
  cout << add(1.2,1.3) << endl; 
  return 0; 
 }

　　结束语

　　本文详细介绍了 C++11 新特性 defaulted 和 deleted 函数。该特性巧妙地对 C++ 已有的关键字 default 和 delete 的语法进行了扩充，引入了两种新的函数定义方式：在函数声明后加 =default 和 =delete。通过将类的特殊成员函数声明为 defaulted 函数，可以显式指定编译器为该函数自动生成默认函数体。通过将函数声明为 deleted 函数，可以禁用某些不期望的转换或者操作符。Defaulted 和 deleted 函数特性语法简单，功能实用，是对 C++ 标准的一个非常有价值的扩充。

const修饰符

　　C++中的const关键字的用法非常灵活，而使用const将大大改善程序的健壮性，本人根据各方面查到的资料进行总结如下，期望对朋友们有所帮助。

　　Const 是C++中常用的类型修饰符,常类型是指使用类型修饰符const说明的类型，常类型的变量或对象的值是不能被更新的。
　　

作用

Const的使用

1、定义常量
　　(1)const修饰变量，以下两种定义形式在本质上是一样的。它的含义是：const修饰的类型为TYPE的变量value是不可变的。

TYPE const ValueName = value;
const TYPE ValueName = value;

　　(2)将const改为外部连接,作用于扩大至全局,编译时会分配内存,并且可以不进行初始化,仅仅作为声明,编译器认为在程序其他地方进行了定义.

extend const int ValueName = value;

2、指针使用CONST
　　(1)指针本身是常量不可变

(char*) const pContent;
const (char*) pContent;

　　(2)指针所指向的内容是常量不可变

const (char) *pContent;
(char) const *pContent;

　　(3)两者都不可变

const char* const pContent;

　　(4)还有其中区别方法，沿着号划一条线：
如果const位于的左侧，则const就是用来修饰指针所指向的变量，即指针指向为常量；
如果const位于*的右侧，const就是修饰指针本身，即指针本身是常量。
　　

3、函数中使用CONST

　　(1)const修饰函数参数
　　　　a.传递过来的参数在函数内不可以改变(无意义，因为Var本身就是形参)

void function(const int Var);

　　　　b.参数指针所指内容为常量不可变

void function(const char* Var);

　　　　c.参数指针本身为常量不可变(也无意义，因为char* Var也是形参)

void function(char* const Var);

　　　　d.参数为引用，为了增加效率同时防止修改。修饰引用参数时：

void function(const Class& Var); //引用参数在函数内不可以改变
void function(const TYPE& Var); //引用参数在函数内为常量不可变

　　这样的一个const引用传递和最普通的函数按值传递的效果是一模一样的,他禁止对引用的对象的一切修改,唯一不同的是按值传递会先建立一个类对象的副本, 然后传递过去,而它直接传递地址,所以这种传递比按值传递更有效.另外只有引用的const传递可以传递一个临时对象,因为临时对象都是const属性, 且是不可见的,他短时间存在一个局部域中,所以不能使用指针,只有引用的const传递能够捕捉到这个家伙.
　　
　　
　　(2)const 修饰函数返回值
const修饰函数返回值其实用的并不是很多，它的含义和const修饰普通变量以及指针的含义基本相同。

a.const int fun1() //这个其实无意义，因为参数返回本身就是赋值。
b. const int * fun2() //调用时 const int *pValue = fun2();
                      //我们可以把fun2()看作成一个变量，即指针内容不可变。
c.int* const fun3()   //调用时 int * const pValue = fun2();
                      //我们可以把fun2()看作成一个变量，即指针本身不可变。

　　一般情况下，函数的返回值为某个对象时，如果将其声明为const时，多用于操作符的重载。通常，不建议用const修饰函数的返回值类型为某个对象或对某个对象引用的情况。原因如下：如果返回值为某个对象为const（const A test = A 实例）或某个对象的引用为const（const A& test = A实例） ，则返回值具有const属性，则返回实例只能访问类A中的公有（保护）数据成员和const成员函数，并且不允许对其进行赋值操作，这在一般情况下很少用到。
　　
4、类相关CONST

　　(1)const修饰成员变量
　　const修饰类的成员函数，表示成员常量，不能被修改，同时它只能在初始化列表中赋值。

class A {
    …
    const int nValue; //成员常量不能被修改
    …
    A(int x): nValue(x) { } ; //只能在初始化列表中赋值
}

　　(2)const修饰成员函数
　　const修饰类的成员函数，则该成员函数不能修改类中任何非const成员函数。一般写在函数的最后来修饰。

class A {
    …
    void function()const; //常成员函数, 它不改变对象的成员变量.                        
                          //也不能调用类中任何非const成员函数。
}

　　对于const类对象/指针/引用，只能调用类的const成员函数，因此，const修饰成员函数的最重要作用就是限制对于const对象的使用。

　　a. const成员函数不被允许修改它所在对象的任何一个数据成员。
　　b. const成员函数能够访问对象的const成员，而其他成员函数不可以。

　　
　　(3)const修饰类对象/对象指针/对象引用

　　　　const修饰类对象表示该对象为常量对象，其中的任何成员都不能被修改。对于对象指针和对象引用也是一样。
　　　　const修饰的对象，该对象的任何非const成员函数都不能被调用，因为任何非const成员函数会有修改成员变量的企图。

　　
　　　　例如：

class AAA {
    void func1();
    void func2() const;
}
const AAA aObj;
aObj.func1(); ×
aObj.func2(); 正确
const AAA* aObj = new AAA();
aObj-> func1(); ×
aObj-> func2(); 正确

　　
三、将Const类型转化为非Const类型的方法

采用const_cast 进行转换。
用法：const_cast (expression)
该运算符用来修改类型的const或volatile属性。除了const 或volatile修饰之外， type_id和expression的类型是一样的。

　　.常量指针被转化成非常量指针，并且仍然指向原来的对象；
　　.常量引用被转换成非常量引用，并且仍然指向原来的对象；
　　.常量对象被转换成非常量对象。

四、使用const的一些建议

　　.要大胆的使用const，这将给你带来无尽的益处，但前提是你必须搞清楚原委；
　　.要避免最一般的赋值操作错误，如将const变量赋值，具体可见思考题；
　　.在参数中使用const应该使用引用或指针，而不是一般的对象实例，原因同上；
　　.const在成员函数中的三种用法（参数、返回值、函数）要很好的使用；
　　.不要轻易的将函数的返回值类型定为const;
　　.除了重载操作符外一般不要将返回值类型定为对某个对象的const引用;
　　.任何不会修改数据成员的函数都应该声明为const 类型。

五、补充重要说明

　　.类内部的常量限制：使用这种类内部的初始化语法的时候，常量必须是被一个常量表达式
　　.初始化的整型或枚举类型，而且必须是static和const形式。

　　.如何初始化类内部的常量：一种方法就是static 和 const 并用，在外部初始化，例如：
class A {
　　public: A() {}
private:
　　static const int i; //注意必须是静态的！
}；
const int A::i=3;
另一个很常见的方法就是初始化列表：
class A {
public:
　　A(int i=0):test(i) {}
private:
　　const int i;
}；
还有一种方式就是在外部初始化，

　　.如果在非const成员函数中，this指针只是一个类类型的；如果在const成员函数中， this指针是一个const类类型的；如果在volatile成员函数中,this指针就是一个volatile类类型的。

　　.new返回的指针必须是const类型的。

用户定义字面量

#include <iostream>
long double operator"" _mm(long double x) { return x / 1000; }
long double operator"" _m(long double x)  { return x; }
long double operator"" _km(long double x) { return x * 1000; }
int main() {
    std::cout << 1.0_mm << '\n';
    std::cout << 1.0_m  << '\n';
    std::cout << 1.0_km << '\n';
}

其输出是：

0.001
1
1000

这种新语法其实很容易理解：#include之后的三行代码定义了一个用户自定义的新的类型的操作符，称为字面量操作符 literal operator。在这个例子中，这个运算符能够转换相应的长度单位，例如，1 mm = 10-3 m，1 km = 103 m，而 1 m = 1 m。因此，我们的操作符就可以自动计算每个长度单位是多少米。

在开始试验这个特性之前，我们应该了解这种字面量操作符的参数的数量和类型的限制。根据 C++ 11 标准，只有下面这些签名是合法的：

char const*
unsigned long long
long double
char const*, std::size_t
wchar_t const*, std::size_t
char16_t const*, std::size_t
char32_t const*, std::size_t

最后四个对于字符串相当有用，因为第二个参数会自动推断为字符串的长度。例如：

std::size_t operator"" _len(char const*, std::size_t l) {
    return l;
}
int main() {
    std::cout << "ABCDEFGH"_len << '\n';
}

其输出是 8。
上面列出的第一个签名不要同字符串相混淆，应该被称为原始字面量 raw literal 操作符。例如：

char const* operator"" _r(char const* s) {
    return s;
}
int main() {
    std::cout << 12_r << '\n';
}

其输出值是 12。

字面量的返回值并没有被严格限定。我们完全可以提供相容类型的返回值。例如：

std::string operator"" _rs(char const* s) {
    return 'x' + std::string(s) + 'y';
}
int main() {
    std::cout << 5_rs << '\n';
}

其输出应该是 x5y。