C++11 新关键字

恋喵大鲤鱼

已于 2023-09-23 17:59:39 修改

阅读量3.6k

点赞数 13

分类专栏： C++11 文章标签： C++ C++11

于 2016-12-26 21:49:43 首次发布

本文链接：https://blog.csdn.net/K346K346/article/details/53887827

版权

C++11 专栏收录该内容

18 篇文章 31 订阅

订阅专栏

1.auto

auto 是旧关键字，在 C++11 之前，auto 用来声明自动变量，表明变量存储在栈，很少使用。在 C++11 中被赋予了新的含义和作用，用于类型推断。

auto 关键字主要有两种用途：

变量类型推断

在变量定义时根据初始化表达式自动推断变量类型。

auto i = 42;		//i is an int
auto l = 42LL;  	//l is an long long
auto p = new foo(); //p is a foo*

函数返回值的占位符

在声明或定义函数时作为函数返回值的占位符，此时需要与关键字 decltype 连用。auto 不能用来声明函数的返回值。但如果函数有一个尾随的返回类型时，auto 是可以出现在函数声明中返回值位置。这种情况下，auto 并不是告诉编译器去推断返回类型，而是指引编译器去函数的末端寻找返回值类型。在下面这个例子中，函数返回值类型是 operator+ 操作符作用在 T、U 类型变量上的返回值类型。

template<class T, class U> auto add(T t, U u) -> decltype(t + u) {
    return t + u;
}

2.using

using 是旧关键词，从 C++11 开始，被赋予了新的功能。using 在 C++11 之前主要用于名字空间、类型、函数与对象的引入，实际上是去除作用域的限制。

//引入名字空间
using namespace std;
//引入类型
using std::iostream;
//引入函数
using std::to_string;
//引入对象
using std::cout;

其中通过 using 引入函数可以解除函数隐藏。

class Base {
public:
	void func() { 
		cout << "in Base::func()" << endl;
	}
	void func(int n) { 
		cout << "in Base::func(int)" << endl;
	}
};

class Sub: public Base {
public:
	using Base::func;	// 引入父类所有同名函数func，解除函数隐藏
	void func() {
		cout<<"in Sub::func()"<<endl;
	}
};

int main() {
	Sub s;
	s.func();
	s.func(1); // Success!
}

从 C++11 开始，可以使用 using 代替 typedef，给类型命名。

// 等价于 typedef unsigned char uint8;
using uint8=unsigned char;

// 等价于 typedef void (*FunctionPtr)();
using FunctionPtr = void (*)(); 

// 定义模板别名，注意typedef无法定义模板别名，因为typedef只能作用于具体类型而非模板
template<typename T> using MapString = std::map<T, char*>;

3.decltype

随着 C++ 模板和泛型编程的广泛使用，类型推导成为了 C++ 必备的一个能力。在 decltype 出现之前，很多编译器厂商都实现了自己的 C++ 扩展特性用于类型推导，比如 GCC 的 typeof 操作符。C++11 将这些类型推导手段进行了细致的考量，最终标准化为 auto 与 decltype。decltype 与auto 关键字类似，用于编译时类型推导，不过它与 auto 还是有一些区别的。decltype 的类型推导并不像 auto 从变量声明的初始化表达式获得变量的类型，而总是以一个普通表达式作为参数，返回该表达式的类型，而且 decltype 并不会对表达式进行求值 $^{[2]}$ 。

3.1 推导规则

如果 e 是一个变量或者类成员访问表达式，假设e的类型是T，那么的decltype(e)为T，decltype((e)) 为 T&。
如果e是一个解引用操作，那么 decltype(e) 和 decltype((e)) 均为 T&。
否则 decltype(e) 与 decltype((e)) 均为 T。

3.2 用法示例

（1）推导出表达式类型。

struct A { double x; };
const A* a = new A{0};

