在C++0x中，我们可以在定义一个构造函数时调用另外一个构造函数：
　　class X {
　　int a;
　　public:
　　X(int x) { if (0<x && x<=max) a=x; else throw bad_X(x); }
　　// 构造函数X()调用构造函数X(int x)
　　X() :X{42} { }
　　// 构造函数X(string s)调用构造函数X(int x)
　　X(string s) :X{lexical_cast<int>(s)} { }
　　// …
　　};
　　继承的构造函数 Inheriting constructors
　　C++11提供了将构造函数晋级的能力：
　　比如以下这个示例，基类提供一个带参数的构造函数，而派生类没有提供；
　　如果直接使用D1 d(6);将会报错；通过将基类构造函数晋级，派生类中会隐式声明构造函数D1(int)；
　　需要注意的是，晋级后的基类构造函数是无法初始化派生类的成员变量的，所以如果派生类中有成员变量，
　　需要使用初始化列表初始化；
　　struct B1 {
　　B1(int) { }
　　};
　　struct D1 : B1 {
　　using B1::B1; // 隐式声明构造函数D1(int)
　　// 注意：在声明的时候x变量已经被初始化
　　int  x{0};
　　};
　　void test()
　　{
　　D1 d(6);    // d.x的值是0
　　}
　　类内部成员的初始化 Non-static data member initializers
　　在C++98标准里，只有static const声明的整型成员能在类内部初始化，并且初始化值必须是常量表达式。这些限制确保了初始化操作可以在编译时期进行。
　　class X {
　　static const int m1 = 7;   // 正确
　　const int m2 = 7;    // 错误：无static
　　static int m3 = 7;              // 错误：无const
　　static const string m5 = “odd”; //错误：非整型
　　};
　　C++11的基本思想是，允许非静态（non-static）数据成员在其声明处（在其所属类内部）进行初始化。这样，在运行时，需要初始值时构造函数可以使用这个初始值。现在，我们可以这么写：
　　class A {
　　public:
　　int a = 7;
　　};
　　它等同于使用初始化列表：
　　class A {
　　public:
　　int a;
　　A() : a(7) {}
　　};
　　单纯从代码来看，这样只是省去了一些文字输入，但在有多个构造函数的类中，其好处很明显了：
class A {
public:
A(): a(7)， b(5)， hash_algorithm(“MD5″)，
s(“Constructor run”) {}
A(int a_val) :
a(a_val)， b(5)， hash_algorithm(“MD5″)，
s(“Constructor run”)
{}
A(D d) : a(7)， b(g(d))，
hash_algorithm(“MD5″)， s(“Constructor run”)
{}
int a， b;
private:
// 哈希加密函数可应用于类A的所有实例
HashingFunction hash_algorithm;
std::string s;  // 用以指明对象正处于生命周期内何种状态的字符串
};
　　可以简化为：
　　class A {
　　public:
　　A() {}
　　A(int a_val) : a(a_val) {}
　　A(D d) : b(g(d)) {}
　　int a = 7;
　　int b = 5;
　　private:
　　//哈希加密函数可应用于类A的所有实例
　　HashingFunction hash_algorithm{“MD5″};
　　//用以指明对象正处于生命周期内何种状态的字符串
　　std::string s{“Constructor run”};
　　多么优雅！
　　移动构造和移动赋值
　　在C++98中，我们自定义的类，会默认生成拷贝赋值操作符函数和拷贝赋值函数以及析构函数；
　　在C++11中，依赖于新增的move语义，默认生成的函数多了2个移动相关的：移动赋值操作符（ move assignment ）和移动构造函数（ move constructor ）；
　　BS建议，如果你显式声明了上述 5 个函数或操作符中的任何一个，你必须考虑其余的 4 个，并且显式地定义你需要的操作，或者使用这个操作的默认行为。
　　一旦我们显式地指明（ 声明 ， 定义 ， =default ， 或者 =delete ）了上述五个函数之中的任意一个，编译器将不会默认自动生成move操作。
　　一旦我们显式地指明（ 声明 ， 定义 ， =default ， 或者 =delete ）了上述五个函数之中的任意一个，编译器将默认自动生成所有的拷贝操作。但是，我们应该尽量避免这种情况的发生，不要依赖于编译器的默认动作。
　　如果你声明了上述 5 个默认函数中的任何一个，强烈建议你显式地声明所有这 5 个默认函数。例如：
　　template<class T>
　　class Handle {
　　T* p;
　　public:
　　Handle(T* pp) : p{pp} {}
　　// 用户定义构造函数： 没有隐式的拷贝和移动操作
　　~Handle() { delete p; }
　　Handle(Handle&& h) :p{h.p}
　　{ h.p=nullptr; }; // transfer ownership
　　Handle& operator=(Handle&& h)
　　{ delete p; p=h.p; h.p=nullptr; } // 传递所有权
　　Handle(const Handle&) = delete;  // 禁用拷贝构造函数
　　Handle& operator=(const Handle&) = delete;
　　// ...
　　};