c++新特性

继承构造函数：

实用情况：基类的构造函数很多，子类的构造函数想要实现同样多得构造接口，必须一一调用积累的构造函数，有点麻烦。 在子类中写上 using 父类名：：父类名

继承构造函数只会初始化基类中的成员变量(毕竟只是从基类继承下来的), 对于派生类中的变量无能为力,

（2）不过，可以配合另一个C++11中的新特性: 数据成员就地初始化，来解决这个问题。但是，这种做法导致子类的成员不能在构造函数的参数列表中体现出来。

（3）一旦，子类继承了基类的构造函数，那么子类就不会自动生成默认构造函数。

委托构造函数：

允许类中的一个构造函数通过初始化列表方式来调用同一个类中的另一个构造函数

class SomeType{

protected:

int number=10;

string name;

SomeType(int _num,string &_name):number(_num),name(_name){

}

public:

SomeType(string &_name):SomeType(1,_name){//直接构造调用函数 委托构造函数

}

};

缺点：

struct Rule2 {

int i, c;

Rule2(): Rule2(2) {}

Rule2(int i): Rule2('c') {}

Rule2(char c): Rule2(2) {}

};

Rule2定义中，Rule2()、Rule2(int)和Rule2(char)都依赖于别的构造函数，形成环委托构造关系。这样的代码通常会导致编译错误

override 关键字

检查虚函数是否正确 ，在类名后加final ，说明这个类不能继承，在函数名后加也是同理。

函数绑定

#include <iostream>

#include <functional>

using namespace std;

using namespace placeholders;

int f(int a,int b,int c){

printf("a=%d b=%d c=%d",a,b,c);

printf("\n");

return a>b?a:b;

}

int main(int argc, const char * argv[])

{

//绑定到类的非静态成员函数

function<int(int,int,int)>f_bind= bind(f, _1 ,_3,5);

cout<< f_bind(4,1,5)<<endl;

int i=2,j=3;

function<int()>f=[&](){

i= i+1;

j=j+3;

return i+j;

};

cout<<f()<<endl;

cout<<"i="<<i<<"j="<<j<<endl;

//lambda 表达式可以方便地构造匿名函数，如果你的代码里面存在大量的小函数，而这些函数一般只被调用一次，那么不妨将他们重构成 lambda 表达式。

function<int (int )> f1=[](int i){

return i+4;

};

cout<<f1(6)<<endl;//带参数

int z=[=]()mutable throw ()->int{int n=i+j; return n;}();

cout<<"z="<<z<<endl;

function<int()> z1=[=](){

return i+j;

};

cout<<"z1="<<z1()<<endl;

return 0;

}

关键字：explicit

作用：防止隐示转换 eg ：

//explicit防止隐示类型转换

class SomeClass {

public:

SomeClass(){

cout<<"default"<<endl;

}

explicit SomeClass(int a):some(a){

cout<<"my ctor"<<endl;

}

private:

int some;

};

SomeClass someClass;

// someClass=5;//这里隐示转换了 加上了explicit会报错，就是防止隐示转换

bind 的动态识别

//bind的多态行为

class A{

public:

virtual void f(int a){

cout<<a<<endl;

cout<<"A::f()"<<endl;

}

void init(){

auto f=bind(&A::f, this,_1);//bind的多态行为

f(10);

}

};

class B:public A{

public:

virtual void f(int a){

cout<<a<<endl;

cout<<"B::f()"<<endl;

}

};

decltype 可以从一个变量或表达式中得到类型