第一篇：C++11关键字

C++11 关键字共73个。

新增关键字： alignas、alignof、char16_t、char32_t、constexpr、decltype、

noexcept、nullptr、static_assert、thread_local。
auto 的意义改变。

register 被视为过时的（可能在未来标准移除）。

export 因为实现支持太少（仅Edison Design Group的前端支持），编译效率低下，取消原有意义（仍是关键字，但使用它的程序是错误的），改为保留给未来标准使用。 

alignas

alignof用于获取取指定表达式指定的（类似sizeof，可以直接是类型名）的对齐(alignment)。alignas用于声明时指定对齐类似于现有的类型。和sizeof类似，两者的操作数都不被求值。

constexpr

类似const但更强大，修饰函数或对象，表示函数结果或对象是编译时决定的常量，以便优化。

char16_t 和 char32_t

二者分别表示16位字符型和32位字符型，类似char和wchar_t，也是一般只专用于表示字符的整数类型，且设计上用于表示Unicode字符。char16_t和char32_t是C++11新增的，以克服wchar_t在不同平台上无法保证确定宽度的缺点。

decltype

用于编译时推断类型。此外参与函数声明的另一种语法：指定返回auto，同时decltype引导trailing-return-type指定实际应该返回类型。decltype的操作数也不被求值。

nullptr

字面量nullptr是具有std::nullptr_t类型的右值，是空指针常量。C++98/03中表示空指针常量的NULL或0都会在重载中引起混淆，而纯库的解决方案在这里也遇到困难，所以有必要加入新的关键字来专门表示空指针。

noexcept

实践表明动态异常规范会影响运行时性能。新增的noexcept表示静态异常规范，只指定函数（模版）是否有异常抛出，这里noexcept即noexcept(true)，表示没有异常抛出。除了异常规范，noexcept可以作用于一个表达式来判断是否有异常，这对于模版代码非常有用。

static_assert

用于编译时的静态断言：若指定的表达式为false则编译失败。

auto

C++11标准和C++98/03标准的auto是不同的。C++98/03标准中，auto表示自动储存类型 ；C++11标准中，auto表示由编译器静态判断其应有的类型。

C++98/03关键字

asm

语法：asm(“instruction”)
asm允许在C/C++程序中直接插入汇编语言指令
//汇编代码块
asm
｛
instruction-sequence
｝
//or单条汇编指令
asm(instruction);

auto

关键字auto用来声明一个自动存储变量，也就是申明一块临时的变量内存。在C++98/C++03标准里auto的定义如上，但在C++11之后的标准里auto的临时变量的主义不再存在，auto被定义为自动类型推断，例如：

//这里的x被auto推断为double类型

auto x=1.2;

//这里的iter被auto推断为vector<string>::iterator类型

vector<string> vec;auto iter = vec.begin();
在C++11标准中auto关键字有一个限定条件：声明变量时必须赋一个初始值，否则编译阶段报错。
因为声明为auto的变量在编译时期就分配了内存，而不是到了运行时期，所以使用auto不再引发任何速度延迟，这也意味着使用auto的时候，这个变量不初始化会报错。因为编译器无法知道这个变量的类型。
C++11标准里不能用auto来定义一个函数类型，但在新的C++14标准里就可以使用了。
看例子：
C++11:
std::vector<int>& add_one(std::vector<int> &v)
{
for(auto& it : v)
it += 1;
return v;
}
C++14:
auto& add_one(std::vector<int>& v)
{
for(auto& it : v)
it += 1;
return v;
}
C++14中可以根据函数返回类型来判断，如果函数是递归的，递归调用必须定义在至少一个return语句后，下面的代码是正确的，但两个return语句调换位置则是错误的。
auto Correct(int i)
{
if(i == 1)
return i;
else
return Correct(i-1)+i;
}
还得注意：auto不能与其他类型组合连用，auto int a=1; //是错误的
auto是一个占位符，并不是他自己的类型，因此不能用于类型转换或者sizeof/typeid操作等；
auto不能自动推导为CV类型（也即constant & volatile类型），除非声明为引用类型。
const int i=100; auto j = i;j = 99;//Ok
const int i=100; auto &j = i; j = 99;//Error