//第一种情况
decltype(a->x) y;       // type of y is double
decltype((a->x)) z = y; // type of z is const double&,因为a一个常量对象指针

//第二种情况
int* aa=new int;
decltype(*aa) y=*aa;    //type of y is int&，解引用操作

//第三种情况
decltype(5) y;          //type of y is int
decltype((5)) y;        //type of y is int
const int&& RvalRef() { return 1; }
decltype ((RvalRef())) var = 1;  //type of var is const int&&

（2）与using/typedef合用，用于定义类型。

using size_t = decltype(sizeof(0));//sizeof(a)的返回值为size_t类型
using ptrdiff_t = decltype((int*)0 - (int*)0);
using nullptr_t = decltype(nullptr);

vector<int>vec;
typedef decltype(vec.begin()) vectype;
for (vectype i = vec.begin; i != vec.end(); i++)
{
	//...
}

显而易见，与auto一样，也提高了代码的可读性。

（3）重用匿名类型。在 C++ 中，我们有时候会遇上一些匿名类型。

struct {
    int d ;
    doubel b;
}anon_s;

借助 decltype，我们可以重新使用这个匿名结构体，C++11 之前我们是无法做到的。

decltype(anon_s) as ;	//定义了一个上面匿名的结构体

注意，匿名类型有其匿名的原因，一般情况下，匿名类型不应该被重用，应尽量避免这种用法。

（4）泛型编程中结合 auto，用于追踪函数的返回值类型，这是 decltype的最大用途。decltype 帮助 C++ 模板更加泛化，程序员在编写代码时无需关心任何时段的类型选择，编译器会合理地进行推导。

template <typename _Tx, typename _Ty> auto multiply(_Tx x, _Ty y)->decltype(x*y) {
    return x*y;
}

4.nullptr_t 与 nullptr

C++11 之前都是用 0 来表示空指针，但由于 0 可以被隐式类型转换为整型，这就会存在一些问题。关键字 nullptr 是 std::nullptr_t 类型的值，用来指代空指针常量。nullptr 和任何指针类型以及类成员指针类型的空值之间可以发生隐式类型转换，同样也可以隐式转换为 bool 型（取值为false），但是不存在到整型的隐式转换。

int* p1 = NULL;
// 或
int* p2 = nullptr;

在使用 nullptr_t 与 nullptr 时，注意以下几点：

可以使用 nullptr_t 定义空指针，但所有定义为 nullptr_t 类型的对象行为上是完全一致的。
nullptr_t 类型对象可以隐式转换为任意一个指针类型。
nullptr_t 类型对象不能转换为非指针类型，即使使用reinterpret_cast进行强制类型转换也不行。
nullptr_t 类型对象不能用于算术运算表达式。
nullptr_t 类型对象可以用于关系运算表达式，但仅能与 nullptr_t 类型或指针类型对象进行比较，当且仅当关系运算符为==、>=、<=时，如果相等则返回 true。

5.constexpr

5.1 简介

constexpr 在 C++11 中用于申明常量表达式 (const expression)，可作用于函数返回值、函数参数、数据申明以及类的构造函数等。常量表达式指值不会改变并且在编译时期就得到计算结果的表达式 $^{[4]}$ ，例如：

const int i=3;    //i是一个常变量
const int j=i+1;  //j是一个常变量，i+1是一个常量表达式
int k=23;         //k的值可以改变，从而不是一个常变量
const int m=f();  //m不是常变量，m的值只有在运行时才会获取

5.2 constexpr 的应用

（1）常量表达式函数
如果函数返回值在编译时期可以确定，那么可以使用constexpr修饰函数返回值，使函数成为常量表达式函数。

constexpr int f(){return 1;}

注意，constexpr修饰函数返回值需要满足如下条件：
（a）函数必须有返回值；
（b）函数体只有单一的return语句；
（c）return语句中的表达式也必须是一个常量表达式；
（d）函数在使用前必须已有定义。

