类的形式

class Rectangle {
    int width, height;
  public:
    void set_values (int x,int y);
    int area() {return width*height;}
};

构造函数

class Rectangle {
  public:
    Rectangle() 
    {
        cout << "无参构造函数调用\n";
    }
    Rectangle(int a, int b) 
    {
        cout << "有参构造函数调用\n";
    }
};

int main () {
    Rectangle rect1; // 无参构造
    Rectangle rect1{}; // 无参构造
    Rectangle rest(); //函数声明
    Rectangle rect2(1, 2);

    Rectangle * a = new Rectangle; // 无参构造
    Rectangle * b = new Rectangle();// 无参构造
    Rectangle * c = new Rectangle{};// 无参构造
    Rectangle * d = new Rectangle(1, 2);// 有参构造
    Rectangle * e = new Rectangle{1, 2};// 有参构造

  return 0;
}

比较易混淆的点：

class Rectangle {
  public:
    Rectangle()  // 使用了带默认值的有参构造，无参构造函数应该删除
    {
        cout << "无参构造函数调用\n";
    }
    Rectangle(int a = 3) 
    {
        cout << "有参构造函数调用\n";
    }
};

如果只有有参构造，则需要自定义无参构造

类的初始化

    Rectangle rect2{1, 2};
    Rectangle rect3(1, 2);
    Rectangle rect4 = {1, 2};
    Rectangle rect5 = Rectangle(1, 2);

运算符重载

class  Vec{
public:
    Vec() {};
    Vec(int x, int y) : x{x}, y{y} {};

    Vec operator+(const Vec & other)
    {
        std::cout << "成员";
        return Vec(x + other.x, y + other.y);
    }

    friend Vec operator+ (const Vec& lhs, const Vec& rhs);
    void print()
    {
        std::cout << "x: " << x << ", y: " << y << " \n";
    }

private:
    int x, y;
};

拷贝构造函数和拷贝赋值函数

class  Vec{
public:
    Vec() {};
    Vec(int x, int y) : x{x}, y{y} { std::cout << "默认构造函数调用\n"; };

    Vec(const Vec&)
    {
        std::cout << "拷贝构造函数调用\n";
    }

    Vec& operator= (const Vec&)
    {
        std::cout << "拷贝赋值调用\n";
        return *this;
    }
    void print()
    {
        std::cout << "x: " << x << ", y: " << y << " \n";
    }

private:
    int x, y;
};

int main()
{
    Vec a{1, 2};
    Vec b{3, 4};
    Vec c(a); // 拷贝构造函数调用
    Vec d = a; // 拷贝构造函数调用
    d = c; // 拷贝赋值函数调用

    return 0;
}

移动构造和移动赋值

class  Vec{
public:
    Vec() {};
    Vec(int x, int y) : x{x}, y{y} { std::cout << "默认构造函数调用\n"; };
    Vec (Vec&& a)
    {
        std::cout << "调用移动构造函数\n";
    }

    Vec& operator= (Vec&& a)
    {
        std::cout << "移动赋值调用\n";
        return *this;
    } 
private:
    int x, y;
};

Vec get()
{
    Vec t(1, 2);
    return t;
}
int main()
{
    Vec a{1, 2};
    Vec b{3, 4};
    Vec c(std::move(a)); // 调用移动构造函数
    Vec c = std::move(a); // 调用移动构造函数
    Vec d;
    d = std::move(c);  // 调用移动赋值函数
    return 0;
}

由于RVO（返回值优化），默写情况下移动构造函数不会调用，例如

Vec c = get(); // 这里get返回的是一个Vec实例
Vec d;
d = get(); // 这里会调用移动赋值

但是函数返回值可以调用移动赋值