1. 继承构造函数

C++98中，如果派生类需要使用基类的构造函数，需要在构造函数中显式声明：

struct A{A(int i){}};
struct B:A{
    B(int i):A(i),d(i){};
    int d;
}

:::info 但是，倘若基类中有大量构造函数，而派生类只有一些成员函数，其构造就等同于构造基类，但我们还需要写很多“透传”的构造函数 ::: :::warning 在C++中，如果派生类想要使用基类的函数的话，可以使用using声明来完成，在C++11中，对于构造函数也可这样做 :::

struct A{
    A(int i){}
    A(double d,int i){}
    A(float f,int i, const char* c){}  
};
struct B:A{
    using A::A;
    //...
    virtual void ExtraInterface(){};
}

通过使用using的方式，基类的构造函数被继承到B中，这样就不需要透传构造函数了。
此外，继承构造函数并不会继承参数的默认值。

2. 委派构造函数

和继承构造函数类似，委派构造函数也是C++11中的构造函数的一种改进，为了减少构造函数书写的时间。具体来讲继承构造函数可能是针对基类衍生出的派生类的，而委派构造函数时针对同一个类中的多种构造函数的。
具体思想是提供一个构造函数作为基准版本，而其他构造函数通过基准版本来进行初始化。 :::warning C++11中委派构造函数是在构造函数的初始化列表进行构造、委派的 :::

class Info{
public:
    Info() {InitRest();}
    Info(int i):Info(){type =i;}
    Info(char e): Info(){ name=e;}
private:
    void InitRest(){};
    int type{1};
    char name{'a'};
}

值得注意的是委派构造函数中成员变量赋初值只能在函数体中进行，因为委派构造函数不能有初始化列表，即构造函数不能同时委派和使用初始化构造列表。 :::info 委派构造函数的一个实际的应用就是用构造模板函数产生目标构造函数 :::

#include<list>
#include<vector>
#include<deque>
using namespace std;
class TDConstructed{
    template<class T> TDConstructed(T first, T last):
    l(first,last){}
    list<int> l;
    public:
    TDConstructed(vector<short>& v):
    TDConstructed(v.begin(),v.end()){}
    TDConstructed(deque<int>& d):
    TDConstructed(d.begin(),d.end()){}
};

如上述代码，TDConstructed类可以很容易地接受多种容器进行初始化。

3.右值引用

拷贝构造和移动构造

如果类中包含一个指针成员(或者说类中包含一个堆上的成员的话)，就需要小心拷贝构造函数的编写，因为可能发生内存泄漏的情况。（即存在深拷贝和浅拷贝问题）
但是拷贝构造函数在拷贝的过程中会给指针成员分配新的内存空间，然后在进行拷贝，有时候我们并不需要多次分配新的内存。

#include<iostream>
using namespace std;
class HasPtrMem{
public:
    HasPtrMem():d(new int(0)){
        cout<<"Construct:"<<++n_cstr<<endl;
    }
    HasPtrMem(const HasPtrMem& h):d(new int(*h.d)){
        cout<<"Copy construct:"<< ++n_cptr<<endl;
    }
    ~HasPtrMem(){
        cout<<"Destruct:"<<++n_dstr<<endl;
    }
    int *d;
    static int n_cstr;
    static int n_dstr;
    static int n_cptr;
};
int HasPtrMem::n_cstr=0;
int HasPtrMem::n_dstr=0;
int HasPtrMem::n_cptr=0;
HasPtrMem GetTemp(){
    return HasPtrMem();
}
int main(){
    HasPtrMem a=GetTemp();
    return 0;
}

g++ test.cpp -fno-elide-constructors
注意：指定这个参数（-fno-elide-constructors）是为了关闭编译器的优化，强制 g++ 在所有情况下都会调用拷贝构造函数。

Construct:1    //GetTemp内构造了一个匿名对象
Copy construct:1    //匿名对象拷贝给一个临时对象，该临时对象是函数的返回值
Destruct:1    //匿名对象析构
Copy construct:2    //函数返回值（临时对象）拷贝给a
Destruct:2    //临时对象析构
Destruct:3    //a析构