（2）常量表达式值
一般来说，如果认定变量是一个常量表达式，那就把它声明为constexpr类型。

constexpr int i=3;		//i是一个常变量
constexpr int j=i+1;	//i+1是一个常变量
constexpr int k=f(); 	//只有f()是一个constexpr函数时，k才是一个常量表达式

必须明确一点，在constexpr声明中，如果定义了一个指针，constexpr仅对指针有效，与指针所指对象无关。

const int *p=nullptr;  		//p是一个指向整型常量的指针（pointer to const）
constexpr int *p1=nullptr;	//p1是一个常量指针(const pointer)

如果自定义类型对象为常量表达式，那么在定义自定义类型时，需要将constexpr作用于自定义类型的构造函数。

struct MyType {
	int i;
	constexpr MyType(int x):i(x){}
};
constexpr MyType myType(1);

constexpr作用于自定义类型的构造函数需要满足如下条件：
（a）构造函数体必须为空；
（b）初始化列表只能使用常量表达式。

（3）常量表达式的其他应用
（a）常量表达式作用于函数模板
常量表达式可以作用于函数模板，但是由于函数模板参数的不确定性，实例化后的模板函数可能不满足常量表达式的条件，此时，C++11标准规定，自动忽略constexpr。

struct NotConstType {
	int i;
	NotConstType(int x) :i(x) {}
};
NotConstType myType;

//constexpr作用于函数模板
template <typename T> constexpr T ConstExpFunc(T t) {
	return t;
}

int main() {
	NotConstType objTmp = ConstExpFunc(myType);				//编译通过，ConstExpFunc实例化为普通函数，constexpr被忽略
	constexpr NotConstType objTmp1 = ConstExpFunc(myType);	//编译失败
	constexpr int a = ConstExpFunc(1);						//编译通过，ConstExpFunc实例化为常量表达式函数
}

（b）constexpr元编程
constexpr可以作用于递归函数来实现编译时期的数值计算，即constexpr元编程。C++11标准规定，常量表达式应至少支持512层递归。

constexpr int Fibonacci(int n) {
	return (n == 1) ? 1 : (n == 2 ? 1 : Fibonacci(n - 1) + Fibonacci(n - 2));
}

int main() {
	constexpr int fib8 = Fibonacci(8);	//编译期常量等于21
}

注意，constexpr 元编程并非 C++11 标准强制规定编译器必须实现，编译器可以选择地实现。也就是说，编译器可能并不支持递归常量表达式函数。不过也不用过于担心，主流的 C++ 编译器都是支持的，比如 GCC 和 VC++。

5.3 constexpr 与 const 的区别

const可以修饰函数参数、函数返回值、函数本身、类等，在不同的使用场景下，const具有不同的意义，不过大多数情况下，const描述的是“运行时常量性”，即在运行时数据具有不可更改性。

constexpr可以修饰函数参数、函数返回值、变量、类的构造函数、函数模板等，是一种比const更加严格的约束，它修饰的表达式除了具有“运行时常量性”，也具有“编译时常量性”，即constexpr修饰的表达式的值在编译期间可知。下面看一个实际应用时的区别：

const int getConst(){ return 1; }
enum{ e1=getConst(),e2};				//编译出错

//换成constexpr即可在编译期确定函数返回值用于初始化enum常量
constexpr int getConst(){ return 1; }
enum{ e1=getConst(),e2};				//编译OK

在constexpr出现之前，可以在编译期初始化的const表达式都是隐含的常量表达式（implicit constexpr），直到C++ 11，constexpr才从const中细分出来成为一个关键字，而 const从1983年C++刚改名的时候就存在了。面对constexpr，我们应当尽可能地、合理地使用constexpr来帮助编译器优化代码。

6.noexcept

在 C++11 之前，C++在函数声明中有异常声明（exception specification）的功能，用来指定函数可能抛出的异常类型。