bool, true, false

bool

bool关键字用来声明布尔逻辑变量的，也就是说变量要么是真要么是假
bool boolean1 = true; //真
bool boolean2 = false; //假

true 

"true"是布尔型的值。

false

是布尔型的值，一般定义为(int)0;

break, continue, goto

break

break是用来跳出一个循环用的，循环如：do...while, while, for, 也可以用来结束一个switch语句的子句。break语句只能跳出一层循环。

continue

continue语句用来结束当前适合条件的循环，接着执行下一轮循环。

goto 

语法: 
goto labelA;
...
labelA:
goto语句可以完成从当前位置到指定标志位的跳转.

case, default, switch

case

语法：case value:
value的类型可以是int, char, boolean, enum。在switch里用来检测匹配项。

default

在switch语句中用作缺省条件。

switch 

语法: 
switch( expression ) {
case A:
    statement list;
    break;
case B:
   statement list;
   break;
...
case N:
   statement list;
   break;
default:
    statement list;
    break;
}
switch语句允许你通过一个表达式判断许多数值,它一般用来在多重循环中代替if()...else if()...else if()... 语句. break 语句必须在每个case 语句之后, 负责循环将执行所有的case语句.default case 是可选的.假如所有的case都不能匹配的话,他将和defult case匹配.

catch, throw, try
用于异常处理。try指定try块的起始，try块后的catch可以捕获异常。异常由throw抛出。throw在函数中还表示动态异常规范，但在C++11中被标记为过时（由noexcept部分取代）

catch

catch语句通常通过throw语句捕获一个异常。如果在try语句块程序段中发现了异常，且抛出该异常，则这个异常就可以被try语句块后的某个catch语句所捕获并处理，捕获和处理的条件是被抛出的异常的类型与catch语句的异常类型相匹配。
try
{
//程序中抛出异常 throw value;
}
catch(valuetype v)
{
//例外处理程序段
}
语法小结：throw抛出值，catch接受，当然，throw必须在“try语句块”中才有效。

throw 

语法: 
try {
statement list;
}
catch( typeA arg ) {
statement list;
}
catch( typeB arg ) {
statement list;
}
...
catch( typeN arg ) {
statement list;
}
throw 在C++体系下用来处理异常.同try 和 catch 语句一起使用, C++ 处理异常的系统给程序一个比较可行的机制用于错误校正.当你通常在用 try 去执行一段有潜在错误的代码时.在代码的某一处,一个throw 语句会被执行, 这将会从try的这一块跳转到catch的那一块中去.

 try 

try 语句试图去执行由异常产生的代码。

struct, class, union

 class

语法：
class class-name : inheritance-list {
    private-members-list;    
    protected:
      protected-members-list;
    public:
      public-members-list;
  } object-list；
class关键字允许用户创建自己的数据类型。

struct 

语法: 
struct struct-name : inheritance-list
{
//默认为public
     public-members-list;    
protected:
     protected-members-list;
private:
     private-members-list;
} object-list;
struct 类似于 class, struct中的成员更像是类中的公共成员.在C中,structs 仅能包含数据并不允许有继承表. 例如: 
struct Date {
int Day;
int Month;
int Year;
};

union 

语法: 
union union-name {
public-members-list;    
private:
private-members-list;
} object-list;
union 类似于 class,除了所有的成员分享同一内存外它的缺省值更像公共类型.

const,volatile
const和volatile是类型修饰符，语法类似，在C++中合称为cv-限定符(cv-qualifier)。可以共同使用。用于变量或函数参数声明，也可以限制非静态成员函数。const表示只读类型（指定类型安全性，保护对象不被意外修改），volatie指定被修饰的对象类型的读操作是副作用（因此读取不能被随便优化合并，适合映射I/O寄存器等）。

const