可以看出有两次拷贝构造函数的调用，如果成员包含很大的数据的话，这会耗时很多，因此使用移动构造函数。
对于拷贝构造而言，内存的变化如下

对于移动构造而言，内存的变化如下：

在C++11中，这样”偷走“临时变量中的资源的构造函数就被称为”移动构造函数“，这样”偷“的行为则被称作移动语义。

HasPtrMem::HasPtrMem(HasPtrMem &&h):d(h.d){
    h.d=nullptr;
    cout<<"Move construct:"<<++n_mvtr<<endl;
}
/*
Construct: 1     
Move construct: 1
Destruct: 1      
Move construct: 2
Destruct: 2      
Destruct: 3 
*/

移动构造函数接受的右值引用的参数，所谓的偷取内存，就是指将本对象d指向h.d所指的内存这一条语句，同时要将h的成员d置为空指针。
何时触发移动构造函数？遇到临时变量时

左值、右值、右值引用

所谓左值和右值的概念是源自C，在C++中还有一个广泛认可的说法，可以取地址的、有名字的就是左值，反之不能去地址的、没有名字的就是右值。 :::info 更细致地，在C++11中右值是由两个概念组成：将亡值（xvalue，eXpiring Value）和纯右值（prvalue，pure Rvalue）。

纯右值是C++98的概念，表示临时变量和一些不跟对象关联的值，例如非引用返回的函数的返回值、运算表达式、不跟对象关联的字面值(2,'c',true)，类型转换函数的返回值、lambda表达式也是
将亡值是C++11新增的与右值引用相关的表达式，通常是将要被移动的对象，例如，返回右值引用T&&的函数返回值、std::move的返回值 :::
注意事项

右值引用实际上就是对于一个右值进行引用的类型，实际上由于右值常常不具备名字，我们只能通过引用的方式找到他的存在。e.g., T&& a=ReturnRvalue()
此外，无论是声明一个左值还是右值，都是需要在声明的同时立刻进行初始化。
右值引用可以延长右值的生命周期，让其和右值引用类型的变量的存活时间一样。
通常情况下右值引用无法绑定一个左值，但是左值引用可以绑定右值对象，前提是左值引用是const修饰的，即常量左值引用，不允许修改引用对象。
为了语义的完整，C++11还允许常量右值引用，但是没有什么用。。。。
通常情况下如果需要移动语义，程序员需要自己定义移动构造函数，并且类似之前的拷贝构造函数，一旦声明了移动构造函数，C++便不会生成默认的copy 、move construct

确定引用类型
有时我们不知道引用是啥类型，标准库在<type_traits>中提供了三个模板类：is_rvalue_reference is_lvalue_reference is_reference，可以用来判断。
此外，可以通过一些辅助的模板类来判断一个类型是否可以移动：is_move_constructible is_trivially_move_constructible is_nothrow_move_constructible

用法：is_move_constructible<UnknownType>::value

std::move 强制转换右值

在C++11标准库<utility>中提供了函数std::move，他的功能是将一个左值强制转换为一个右值引用。
基本上等价于：static_cast<T&&>(lvalue);
需要注意的是转化后，左值的生命周期并未随着转换而变化，即左值并不会立刻被析构。因此被转换后不应该再使用。

#include <iostream>
#include <utility>
using namespace std;
class HugeMem{
public:
    HugeMem(int size):sz(size>0?size:1){
        c=new int [sz];
    }
    ~HugeMem(){ delete []c ;}
    HugeMem(HugeMem&& hm):sz(hm.sz),c(hm.c){
        hm.c=nullptr;
    }
    int *c;
    int sz;
};
class Moveable{
public:
    Moveable():i(new int(3)),h(1024){}
    ~Moveable(){ delete i; }
    Moveable(Moveable&& m):i(m.i),h(move(m.h)){
    //m.h被强制转换为右值，可以用移动构造函数了
     //如果不改右值的话需要写个深拷贝版本的的HugeMem的拷贝构造
      //然后这里会调他的拷贝构造在新建一个然后赋值，开销巨大
        m.i=nullptr;
    }
    int * i;
    HugeMem h;
};
Moveable GetTemp(){
    Moveable temp=Moveable();
    cout<<hex<<"Huge Mem from "<<__func__<<
    " @ "<<temp.h.c<<endl;
    return temp;
}
int main()
{
    Moveable a = GetTemp();
   cout<<hex<<"Huge Mem from "<<__func__<<
    " @ "<<a.h.c<<endl;
    return 0;
}