void Func0() throw(runtime_error);
void Func1() throw();
void Func2();

函数 Func0 可能抛出 runtime_error 类型的异常；函数 Func1 不会抛出任何异常；函数 Func2 没有异常说明，则该函数可以抛出任何类型的异常。

如果函数抛出了没有在异常说明中列出的异常，则编译器会调用标准库函数unexpected。默认情况下，unexpected函数会调用terminate函数终止程序。

这种异常声明的功能很少使用，因此在 C++11 中被弃用（实际仍可使用）。C++11 引入 noexcept，具有两层含义，一个是修饰符，二是操作符。

（1）修饰符示例。

voidFunc3() noexcept;

noexcept的功能相当于上面的throw()，表示函数不会抛出异常。如果noexcept修饰的函数抛出了异常，编译器可以选择直接调用std::terminate()终止程序运行。noexcept比throw()效率高一些。

voidFunc4() noexcept(常量表达式);

如果常量表达式的结果为true，表示该函数不会抛出异常，反之则有可能抛出异常。不带常量表达式的noexcept相当于noexcept(true)。

（2）操作符示例。
上面 noexcept 的用法是其作为修饰符时的用法，实际上 noexcept 还可以作为操作符，常用于模板中。

template <typename T> void func5() noexcept(noexcept(T())) {}

第二个 noexcept 是一个操作符，如果其参数是一个有可能抛出异常的表达式，noexcept(T()) 则返回值为false，那么 func5 有可能会抛出异常，否则 noexcept(T()) 返回true，func5 不会抛出异常。这样函数模板是否会抛出异常，可以由表达式进行推导，使得 C++11 更好的支持泛型编程。参考以下示例：

template <typename T>
void fun() noexcept(noexcept(T())) { throw 1; }

class Base {
public:
    virtual void f() {}
};

class Test :public Base {
public:
    ~Test() noexcept(true) {}
};

class TestFalse :public Base {
public:
    ~TestFalse() noexcept(false) {}
};

int main(int argc, char **argv) {
    std::cout << noexcept(TestFalse()) << std::endl;        // false
    std::cout << noexcept(Test()) << std::endl;             // true

    try {
        fun<TestFalse>();
    }
    catch (...) {
        std::cout << "throw" << std::endl;                   // throw
    }

    try {
        fun<Test>();                                         // terminate
    }
    catch (...) {
        std::cout << "throw" << std::endl;
    }
    return 0;
}

程序输出：

0
1
throw
terminate called after throwing an instance of 'int'
Aborted

7.final 和 override

2012 年 3 月 22 日，GCC 4.7.0 正式发布，从这个版本开始，GCC 增加了许多新的 C++ 11 特性，final 和 override 关键字便是其中之一。

7.1 final

（1）final 修饰类。

final 可用于申明终结类，从此 C++ 便有申明终结类的关键字了。

struct B1 final {};
struct D1 : B1 {}; 	// 错误！不能从 final 类继承！

上面的代码是错误的，因为 D1 试图继承 B1，而 B1 被 final 声明为终结类，类似于 Java 关键字 final 的作用。

（2）final 修饰虚函数。

final 修饰虚函数，表明子类不能重写该虚函数，为“终结虚函数”。

struct B2 {
    virtual void f() final {} // final 函数
};
 
struct D2: B2 {
    virtual void f() {}
};

这段代码会出错，因为 D2::f 重写了 B2::f，但是 B2::f 却被声明为 final 。

7.2 override

假如我们继承基类的虚函数，在重写虚函数时写错了，参数类型或个数不对，但是编译没问题，造成了对基类同名函数的隐藏，运行时候和设计的不一样，override 辅助编译器检查是否正真重写了基类虚函数，将错误提前暴露在编译期。

struct B3 {
    virtual void f() {}
};
 
struct D3: B3 {
    void f(int a) {}  //未重写，发生隐藏，但不会报编译错误
};

