auto a = 1;    //ok  自动推导出a为int

auto b = 2.0;   //ok 自动推导出b为 double

vector v;
auto iterator = v.begin();        //ok自动推导出 vector::iterator

1
2
3
4
5
6
7

int i;
decltype(i) j = 0;
//typeid可以查看变量类型
cout< 

float a;
double b;
decltype(a + b) c;
cout< tmp;
decltype(tmp.begin()) k;
1
2
3
4
5
6
7
8
9
10
11
12
13

template
auto add(T1 &t1, T2 &t2) ->decltype(t1 + t2)
{
	return t1 + t2;
}

调用：
auto a =1;
auto b = 2.5;
auto c = add(a, b);

1
2
3
4
5
6
7
8
9
10
11

 	bool flag = false;
    assert(flag == true); //这里flag!= true不会继续运行
    cout<<"Hello C++"<

• 1
• 2
• 3

C++11中提供了静态断言机制（static_assert），可以在编译阶段对断言进行测试，可以更早发现各种功能错误。

语法如下：
static_assert(常量表达式， 提示字符串)

注意：只能是常量表达式，不能是变量

static_assert(sizeof(void*) == 4, "64bit 系统不支持");
1

noexcept

如果函数不会抛出异常，则在函数最后加上noexcept

void func() noexcept

{

​ ****************

}

常量表达式

常量表达式主要是允许一些计算发生在编译时，即发生在代码编译而不是运行的时候

（直接在编译时就做一次，而不是运行时都计算，提升性能）

C++11中可使用constexpr

constexpr int getNum()
{
    return 3;
}

constexpr int tmp = getNum(); //ok  发生在编译阶段
1
2
3
4
5
6

constexpr函数的限制：

1、函数只能有一个return语句
2、函数必须有返回值 （不能时void）
3、在使用前必须已有定义
4、return返回语句表达式中不能使用非常量表达式的函数、全局数据且必须时一个常量表达式
1
2
3
4

类中成员是常量表达式

class MyTest{
public:
    //constexpr修饰构造函数，构造函数体必须为空，通过参数初始化列表进行构造
    constexpr MyTest(int y, int m, int d):year(y),month(m),day(d)
    {
        
    }
    constexpr int getYear()
    {
        return year;
    }
    constexpr int getMonth()
    {
        return month;
    }
    constexpr int getDay()
    {
        return day;
    }

private:
    int year;
    int month;
    int day;
};

调到用:
 constexpr MyTest test(2017,10,10); //必须使用常量给构造函数传参
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

final与override

final修饰类

表示阻止类的派生（继承）， 被final修饰的类不能在被继承

class A final{

};

class A1: public A{} //error A类时final不能被继承
1
2
3
4
5

final修饰类的成员函数

class B{
public:
	virtual void func() final   //final修饰的虚函数不能被重写
	{}
};

class B1: public B{
	virtual void func()     //error 子类不能重写父类final修饰的虚函数
}
1
2
3
4
5
6
7
8
9

override

override用在子类重写父类的虚函数时加上override

class A1{
public:
	virtual void func(int a)
	{
	
	}
};

class A2: public A1{
public:
	//在重写父类的虚函数地方加上override   要求重写的虚函数的函数签名和父类一样否则会报错提示
	virtual void func(int a) override
	{
	
	}
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

default与delete

default

函数模板的默认模板参数

1、普通