1 explicit

explicit 的意思是清楚的，明显的。一般用在类的构造函数中，防止隐式转换。

explicit specifier - cppreference.com

如下代码，

(1) 类 A 的两个构造函数都没有使用 explicit 修饰，所以如下两行代码，隐式转换，是允许的  

A a1 = 1;
A a4 = {4, 5};

(2) 类 B 的两个构造函数都使用 explicit 修饰了，不允许隐式构造，所以下边两行代码编译不通过

B b1 = 1;
B b4 = {4, 5};

(3) 类 B，如下代码，使用强制类型转换，是可以的。

B b5 = (B)1;

#include <iostream>
#include <string>

class A
{
public:
    A(int) { }      // converting constructor
    A(int, int) { } // converting constructor (C++11)
};

class B
{
public:
    explicit B(int) { }
    explicit B(int, int) { }
};

int main()
{
    A a1 = 1;      // OK: copy-initialization selects A::A(int)
    A a2(2);       // OK: direct-initialization selects A::A(int)
    A a3 {4, 5};   // OK: direct-list-initialization selects A::A(int, int)
    A a4 = {4, 5}; // OK: copy-list-initialization selects A::A(int, int)
    A a5 = (A)1;   // OK: explicit cast performs static_cast

    // B b1 = 1;      // error: copy-initialization does not consider B::B(int)
    B b2(2);       // OK: direct-initialization selects B::B(int)
    B b3(4, 5);   // OK: direct-list-initialization selects B::B(int, int)
    // B b4 = {4, 5}; // error: copy-list-initialization does not consider B::B(int, int)
    B b5 = (B)1;   // OK: explicit cast performs static_cast
    return 0;
}

2 delete

指定某个函数禁用。

在单例模式中，一个类只允许创建一个对象，同时也不允许这个类进行拷贝构造或者对象之间进行赋值。怎么做到不让类进行拷贝构造，以及不让对象之间进行赋值呢，这个时候就可以使用 delete 来修饰拷贝构造函数和赋值运算符。

如果在代码中使用了禁用的函数，那么编译的时候会报错。

#include <iostream>
#include <mutex>
 
class Test {
public:
  static Test *GetInstance() {
    std::lock_guard<std::mutex> lock(mtx);
    if (instance == nullptr) {
      instance = new Test();
      return instance;
    }
    return instance;
  };
 
  Test(const Test &) = delete;
  Test &operator=(const Test &) = delete;
 
  ~Test() {
    std::cout << "~Test()" << std::endl;
  };
 
  class Recycler {
  public:
    ~Recycler() {
      if (Test::instance) {
        delete Test::instance;
      } else {
        std::cout << "no need to recycle" << std::endl;
      }
    }
  };
  static Recycler recycler;
 
  void Do() {
    std::cout << "Do()" << std::endl;
  }
 
private:
  static Test *instance;
  static std::mutex mtx;
  Test() {
    std::cout << "Test()" << std::endl;
  };
};
 
Test *Test::instance = nullptr;
std::mutex Test::mtx;
Test::Recycler recycler;
 
void TestDo(Test test) {
  test.Do();
}
 
int main() {
  Test *test = Test::GetInstance();
  test->Do();
  return 0;
}

3 default

这个关键字和 c++ 编译器默认生成的函数有关系。如果定义了一个空类，那么 c++ 编译器会默认生成构造函数，析构函数，拷贝构造函数，拷贝赋值运算符，取地址运算符，取值运算符，移动拷贝构造函数，移动赋值运算符。

以构造函数为例，如果我们自己没有定义构造函数，那么编译器会默认生成一个无形参的构造函数；如果我们定义了有形参的构造函数，那么编译器就不会生成默认无形参的构造函数了。而默认的构造函数在某些使用场景下也会用到，这个时候我们就不需要自己定义一个这样的构造函数，而是使用 default 关键字来提醒编译器，虽然我自己写了有参数的构造函数，但是也让编译器生成默认构造函数。

如下代码，如果不将 Test() 声明为 default，那么在 main() 函数中的 Test t1 这行代码便会导致编译错误。

#include <iostream>
#include <string>