开发 D3 的程序员真的想重写 B3::f 函数吗？还是说，他只是不小心写了个与父类同名的函数，却在不经意间导致了隐藏？为了避免这种错误，C++11 引入了 override 关键字。于是，我们会发现，下面这段代码会出错：

struct B4 {
    virtual void g(int) {}
};
 
struct D4: B4 {
    virtual void g(int) override {}    // OK
    virtual void g(double) override {} // Error
};

多亏了 override 关键字，我们可以让编译器帮我们检测到这个很难发现的程序错误。这段代码的错误在于，override 关键字表明，g(double) 虽然想要进行 override 的操作，但父类并没有这么个函数。有时，C++ 编译器的“放纵”降低了代码可读性，所以在实际开发中，建议大家在子类类体内声明或者重写继承而来的虚函数时，加上关键字 virtual 表明当前函数是虚函数，以提高代码可读性。

注意，override 和 virtual 一样，只能在类体内申明或重写虚函数时使用，在类体外重写虚函数时使用 override 和 virtual 将无法通过编译。即下面的代码将报编译错误。

struct B4 {
    virtual void g(int) {}
};
 
struct D4 : B4 {
    virtual void g(int) override;    	// OK
};
virtual void D4::g(int) override {}		// Error

值得注意的是，这些并不是奇技淫巧，而是能确确实实地避免很多程序错误，并且暗示编译器作出一些优化。调用标记了 final 的 virtual 函数，例如上面的 B2::f，GNU C++ 编译时会识别出来这个函数不能被重写，因此会将其从类的虚表中删除。而标记为final 的类，例如上面的 B1，编译器则根本不会生成虚表，这样的代码显然效率更高。

8.sizeof… 运算符

sizeof… 运算符的作用是获取 C++11 中可变参数模板中参数包中元素个数。类似 sizeof，sizeof… 返回一个常量表达式，而且不会对模板的实参求值。

template<typename... Args> void g(Args... args) {
	cout<<sizeof...(Args)<<endl;  //类型参数的数目
	cout<<sizeof...(args)<<endl;  //函数参数的数目
}

9.default 和 delete

9.1 default

C++98 和 C++03 编译器在类中会隐式地产生四个函数：默认构造函数、拷贝构造函数、析构函数和赋值运算符函数，它们被称为特殊成员函数。在 C++11 中，被称为 “特殊成员函数” 的还有两个：移动构造函数和移动赋值运算符函数。如果用户申明了上面六种函数，编译器则不会隐式产生。C++11 引入的 default 关键字，可显示地、强制地要求编译器生成默认版本。

class DataOnly {
public:
	DataOnly()=default;               //default constructor
	~DataOnly()=default;              //destructor

	DataOnly(const DataOnly& rhs)=default;    			//copy constructor
    DataOnly& operator=(const DataOnly & rhs)=default;  //copy assignment operator

    DataOnly(const DataOnly && rhs)=default;  		//C++11,move constructor
    DataOnly& operator=(DataOnly && rhs)=default;  	//C++11,move assignment operator
};

上面的代码，就可以让编译器生成上面六个函数的默认版本。

9.2 delete

delete关键在C++11之前是对象释放运算符，但在C++11中，被赋予了新的功能，主要有如下几种作用。
（1）禁止编译器生成上面六种函数的默认版本。

class DataOnly {
public:
	DataOnly()=delete;               //default constructor
	~DataOnly()=delete;            	//destructor

	DataOnly(const DataOnly& rhs)=delete;    //copy constructor
	DataOnly& operator=(const DataOnly & rhs)=delete;  //copy assignment operator

	DataOnly(const DataOnly && rhs)=delete;  		//C++11,move constructor
	DataOnly& operator=(DataOnly && rhs)=delete;  	//C++11,move assignment operator
};

