C++ 中类的构造方法

#include <iostream>
#include <string>

class C {
private:
  std::size_t n = 0;
  std::string s = "Hello";
public:
  // 默认构造函数：当声明对象如 C c 或调用默认构造函数如 C() 时调用
  C() { std::cout << "Default constructor." << *this << std::endl; }
  // 一个参数的构造函数
  C(std::size_t n_): n(n_) {
    n = 2;
    std::cout << "Constructor with one argument." << *this << std::endl;
  }
  // 两个参数的构造函数，冒号后使用了初始化参数列
  C(std::size_t n_, std::string s_): n(n_), s(s_) {
    std::cout << "Constructor with two arguments." << *this << std::endl;
  }
  // 拷贝构造函数
  C(C const& c) {
    n = c.n;
    s = c.s;
    std::cout << "Copy constructor." << *this << std::endl;
  }
  // 赋值
  C& operator= (C const& rhs) {
    n = rhs.n;
    s = rhs.s;
    std::cout << "Assignment." << *this << std::endl;
    return *this;
  }
  friend std::ostream& operator<< (std::ostream& os, C const& c) {
    return os << " n: " << c.n << ", s: " << c.s;
  }
};

int main() {
  // 调用默认构造函数，第二种方法会生成一个匿名局部变量
  std::cout << "Construct c1: ";
  C c1;
  std::cout << "Construct C(): ";
  C();

  // 调用拷贝构造函数，以下两种方式等价
  std::cout << "Construct c2: ";
  C c2(c1);
  std::cout << "Construct c3: ";
  C c3 = c1;
  std::cout << "Construct C4 with C(): ";
  C c4 = C(); // 从语法看会进行一次默认构造和一次拷贝构造，C() 生成临时对象一次
              // 默认构造，用临时变量拷贝构造 c4 一次，实际只有一次默认构造

  // 调用两个参数的构造函数，以下四种方式等价。此处需要注意的是成员初始化的先后
  // 顺序，最先发生的是声明成员时的初始化，然后是构造函数的初始化参数列，最后是
  // 构造函数内部的赋值
  std::cout << "Construct c5: ";
  C c5(1, "world");
  std::cout << "Construct c6: ";
  C c6{1, "world"};
  std::cout << "Construct c7: ";
  C c7 = {1, "world"};
  std::cout << "Construct C(1, \"world\"): ";
  C(1, "world");

  // 调用一个参数的构造函数，以下两种方法等价。第二种方法说明当只有一个参数时可
  // 省略花括号，此时会隐式地用参数 1 去构造 C（也就是说对应的构造函数必须不为
  // explicit 的），也说明为什么 std::string s = "world"是合法的，即等价于
  // std::string s{"world"}
  std::cout << "Construct c8: ";
  C c8 = {1};
  std::cout << "Construct c9: ";
  C c9 = 1;

  // 此处并没有发生构造，只是用 c4 给 c1 赋值
  std::cout << "Assignment c4 with c1: ";
  c4 = c1;
}