1
2
3
4
5
6

Object() {}                          //默认构造函数
~Object() {}                         //析构函数
Object(const Object&) {}             //复制构造函数
Object(Object&&) {}                  //移动构造函数
Object& operator=(const Object&) {}    //赋值函数
Object& operator=(Object&&) {}        //移动赋值函数

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

  struct A {
    int a;
    int b;
    A(int a, int b) a(a),b(b) {};
  }

A a1 = {1, 2};        //1. 顺序初始化
A a2 = {.b=1, .a=2};  //2. c99，点+=
A a3 = {b:1, a:2};    //3. gcc，
A a4(1,2);            //4. 构造函数方式构造, 在函数栈上分配，函数结束后，自动调用析构函数释放；

A *a5 = new A(1,2);    //5. 在堆上分配A结构体，将结构体堆内存指针返回给a5，不会自动释放；

T global;        //T是我们的自定义类型，因为它是全局变量，所以首先零初始化，实际上进行的是默认初始化

void foo()
{
    T i;         //默认初始化
    T j{};       //值初始化(C++11)
    T k = T();   //值初始化
    T l = T{};   //值初始化(C++11)
    T m();       //函数声明

    new T;       //默认初始化
    new T();     //值初始化
    new T{};     //值初始化(C++11)
}

struct A
{
    T t;
    A() : t()    //t将值初始化
    {
        //构造函数
    }
};

struct B
{
    T t;
    B() : t{}    //t将值初始化(C++11)
    {
        //构造函数
    }
};

struct C
{
    T t;
    C()          //t将默认初始化
    {
        //构造函数
    }
};

1
2
3
4

class A {
  virtual void func1() {}   //普通虚函数
  virtual void func2() = 0;   //纯虚函数，子类必须实现基类的纯虚函数。
}

1
2

class base {}
class son:base{}

1

move() //操作符