（2）C++11 中，delete 关键字可用于任何函数，不仅仅局限于类成员函数。在函数重载中，可用delete来滤掉一些函数的形参类型，如下：

bool isLucky(int number);        // original function
bool isLucky(char) = delete;     // reject chars
bool isLucky(bool) = delete;     // reject bools
bool isLucky(double) = delete;   // reject doubles and floats

这样在调用 isLucky 函数时，如果参数类型不对，则会出现错误提示

if (isLucky('a'))...       // error! call to deleted function
if (isLucky(true))...      // error!
if (isLucky(3.5))...       // error!

（3）在模板特例化中，也可以用 delete 来过滤一些特定的形参类型。例如，Widget 类中声明了一个函数模板，当进行模板特化时，要求禁止参数为 void* 的函数调用。

class Widget
{
public:
	template<typename T> void processPointer(T* ptr){}
};
template<> void Widget::processPointer<void>(void*)=delete;	//deleted function template

10.static_assert

static_assert是C++11引入的静态断言，与assert（运行时断言宏）相反，用于检测和诊断编译期错误。基本语法如下：

static_assert(断言表达式，提示字符串);

断言表达式必须是在编译期可以计算的表达式，即必须是常量表达式。如果断言表达式的值为 false ，那么编译器会出现一个包含指定字符串的错误，同时编译失败。如果为 true 那么没有任何影响。例如：

static_assert(sizeof(void*) == 8,"not supported");

static_assert和type traits一起使用能发挥更大的威力。type traits是一些类模板，在编译时提供关于类型的信息，在头文件<type_traits>中可以找到它们。这个头文件中有好几种类模板，有helper class，用来产生编译时常量，有type traits class，用来在编译时获取类型信息，还有就是type transformation class，他们可以将已存在的类型变换为新的类型。下面这段代码原本期望只作用于整数类型。

template <typename T1, typename T2> auto add(T1 t1, T2 t2) {
	return t1 + t2;
}

但是如果有人写出如下代码，编译器并不会报错。

std::cout << add(1, 3.14) << std::endl;
std::cout << add("one", 2) << std::endl;

程序会打印出4.14和”e”。但是如果我们加上编译时断言，那么以上两行将产生编译错误。

template <typename T1, typename T2> auto add(T1 t1, T2 t2) {
   static_assert(std::is_integral<T1>::value, "Type T1 must be integral");
   static_assert(std::is_integral<T2>::value, "Type T2 must be integral");
   return t1 + t2;
}

使用static_assert，应当注意：
（1）static_assert可以用在全局作用域，命名空间，类作用域，函数作用域，几乎可以不受限制地使用；
（2）static_assert可以在帮助我们在编译期间发现更多的错误，用编译器来强制保证一些契约，改善编译信息的可读性，尤其是用于模板的时候；
（3）编译器在遇到一个static_assert语句时，通常立刻将其第一个参数作为常量表达式进行演算。如果第一个常量表达式依赖于某些模板参数，则延迟到模板实例化时再进行演算，这就让检查模板参数成为了可能；
（4）由于是static_assert编译期间断言，不生成目标代码，因此static_assert不会造成任何运行期性能损失。

11.alignas 与 alignof

内存对齐指变量起始存储地址和类型大小是对齐字节数的整数倍。例如某个int型变量，其起始存储地址0x0000CC04是4的整数倍，那么这个变量就是对齐的。在C++11之前对齐方式是无法得知的，且不同的平台实现方式可能不同。C++11为了支持内存对齐，引入了两个关键字，对齐描述符alignas与操作符alignof。alignas用于指定类型的对齐字节数，alignof用于获取类型的对齐字节数。

alignas不仅可以作用于类型，也可以作用于成员变量。并且alignas既可以接受常量表达式，也可以接受类型作为参数。所以alignas(char) int i等价于alignas(alignof(char)) int i。使用常量表达式作为alignas的操作数时，其值必须是2的自然数次幂。对齐值越大，对齐要求越高；对齐值越小，对齐要求越低。显然，能够满足严格对齐要求的对齐方式也能够满足要求低的对齐方式。