class Test {
public:
  Test() = default;
  Test(std::string str) {
    std::cout << "Test(), str = " << str << std::endl;;
  }
};

int main() {
  Test t1;
  Test t2("hello");
  return 0;
}

自己定义的构造函数需要和 default 构造函数形成重载，不能定义一个和 default 构造函数一样的构造函数，这样是不允许的，比如下边的代码。

#include <iostream>
#include <string>

class Test {
public:
  Test() = default;
  Test() {
    std::cout << "Test()" << std::endl;;
  }
};

int main() {
  Test t1;
  return 0;
}

4 override

显式指定，覆写。

（1）override 可以显式的说明函数覆盖了基类中的虚函数，增加了可读性。对于虚函数来说，即使不使用 override 指定，子类也可以覆写基类中的虚函数

（2）对于非虚函数来说，派生类不能覆写父类的同名函数，使用 override 编译时会报错

#include <iostream>
#include <string>

class Base {
public:
  virtual void Do() {
    std::cout << "Base() Do()\n";
  }

  void Do1() {
    std::cout << "Base() Do1()\n";
  }
};

class Derived : public Base {
public:
  virtual void Do() override {
    std::cout << "Derived() Do()\n";
  }

  // 非虚函数，不能使用 override
  // 派生类也无法覆写父类的同名函数
  void Do1() /* override */ {
    std::cout << "Derived() Do1()\n";
  }
};

int main() {
  Base *b = new Derived;
  b->Do();
  b->Do1();
  return 0;
}

5 final

（1）修饰类，说明这个类不能被继承

（2）非虚函数，不能使用 final 来修饰。因为非虚函数，本身就具有 final 的性质，派生类不能覆写基类中的非虚函数

（3）修饰虚函数，派生类中不能覆写

#include <iostream>
#include <string>

class Base {
public:
  virtual void Do1() {
    std::cout << "Base() Do1()\n";
  }

  virtual void Do2() final {
    std::cout << "Base() Do2()\n";
  }
};

class Derived1 final : public Base {
public:
  virtual void Do1() override {
    std::cout << "Derived1() Do1()\n";
  }

  virtual void Do2() {
    std::cout << "Derived1() Do2()\n";
  }
};

class Derived2 : public Derived1 {
public:
  virtual void Do1() {
    std::cout << "Derived2() Do1()\n";
  }

  virtual void Do2() final {
    std::cout << "Derived2() Do2()\n";
  }
};

int main() {
  Base *b1 = new Derived1;
  Base *b2 = new Derived2;
  b1->Do1();
  b2->Do1();
  return 0;
}

编译报错：

6 noexcept

这个函数不会抛异常，当这个函数出现异常的时候不会向上抛，而是进程被 std::terminate 杀掉。

（1）Do1() 使用 noexcept 修饰，那么函数中抛异常的时候，不会抛给上一级函数，会直接被 std::terminate 杀掉

（2）Do2() 使用 noexcept(true) 修饰，作用和直接使用 noexcept 修饰相同，函数内的异常不会抛给上一级函数，会直接被 std::terminate 杀掉

（3）Do3() 没有被 noexcept 修饰，函数中抛出的异常，可以抛给上一级函数

（4）Do4() 被 noexcept(false) 修饰，函数中抛出异常，可以抛给上一级函数

#include <iostream>
#include <string>

void Do1() noexcept {
  throw "Do1 exception";
}

void Do2() noexcept(true) {
  throw "Do2 exception";
}

void Do3() {
  throw "Do3 exception";
}

void Do4() noexcept(false) {
  throw "Do4 exception";
}

int main(int argc, char *argv[]) {
  if (argc != 2) {
    std::cout << "argc is not 2\n";
    return 0;
  }

  printf("argv[1] = %s\n", argv[1]);
  try {
    if (argv[1][0] == '1') {
      std::cout << "call Do1()\n";
      Do1();
    } else if (argv[1][0] == '2') {
      std::cout << "call Do2()\n";
      Do2();
    } else if (argv[1][0] == '3') {
      std::cout << "call Do3()\n";
      Do3();
    } else {
      std::cout << "call Do4()\n";
      Do4();
    }
  } catch (const char *e) {
    std::cout << "exception: " << e << std::endl;
  }
  return 0;
}