const关键字用来限定一个变量不允许被改变，即只读，使用const在一定程序上可以提高程序的安全性和可靠性。const作为类型限定符，是类型的一部分。相比C中的const，在C++里const允许在编译时确定作为真正的常量表达式，如const int max_len=10; int arr[max_len]; 

volatile 

关键字volatile在描述变量时使用,阻止编译器优化那些以valatile修饰的变量,volatile被用在一些变量能被意外方式改变的地方,例如:抛出中断,这些变量若无volatile可能会和编译器执行的优化 相冲突.

const_cast, dynamic_cast, reinterpret_cast, static_cast

 const_cast

语法：const_cast<type> (object);
关键字const用于修改类型的const或volatile属性。
一、常量指针被转化成非常量的指针，并且仍然指身原来的对象
二、常量引用被转换成非常量的引用，并且仍然指向原来的对象

dynamic_cast

语法: 
dynamic_cast<type> (object);
关键字dynamic_cast强制将一个类型转化为另外一种类型，并且在执行运行时时检查它保证它的合法性。如果你想在两个互相矛盾的类型之间转化时，cast的返回值将为NULL.

reinterpret_cast 

语法: 
reinterpret_cast<type> (object);
reinterpret_cast 操作能把一种数据类型改变成另一种.它应当被用在两种不可调和的指针类型之间.

static_cast 

语法: 
static_cast<type> (object);
关键字static_cast 用来在两个不同类型之间进行强制转换,并且没有运行时间检查.
 
delete, new
delete单独使用，表示释放具有动态存储期对象，默认版本调用全局的去配器(deallocator)::operator delete和析构函数。new单独使用，表示请求分配动态存储期对象，默认版本调用全局的分配器(allocator)::operator new和指定的析构函数。和operator连用表示分别表示去配器(operator delete)和分配器(operator new)，用于释放分配器(allocator)的内存和分配内存。operator delete也在分配内存被异常中断时被调用。

 delete

语法：delete p;或delete [] pArr;
delete与new都属于C++的操作符，用来释放p指向的内存，这个指针指向的内存是被new申请的内存，第二种形式用于删除new申请的一个数组。

 new 

语法: 
pointer = new type;
pointer = new type( initializer );
pointer = new type[size];
new可以给数据类型分配一个新结点并返回一个指向新分配内存区的首地址. 也可以对它进行初始化.中括号中的 size 可以分配尺寸大小.

do, for, while

 do

语法: 
do {
statement-list;
} while( condition );
do构建一个循环语句表,直到条件为假.注意循环中的语句至少被执行一次,因为判断条件在循环的最后.

for 

语法: 
for( initialization; test-condition; increment )
{
statement-list;
}
for由4部分组成：1、初始化initialization 2、判断条件test-condition3、増量increment 4、语句体statement-list
执行顺序：1->2->4->3->2->4->3……
循环语句的组成部分。C++支持do-while循环、for循环和while循环。C++11新增了ranged-based for循环，用:分隔声明的对象和指定循环的范围。
eg: 
vector<int> vec;
……
for(auto &e : vec)
cout<<e<<endl;

while 

语法: 
while( condition ) {
statement-list;
}
关键字 while 用于一个只要条件未真就执行statement-list的循环体.注意假如起始条件为false,statement-list 将不被执行. (你可以用一个do循环来保证statement-list至少被执行一次.)

数值类型
即double、float、long、int、short、signed、unsigned
signed和unsigned作为前缀修饰整数类型，分别表示有符号和无符号。signed和unsigned修饰char类型，构成unsigned char和signed char，和char都不是相同的类型；不可修饰wchar_t、char16_t和char32_t。其它整数类型的signed省略或不省略，含义不变。signed或unsigned可单独作为类型，相当于signed int和unsigned int。
double和float专用于浮点数，double表示双精度，精度不小于float表示的浮点数。long double则是C++11指定的精度不小于double的浮点数。
其它关键字表示整数类型。从占用空间大小(sizeof)来看，保证char<=short<=int<=long<=long long。注意这些都不是相同的类型，即便大小和范围都一致；各自具有unsigned版本。其中long long是C++11指定的不小于long的整数。