alignof的操作数表示一个定义完整的自定义类型或者内置类型或者变量，返回一个std::size_t类型的整型常量。如同sizeof操作符一样，alignof获得的也是一个与平台相关的值。具体用法参考如下代码：

struct Example1 {
    char c;
    int i;
    long long l;
};

struct alignas(16) Example2 {
    char c;
    alignas(8) int i;	//alignas作用于成员变量
    long long l;
};

Example2 array[1024];

int main() {
	std::cout << alignof(Example1) << std::endl;  	// 8
    std::cout << sizeof(Example1) << std::endl;   	// 16
	
	std::cout << alignof(Example2) << std::endl;  	//16
	std::cout << sizeof(Example2) << std::endl;   	//32

	std::cout << alignof(int) << std::endl;       	// 4
	alignas(char) int i;				 
	std::cout << alignof(i) << std::endl;         	//1

	std::cout<<alignof(array)<<std::endl;			//16
    return 0;
}

//编译选项：g++ -std=c++11

理解上述程序输出结果，需要注意以下几点：
（1）构造类型的对齐取决于类型对齐值和各成员对齐值中最大的那个，所以

sizeof(Example2)=sizeof(char)+7+sizeof(int)+4+sizeof(long long)+8=1+7+4+4+8+8=32

（2）数组的对齐值由其元素决定，所以alignof(array)等于alignof(Example2)，等于16。

此外，对内存对齐的支持，C++11在标准库中还提供了std::align()函数来动态地根据指定的对齐方式调整数据块的位置。以及在STL中提供的类模板aligned_storage及aligned_union，其作用与std::align()函数类似，具体用法不详细展开，感兴趣的读者可自行了解。

12.thread_local

thread_local由C++11引入，用于将全局或static变量申明为线程局部存储（TLS，thread local storage）变量，即拥有线程生命周期及线程可见性的变量。

比如程序中有一个全局变量errCode，开启多个线程，每个线程都需要使用这个全局的errCode变量，不同的线程设置不同的错误码，但是，又不能让所有线程同时访问同一个errCode，不然无法正确获取每个线程的错误码。此时有两个解决方案：
（1）改变定义errCode的位置，把errCode从全局变量变为线程的局部变量（比如一个函数中）。
（2）定义errCode的位置不变，依然是全局，只要加一个thread_local关键词，其他什么都不用改。

thread_local int errCode;

一旦申明一个变量为thread_local，其值的改变只对所在线程有效，其它线程不可见。

参考文献

C++ primer中文版第五版.P619-619
深入理解C++11.C7.1.2 nullptr与nullptr_t
深入理解C++11.C6.4 线程局部存储.P214-216
深入理解C++11[M]6.1常量表达式.P174-P183
【C++11新特性】auto关键字
 C++11特性：decltype关键字
 C++开发者都应该使用的10个C++11特性
 constexpr与常量表达式(c++11标准)
了解C++11（五）—— noexcept
C++11 新特性：显式 override 和 final
C++11 之 delete 和 default
< type_traits>
学习笔记：alignas用法
 《深入理解C++11》笔记–noexcept

恋喵大鲤鱼

关注

13
点赞
踩
41

收藏

觉得还不错? 一键收藏
4
评论
C++11 新关键字

1.autoauto是旧关键字，在C++11之前，auto用来声明自动变量，表明变量存储在栈，很少使用。在C++11中被赋予了新的含义和作用，用于类型推断。auto关键字主要有两种用途：一是在变量定义时根据初始化表达式自动推断该变量的类型，二是在声明或定义函数时作为函数返回值的占位符，此时需要与关键字decltype连用。1.1用法示例（1）auto用于推断变量类型示例。auto i = 42;......
复制链接

扫一扫