Huge Mem from GetTemp @ 0x1e3ed0
Huge Mem from main @ 0x1e3ed0   //发现是同一个内存空间的

需要注意的是，用move时应该是在将要转换的对象即将消亡的时候。
典型应用2：高性能swap函数

template<class T>
void swap(T& a,T& b){
    T tmp(move(a));
    a=move(b);
    b=move(tmp);
}

抛出异常

对于移动语义，抛出异常是十分危险的。因此可以用std::move_if_noexcept模板函数来替代move。
该函数在类的移动构造函数没有noexcept修饰时，返回左值引用，可以实现拷贝语义，反之返回右值引用。

完美转发

:::info 完美转发指的是，在函数模板中，完全依靠模板的参数类型，将参数传递给函数模板中调用的另一个函数，要求不产生额外的开销，就好像转发者不存在一样。 :::

template<typename T>
void IamForwording(T t){ IrunCodeActually(t); }

因为要求不需要额外开销，所以通常都是用引用来完成，左值引用和右值引用都应该支持。但是因为如之前所说，右值引用不能引用左值，因此存在问题。
C++11引入了一条所谓的“引用折叠（reference collapsing）”规则，并且结合新的模板推导规则来完成完美转发。所谓的引用折叠是指将复杂的未知表达式折叠成已知的简单表达式，其大致规则是一旦定义中出现了左值引用，引用折叠总是优先将其折叠为左值。

typedef T& TR;
TR& v=xx;

TR类型	声明v的类型	v的实际类型
T&	TR	A&
T&	TR&	A&
T&	TR&&	A&
T&&	TR	A&&
T&&	TR&	A&
T&&	TR&&	A&&

因此完美转发可以用如下形式：

template<typename T>
void IamForwording(T && t){ IrunCodeActually(static_cast<T&&>(t)); }

例如传入一个X类型的左值引用：

void IamForwording(X& && t){ IrunCodeActually(static_cast<X& &&>(t)); }
//根据折叠的规则：
void IamForwording(X& t){ IrunCodeActually(static_cast<X&>(t)); }

如此左值和右值都没有问题了。

列表初始化

C++98中允许用花括号来对数组进行统一的初始化，C++11扩大了这一范围，这种初始化方法被称作列表初始化。

int a=3+4;//=
int a={3+4};//花括号+-
int a(3+4);//圆括号
int a{3+4};//花括号
double* d=new double{1.2f};

此外还可以对自定义的类进行列表初始化，需要包含头文件。

#include<vector>
#include<string>
using namespace std;
enum Gender{M,F};
class People{
    People(initializer_list<pair<string,Gender>> l){
        auto i=l.begin();
        for(;i!=l.end();i++){
            data.push_back(*i);
        }
    }
private:
    vector<pair<string,Gender>> date;
};
People ship2012={{"Garfield",M},{"HelloKitty",F}};

此外还能对函数参数列表进行列表初始化

#include<initializer_list>
using namespace std;
void Func(initializer_list<int> iv){};
int main(){
    Func({1,2});
    Func({});
}

模板的别名

C++中使用typedef定义类型的别名：typedef int myint，
对于比较长的名字具有较大的优势：typedef std::vector<std::string> strvec;
C++11中定义别名不在是typedef的专属，using也可以达到同样甚至更好的效果

template <typename T> using MapString =std::map<T,char*>;
MapString <int> numberedString;

Computer Science

🍬3. 通用为本，专用为末