char, wchar_t

char

关键字char是可以容纳单个字符的一种基本数据类型，是C/C++中整形数据中比较古怪的一个，因为int/long/short等在不指定signed/unsigned时默认是signed的，但char在标准中却是unsigned的，不过编译器可以实现为带符号的，也可以是无符号的，还可以通过编译开关指定char为有符号类型还是无符号类型的。char还有比较特殊的一点是char*,在C/C++中，它不同signed char*也不同于unsigned char*，专门用于指以'\0'为结束的字符串。char *p="abcd"是可以通过编译的，但signed char *p="abcd" or unsigned char *p="abcd"是不能通过编译的。

wchar_t 

关键字 wchar_t 用来声明字符变量的宽度，不同平台可能存在移植问题。

if, else 

 if

if语句的主要功能是给程序提供一个分支，在if语句中的语句成立则执行if后的语句体。
注意：
1、布尔变量与零值比较：不能用布尔变量直接与ture/false/1/0进行比较，因为布尔类型定义零值为假（false），任何非零值都是真(true)
2、整形变量与零值比较：应当将整形变量用"=="/"!="直接与0比较
3、浮点变量与零值比较：不可将浮点变量用“==”或“！=”与任何数字比较。无论是float还是double类型的变量，都有精度限制。所以一定要避免将浮点变量用“==”或“！=”与数字比较，应该设法转化成“>=”或“<=”形式。
4、指针变量与零值比较：应当将指针变量用“==”或“！=”与NULL比较。指针变量的零值是“空”（记为NULL）。尽管NULL的值与0相同，但是两者意义不同。

else

关键字else用在if语句中的二中选一。

enum 

语法: 
enum name {name-list} var-list;
关键字enum用来创建一个包含多个名称元素的名称表.var-list 是可选的。枚举值是常量，不是变量，因此不能在程序中用赋值语句再对它赋值；枚举元素本身由系统定义一个表示序号的数值，从0开始递增，如果有一个定义为某个整形数a，则下一个枚举值为a+1，如此递增；只能把枚举值赋予给枚举变量，不能把元素的数值直接赋予枚举变量，不过可以通过强制类型转换实现。
C++11新增带作用域的枚举，用enum class或enum struct（两者等价）声明。

explicit

explicit可以阻止不应该允许的经过转换构造函数进行的隐式转换的发生。声明为explicit的构造函数不能在隐式转换中使用。
C++中， 一个参数的构造函数(或者除了第一个参数外其余参数都有默认值的多参构造函数)， 承担了两个角色。 1 是个构造器 ，2 是个默认且隐含的类型转换操作符。

export

导出模版，用于分离编译。当初标准委员会未经充分实践支持匆忙通过了这一决定，被EDG证明具备不现实的可用性（即便EDG唯一地实现了这一个特性，他们也表示反对） 。MSVC、GCC、Clang等其它主流编译器前端都没有实现这一特性，甚至这是唯一明显约定不符合C++98/03的特性。C++11废除了这个export关键字的含义，但保留这个关键字，供以后使用。

extern 

关键字extern用来告知编译器变量在当前范围之外声明过了.被extern语句描述过的变量将分派不到任何空间,因为他们在别的地方被定义过了.extern语句频繁的用于在多个文件之间的跨范围数据传递.。
C++11新增extern用于模版显式实例化声明，表示不在当前翻译单元实例化模版，而在别处有定义。这可以提升编译效率。

 friend

关键字friend允许类或函数访问一个类中的私有数据

 inline

语法: 
inline int functionA( int i )
{
...
}
inline这个关键字请求编译器扩张一个给定的函数。它向这个函数发出一条插入代码的call。函数里面有静态变量，嵌套的，switches，或者是递归的时候不给予内联。当一个函数声明包含在一个类声明里面时，编译器会尝试的自动把函数内联。
C++11中，新增inline namespace，指示命名空间中的名称同时是外层命名空间直接包含的名称。这便于命名空间的版本管理，减少冲突。

 mutable

