c++11(4): 模版

constexpr常量表达式

函数:

constexpr int GetConst(){return 1;}

1): 函数体只能有单一的return返回语句
2): 函数必须有返回值(不能为void)
3): 使用前必须已定义,即函数定义写在调用函数前面(放至后面则出错)
4): return返回语句表达式中必须是一个常量表达式,且不能是运行时函数

---

值:

constexpr int a = 1;

它是编译时期的值,编译器可以选择不为它生成数据

---

自定义类: 必须对构造函数加上constexpr关键词

struct MyType{
   constrxpr MyType(int x): my_int(x){}
   int my_int;
}
constexpr MyType mt  = {2};

1): 构造函数的函数体必须为空
2): 初始化列表只能由常量表达式来赋值

变长模板

template <typename T1, typename T2>
class A{};

template <typename... SomeType>
class B: private A<SomeType...>{};

B<int, char> xy;

typename之后带...来说明这是一个参数包,该包名字为SomeType
构造类型B时,会调用B的私有基类构造函数,并进行参数包展开
即实际上执行的是A<int, char> xy;

---

template <typename... B>
class MyClass;

template <typename A, typename... B>
class MyClass<A, B...>: private MyClass<B...>{
   A my_a;
};

template<>
class MyClass<>{};

递归定义,在参数个数为0时结束,从右往左

参数包可以展开的位置:
1): 表达式
2): 初始化列表
3): 基类描述列表
4): 类成员初始化列表
5): 模板参数列表
6): 通用属性列表
7): lambda函数的捕捉列表

---

template <typename... A>
class MyClass1: private OldClass<A...>{};
Myclass1 C1<X, Y>;
//解包为 class MyClass1: private OldClass<X, Y>{};

template <typename... A>
class MyClass2: private OldClass<A>...{};
Myclass2 C2<X, Y>;
//解包为 class MyClass2: private OldClass<X>, private OldClass<Y>{};

template <typename... A>
int GetSize(A... args){
   int size = sizeof...(A);    //使用sizeof...()获取参数包的大小(个数)
   return size;
}

与转发合用:......

原子操作

63. 头文件<atomic>, <thread>

atomic_int  at1 {0};
atomic<int> at2 {0};

int Set(){
   at1 = 1;
   at2 = 2;
}
int Show(){
   cout << at1 << ", " << at2 << endl;    //可能输出(1,0)/(0,2)/(1,2)
}
int main(){
   thread t1(Set, 0);
   thread t2(Show, 0);

   t1.join();
   t2.join();
   cout << at1 << ", " << at2 << endl;    //必输出 1, 2
}

由于编译器的优化,执行时可能会打乱实际的代码顺序
所以需要显式使用原子类的成员函数写入store()和读取load()
这些函数有2个参数,第一个是值,第二个是操作类型
操作枚举值:
memory_order_relaxed不对执行顺序作保证
memory_order_acquire本线程中,所有后续的读操作必须在本条原子操作完成后执行
memory_order_release本线程中,所有之前的写操作完成之后才能执行本条原子操作
memory_order_acq_rel同时包含memory_order_acquire和memory_order_release
memory_order_consume本线程中,所有后续的有关本原子类型的操作,必须在本条原子操作完成后执行
memory_order_seq_cst全部存取按照顺序执行

store()可用:
memory_order_relaxed,
memory_order_release,
memory_order_seq_cst

load()可用:
memory_order_relaxed,
memory_order_consume,
memory_order_acquire,
memory_order_seq_cst

RMW(Read Modify Write)同时读写操作可用: 全部

thread_local线程局部变量

int thread_local tl;

quick_exit() / at_quick_exit()快速退出

struct A{}{
   ~A(){};
}
void Func(){}
int main(){
   A a;
   at_quick_exit(Func);      //注册一个函数,在quick_exit时FILO执行
   quick_exit(0);            //A的析构函数不执行
}

nullptr指针空值

= default 和 = delete 默认函数

class A{
public:
   A() = default;           //使用默认构造函数, 保持POD类型
   A(const A&) = delete;    //删除该函数, 且禁止重载该函数
};

lambda函数(局部函数)

int a = 1, b = 2;
auto Func1 = [=]() -> int{
   return a + b;
};
int c = Func1();      //c = 3

auto Func2 = [](int i1, int i2) -> int{
   return i1 + i2;
}
int d = Func2(a, b);  // d = 3

[var]值传递方式捕捉变量var
[=]值传递方式捕捉所有父作用域的变量,包括this
[this]值传递方式捕捉当前this

[&var]引用传递方式捕捉变量var
[&]引用传递方式捕捉所有父作用域的变量,包括this
[&this]引用传递方式捕捉当前this

数据对齐

alignas(double) int a = 1;             //a按照double类型宽度对齐
alignas(alignof(double)) int b = 1;    //效果相同, alignof用于获取类型的宽度

通用属性

Unicode

原生字符串

参考资料: <<深入理解C++11: C++11新特性解析与应用>>