1. auto
自动推导变量类型，简化代码书写。
#include <iostream>
#include <type_traits>#if defined(__linux__) || defined(__linux)
#include <cxxabi.h>
#define TYPE_NAME(var) abi::__cxa_demangle(typeid(var).name(), 0, 0, 0)
#else
#define TYPE_NAME(var) typeid(var).name()
#endifvoid Test() {char a = 'A';auto aa = a;std::cout << "a,aa type: " << TYPE_NAME(a) << ", " << TYPE_NAME(aa) << std::endl;short b = 1;auto bb = b;std::cout << "b,bb type: " << TYPE_NAME(b) << ", " << TYPE_NAME(bb) << std::endl;int c = 1;auto cc = c;std::cout << "c,cc type: " << TYPE_NAME(c) << ", " << TYPE_NAME(cc) << std::endl;float d = 1.0f;auto dd = d;std::cout << "d,dd type: " << TYPE_NAME(d) << ", " << TYPE_NAME(dd) << std::endl;double e = 1.0;auto ee = e;std::cout << "e,ee type: " << TYPE_NAME(e) << ", " << TYPE_NAME(ee) << std::endl;long f = 1;auto ff = f;std::cout << "f,ff type: " << TYPE_NAME(f) << ", " << TYPE_NAME(ff) << std::endl;const long g = 1;auto gg = g;std::cout << "g,gg type: " << TYPE_NAME(g) << ", " << TYPE_NAME(gg) << std::endl;char h[10] = {0};auto hh = h;std::cout << "h,hh type: " << TYPE_NAME(h) << ", " << TYPE_NAME(hh) << std::endl;int *i = nullptr;auto ii = i;std::cout << "i,ii type: " << TYPE_NAME(i) << ", " << TYPE_NAME(ii) << std::endl;const int *j = nullptr;auto jj = j;std::cout << "j,jj type: " << TYPE_NAME(j) << ", " << TYPE_NAME(jj) << std::endl;const int *const k = nullptr;auto kk = k;std::cout << "k,kk type: " << TYPE_NAME(k) << ", " << TYPE_NAME(kk) << std::endl;int &l = c;auto ll = l;std::cout << "l,ll type: " << TYPE_NAME(l) << ", " << TYPE_NAME(ll) << std::endl;const int &m = c;auto mm = m;std::cout << "m,mm type: " << TYPE_NAME(m) << ", " << TYPE_NAME(mm) << std::endl;int &&n = 1;auto nn = n;std::cout << "n,nn type: " << TYPE_NAME(n) << ", " << TYPE_NAME(nn) << std::endl;const int &&o = 1;auto oo = o;std::cout << "o,oo type: " << TYPE_NAME(o) << ", " << TYPE_NAME(oo) << std::endl;const int *&p = j;auto pp = p;std::cout << "p,pp type: " << TYPE_NAME(p) << ", " << TYPE_NAME(pp) << std::endl;const int *q = j;const auto &qq = j;std::cout << "q,qq type: " << TYPE_NAME(q) << ", " << TYPE_NAME(qq) << std::endl;
}int main(int argc, char *argv[]) {std::cout << "Hello World" << std::endl;Test();return 0;
}执行结果：
| Hello World a,aa type: char, char b,bb type: short, short c,cc type: int, int d,dd type: float, float e,ee type: double, double f,ff type: long, long g,gg type: long, long h,hh type: char [10], char* i,ii type: int*, int* j,jj type: int const*, int const* k,kk type: int const*, int const* l,ll type: int, int m,mm type: int, int n,nn type: int, int o,oo type: int, int p,pp type: int const*, int const* q,qq type: int const*, int const* |
2. decltype
推导实体的声明类型，或表达式的类型和值类别。
#include <iostream>
#include <type_traits>#if defined(__linux__) || defined(__linux)
#include <cxxabi.h>
#define TYPE_NAME(var) abi::__cxa_demangle(typeid(var).name(), 0, 0, 0)
#else
#define TYPE_NAME(var) typeid(var).name()
#endifstruct A {double x;
};const int &GetRef(const int *p) { return *p; }
auto Add(int a, int b) -> decltype(a + b) { return a + b; }void Test() {int a = 33;decltype(a) b = a * 2;std::cout << "a,b type: " << TYPE_NAME(a) << ", " << TYPE_NAME(b)<< std::endl;const A *c = nullptr;decltype(c->x) d;decltype((c->x)) e = d;std::cout << "d,e type: " << TYPE_NAME(d) << ", " << TYPE_NAME(e)<< std::endl;const int *const f = &a;decltype(f) g = &b;std::cout << "f,g type: " << TYPE_NAME(f) << ", " << TYPE_NAME(g)<< std::endl;int &aref = a;decltype(aref) h = a;decltype(Add(10, 20)) i;std::cout << "h,i type: " << TYPE_NAME(f) << ", " << TYPE_NAME(g)<< std::endl;
}执行结果
| a,b type: int, int d,e type: double, double f,g type: int const*, int const* h,i type: int const*, int const* |
3. default & delete
由开发者控制函数由编译器创建(default)或禁止创建(delete)，用于构造、析构系列函数。
class A {A() = delete;A(const A &) = default;A(A &&) = default;A &operator=(const A &) = default;A &operator=(A &&) = delete;~A() = default;
};4. final & override
final 用于指定某个虚函数不能在派生类中被重写，或者某个类不能被派生；override指定一个虚函数重写另一个虚函数，用于派生类虚函数重写了基类某个虚函数，如果没有重写编译报错。
#include <iostream>
#include <string>struct A final { virtual void Print(const std::string &str) { std::cout << str << std::endl; }
}#include <iostream>
#include <string>struct A {A() = default;virtual void Print(const std::string &str) final {std::cout << "A " << str << std::endl;}virtual void Print2(const std::string &str) {std::cout << "A2 " << str << std::endl;}
};struct B : public A {B() : A() {}virtual void Print2(const std::string &str) override {std::cout << "B2 " << str << std::endl;}
};void Test() {A a;a.Print("a invoke");a.Print2("a invoke 2");B b;b.Print("B invoke");b.Print2("b invoke 2");A *c = new B();c->Print("c invoke");c->Print2("c invoke 2");delete c;
}int main(int argc, char *argv[]) {Test();return 0;
}5. 尾随返回类型
当返回类型取决于实参名时或当返回类型复杂时，尾随返回类型很有用。
#include <iostream>template <class T, class U> auto Add(T t, U u) -> decltype(t + u) {return t + u;
}void Test() {int a = 10;double b = 20;std::cout << "a + b = " << Add(a, b) << std::endl;
}int main(int argc, char *argv[]) {Test();return 0;
}执行结果
| a + b = 30 |
6. 右值引用
- 左值：可修改的变量或表达式。
- 右值：常量、表达式等不能出现在等式左边。
- 左值引用(&)：左值变量的引用别名，传统的引用都是左值。
- 右值引用(&&)：右值变量的引用别名，一般只能引用右值，可使用std::move转化为右值，实现移动语义。
- 完美转发：不修改传递的变量或表达式语义，进行完整的语义传递，即左值参数传递后还是左值，左右参数传递后还是右值。
#include <iostream>void Test() {int a = 10; // a 左值， 10右值int &aa = a; // aa 左值引用int &&aaa = std::move(a); // aaa 右值引用，此时 a 在后边作用域内无意义int b = 0;int &bb = b;int &&bbb = std::move(b);const int c = 20;const int &cc = c;// int &&ccc = std::move(c);const int &d = bbb; // const 修饰的引用可以是左值、也可以是右值
}int main(int argc, char *argv[]) {Test();return 0;
}void Func(const int&& x) { cout << "const 右值引用" << endl; }template<typename T>
void Test(T&& t)
{// Func(t); //没有使用forward保持其右值的属性，退化为左值Func(std::forward<T>(t)); // 使用 std::forward 实现完美转发
}7. 移动构造
移动构造函数是一种构造函数，可以提供一个相同类类型实参调用，并复制该实参的内容，有可能会修改实参。
struct A {A() = default;~A() = default;A(const A &) { std::cout << "A(const A&)" << std::endl; }A(A &&) { std::cout << "A(A&&)" << std::endl; }A(const A &&) { std::cout << "const A(A&&)" << std::endl; }A(const volatile A &&) { std::cout << "const volatile A(A&&)" << std::endl; }A(A &&, int num) { std::cout << "A(A&&), num = " << num << std::endl; }int x = 10;
};void Test() {A a;A b = a;A bb = std::move(a);const A c; // 只读变量A d = std::move(c);const volatile A e; // 只读变量A f = std::move(e);a.x = 20;std::cout << "a.x = " << a.x << std::endl;b.x = 30;std::cout << "b.x = " << b.x << std::endl;bb.x = 40;std::cout << "bb.x = " << bb.x << std::endl;d.x = 60;std::cout << "d.x = " << d.x << std::endl;f.x = 80;std::cout << "f.x = " << f.x << std::endl;
}int main(int argc, char *argv[]) {Test();return 0;
}执行结果
| A(const A&) A(A&&) const A(A&&) const volatile A(A&&) a.x = 20 b.x = 30 bb.x = 40 d.x = 60 f.x = 80 |
8. 移动赋值运算符
移动赋值运算符是名字是 operator= 的非模板非静态成员函数，可以提供一个相同类类型实参调用，并复制该实参的内容，有可能会修改实参。
#include <iostream>struct A {A() = default;~A() = default;A &operator=(const A &) {std::cout << "A &operator=(const A &)" << std::endl;}A &operator=(A &&) { std::cout << "A &operator=(A &&)" << std::endl; }A &operator=(const A &&) {std::cout << "A &operator=(const A &&)" << std::endl;}int x = 10;
};void Test() {A a;a.x = 20;A b;b = a;// const A c = a; // 复制构造函数A d;d = std::move(a);// const A e = std::move(a); // 复制构造函数a.x = 20;std::cout << "a.x = " << a.x << std::endl;b.x = 30;std::cout << "b.x = " << b.x << std::endl;d.x = 60;std::cout << "d.x = " << d.x << std::endl;
}int main(int argc, char *argv[]) {Test();return 0;
}执行结果
| A &operator=(const A &) A &operator=(A &&) a.x = 20 b.x = 30 d.x = 60 |
9. 作用域枚举
枚举 是一种独立的类型，它的值被限制在一个取值范围内（细节见下文），它可以包含数个明确命名的常量（“枚举项”）。各常量的值是某个整数类型（称为该枚举的底层类型）的值。枚举的大小、值表示和对齐要求与它的底层类型相同。而且枚举的每个值都与该枚举的底层类型的对应值有着相同的表示。
#include <iostream>enum EnumColor { kRed = 0, kGreen, kBlue };
enum class EnumClassColor { kRed = 3, kGreen, kBlue };
enum class EnumClassColorType : int { kRed = 6, kGreen, kBlue };void Test() {std::cout << "EnumColor: " << EnumColor::kRed << ", " << kGreen << ", "<< kBlue << std::endl;std::cout << "EnumClassColor: " << int(EnumClassColor::kRed) << ", "<< int(EnumClassColor::kGreen) << ", " << int(EnumClassColor::kBlue)<< std::endl;std::cout << "EnumClassColorType: " << int(EnumClassColorType::kRed) << ", "<< int(EnumClassColorType::kGreen) << ", "<< int(EnumClassColorType::kBlue) << std::endl;
}int main(int argc, char *argv[]) {Test();return 0;
}执行结果
| EnumColor: 0, 1, 2 |
10. constexpr
指定变量或函数的值可以在常量表达式中出现，必须初始化。字面类型是constexpr类型拥有的类型，且能通过constexpr函数构造、操作及返回它们。
#include <iostream>constexpr int Ret() { return 0; }
constexpr bool b2 = noexcept(Ret()); // true，f() 是常量表达式constexpr int Add() { return 10 + 20; }static constexpr char *COLOR[3]{"kRed", "kGreen", "kBlue"};void Test() {constexpr int NUM = 10;static constexpr int NUM2 = 20;static constexpr int const NUM3 = 30;static constexpr int const &NUM4 = 40;constexpr int ARR[2] = {0, 1};std::cout << "Add: " << Add() << std::endl; // 30
}int main(int argc, char *argv[]) {Test();return 0;
}11. 列表初始化
从花括号包围的初始化器列表列表初始化对象，默认std::initializer_list类为构造参数。C++98中，标准允许使用花括号{}对数组元素进行统一的列表初始值设定。C++98对于自定义类型，无法使用列表初始化。
#include <iostream>
#include <map>
#include <vector>struct A {A(int a, int b) {}private:int m_a;int m_b;
};void Test() {int arr1[5]{1, 2, 3, 4, 5};int arr2[]{1, 2, 3, 4, 5};int *arr3 = new int[5]{1, 2, 3, 4, 5}; // 动态数组，在C++98中不支持std::vector<int> v{1, 2, 3, 4, 5};std::map<int, int> m{{1, 1}, {2, 2}, {3, 3}, {4, 4}};delete[] arr3;int a = 1 + 3;int b = {1 + 3};int c{1 + 3};A d = {4, 5};A e{6, 7};
}int main(int argc, char *argv[]) {Test();return 0;
}12. 委托构造 & 继承构造
如果类自身的名字在初始化器列表中作为类或标识符 出现，那么该列表只能由这一个成员初始化器组成；这种构造函数被称为委托构造函数，而构造函数列表的仅有成员所选择的构造函数是目标构造函数。此时首先由重载决议选择目标构造函数并予以执行，然后控制返回到委托构造函数并执行其函数体。委托构造函数不能递归。
c++语言当中的继承关系，只有虚函数可以被继承，而构造函数不可以是虚函数，所以构造函数不能被继承，但是我们可以通过某种手段，达到继承效果
class A
{
public: A(char x, int y) {}A(int y) : A('a', y) {} // A(int) 委托到 A(char, int)
};#include <iostream>struct A {A(int a, int b, int c) {}
};struct B : A {using A::A;int m_a;
};void Test() {A a(1, 2, 3);B b(1, 2, 3); // 调用 A 构造函数， 未初始化 m_a// B c;
}int main(int argc, char *argv[]) {Test();return 0;
}13. nullptr
关键词 nullptr 代表指针字面量。它是std::nullptr_t类型的纯右值。存在从 nullptr 到任何指针类型及任何成员指针类型的隐式转换。同样的转换对于任何空指针常量也存在，空指针常量包括std::nullptr_t的值，以及宏 NULL。
#include <type_traits>
#include <iostream>#if defined(__linux__) || defined(__linux)
#include <cxxabi.h>
#define TYPE_NAME(var) abi::__cxa_demangle(typeid(var).name(), 0, 0, 0)
#else
#define TYPE_NAME(var) typeid(var).name()
#endifvoid Test() {std::nullptr_t ptr = nullptr;std::cout << "ptr type: " << TYPE_NAME(ptr) << std::endl;int *ptr2 = nullptr;std::cout << "ptr2 type: " << TYPE_NAME(ptr2) << std::endl;
}int main(int argc, char *argv[]) {Test();return 0;
}
执行输出
| ptr type: decltype(nullptr) ptr2 type: int* |
14. long long类型
long long - 目标类型将有至少 64 位的宽度。具体与平台架构实现相关，long类型规定大于等于32位宽度。
15. char16_t & char32_t
char16_t - UTF-16 字符表示的类型，要求大到足以表示任何 UTF-16 编码单元（16 位）。它与std::uint_least16_t具有相同的大小、符号性和对齐，但它是独立的类型。
char32_t - UTF-32 字符表示的类型，要求大到足以表示任何 UTF-32 编码单元（32 位）。它与std::uint_least32_t具有相同的大小、符号性和对齐，但它是独立的类型。
16. 类型别名
类型别名是指代先前定义的类型的名字(类似 typedef)。别名模版是指代一族类型的名字。
#include <iostream>
#include <string>
#include <type_traits>
#include <typeinfo>// 类型别名，等同于 typedef std::ios_base::fmtflags flags;
using flags = std::ios_base::fmtflags;
flags fl = std::ios_base::dec;// 类型别名，等同于 typedef void (*func)(int, int);
using func = void (*)(int, int);
void example(int, int) {}
func f = example;// 别名模板
template <class T> using ptr = T *;
ptr<int> x;// 用于隐藏模板形参的别名模版
template <class CharT>
using mystring = std::basic_string<CharT, std::char_traits<CharT>>;
mystring<char> str;// 别名模板可引入成员 typedef 名
template <typename T> struct Container { using value_type = T; };// 可用于泛型编程
template <typename ContainerType> void info(const ContainerType &c) {typename ContainerType::value_type T;std::cout << "ContainerType 是 `" << TYPE_NAME(typeid(decltype(c)).name())<< "`\n""value_type 是 `"<< typeid(T).name() << "`\n";
}// 用于简化 std::enable_if 语法的类型别名
template <typename T> using Invoke = typename T::type;template <typename Condition>
using EnableIf = Invoke<std::enable_if<Condition::value>>;template <typename T, typename = EnableIf<std::is_polymorphic<T>>>
int fpoly_only(T) {return 1;
}struct S {virtual ~S() {}
};int main() {Container<int> c;info(c); // Container::value_type 将在此函数中是 int// fpoly_only(c); // 错误：被 enable_if 禁止S s;fpoly_only(s); // OK：被 enable_if 允许
}执行结果
| ContainerType 是 `char const*` value_type 是 `i` |
17. 可变参模板
模板形参包是接受零个或更多个模板实参（非类型、类型或模板）的模板形参。函数形参包是接受零个或更多个函数实参的函数形参。至少有一个形参包的模板被称作变参模板。
#include <iostream>void tprintf(const char* format) // 基础函数
{std::cout << format;
}template<typename T, typename... Targs>
void tprintf(const char* format, T value, Targs... Fargs) // 递归变参函数
{for (; *format != '\0'; format++){if ( *format == '%' ){std::cout << value;tprintf(format + 1, Fargs...); // 递归调用return;}std::cout << *format;}
}int main()
{tprintf("% world% %\n", "Hello", '!', 123);
}执行结果
Hello world! 123 |