关键字mutable忽略所有const语句，一个属于const的mutable成员可以被修改
在c++的类中， 如果一个结构被const 修饰，那么它将无法修改其成员变量的，但是如果这个成员变量是被mutable修饰的话，则可以修改。

 namespace 

语法: 
namespace name
{
declaration-list;
}
关键字namespace允许你创建一个新的空间.名字由你选择,忽略创建没有命名的名字空间.一旦你创建了一个名字空间,你必须明确地说明它或者用关键字using. 

 operator 

语法: 
return-type class-name::operator#(parameter-list)
{
...
}
关键字operator 用于重载函数.在上面语法中用特殊符(#)描述特征的操作将被重载.假如在一个类中,类名应当被指定.对于一元的操作, parameter-list 应当为空, 对于二元的操作,在operator右边的 parameter-list 应当包含操作数 (在operand 左边的被当作 this通过). 对于不属于重载函数的operator成员,在左边的操作数被作为第一个参数,在右边的操作数被当作第二个参数被通过.
不能用#, ##, ., :, .*, 或者 ? 标志重载. 

private, protected, public

private 

属于私有类的数据只能被它的内部成员访问,除了friend 使用.关键字private 也能用来继承一个私有的基类,所有的公共和保护成员的基类可以变成私有的派生类.

protected 

保护数据对于它们自己的类是私有的并且能被派生类继承.关键字也能用于指定派生,所有的公共和保护成员的基类可以变成保护的派生类.

public 

在类中的公共数据可以被任何人访问.关键字public也能用来指定派生,所有的公共和保护成员的基类可以变成保护的派生类.

 register 

关键字register 请求编译器优化它定义的变量,并且通常这种优化比人工优化的好.
C++11中被标记为过时的.

  return 

语法: 
return;
return( value );
return 语句可以从当前函数跳转到调用该函数的任何地方.返回值是任意的.一个函数可以有不止一个返回语句.

 sizeof 

sizeof 操作用来用字节计算右边表达式并返回字节数.

 static 

static 数据类型用来给变量创建永久存储空间.静态变量在函数间调用时保持他们的值不变。还有另一个用途——用于类作用域声明，表示声明的成员是类共有的，不需要通过类的对象访问。类的静态数据成员也具有静态存储期，除非被thread_local修饰。

 template 

语法: 
template <class data-type>
return_type name( parameter-list ) {
statement-list;
}
Templates能用来创建一个对未知数据类型的操作的函数模板.这个通过用其它数据类型代替一个占位符data-type 来实现.
例子:
template<class X>
void generic_swap( X &a, X &b ) {
X tmp;
tmp = a;
a = b;
b = tmp;
}

 this 

关键字 this 指向当前对象.所有属于一个 class 的函数成员都有一个this 指向.

 typedef 

语法: 
typedef existing-type new-type;
关键字typedef 允许你从一个现有的类型中创建一个新类型.
C++11中可被using新增的用法代替

 typeid 

语法: 
typeid( object );
typeid 操作返回给一个type_info 定义过的对象的那个对象的类型. 

 typename 

关键字typename能用来在中 template 描述一个未定义类型或者代替关键字class.

 using 

有两种基本用法：using声明和using指示（using namespace ...）。
前者是声明，引入命名空间或基类作用域内已经被声明的名称。后者引入命名空间内所有的名称。
C++11新增了一类用法，可以代替typename，同时可以配合template使用（typedef基于语法考虑未被允许加入这种用法）。

 virtual 

语法: 
virtual return-type name( parameter-list );
virtual return-type name( parameter-list ) = 0;
关键字virtual 能用来创建虚函数,它通常不被派生类有限考虑.但是假如函数被作为一个纯的虚函数 (被=0表示)时, 这种情况它一定被派生类有限考虑.

 void 

关键字void用来表示一个函数不返回任何值,或者普通变量能指向任何类型的数据. void 也能用来声明一个空参数表.