1
void run() {
2
  A a;
3
  //A a2();这么写符合声明函数的语法，声明了一个：返回值是A类型，函数名是a2，参数列表是无参的
4
  A a3(25, 2);
5
}

1
void run() {
2
  A();//创建匿名对象
3
  A(2, 3);//用参数来创建匿名对象
4
}

1
void run() {
2
  A* p = new A();
3
  A* p2 = new A(int, int);
4
  A* p3 = new A[20];//创建数组
5
  delete p;
6
  delete p2;
7
  delete[] p3;//析构数组时，不delete会报错，准确来讲是有析构函数的数组必须delete[]
8
  //总之，数组delete[]一定不会错
9
}

1
class people {
2
private:
3
    int weight;
4
    int height;
5
    int age;
6
    string name;
7
    string bloodType;
8
public:
9
    //构造函数
10
    people() {
11
        cout << "调用了构造函数" << endl;
12
    }
13
    people(int weight) {
14
        this->weight = weight;
15
        cout << "体重为：" << endl;
16
    }
17
    people(int weight, int height, int age, string name, string bloodType) {
18
        this->weight = weight;
19
        this->height = height;
20
        this->age = age;
21
        this->name = name;
22
        this->bloodType = bloodType;
23
        cout << "姓名为：" << name << endl;
24
        cout << "体重为：" << weight << endl;
25
        cout << "年龄为：" << age << endl;
26
    }
27
    ~people() {
28
        cout << "调用了析构函数" << endl;
29
    }
30
};
31
int main() {
32
    //自定义类型只能用new不能用malloc
33
    //因为new会申请空间并且走构造函数，malloc只会申请空间
34
    people p(1, 2, 3, "asd", "A");//在栈区创建的对象，编译器会自动释放
35
    people *p1 = new people(99999);//在堆区创建的对象，需要手动释放，new会走malloc和构造函数
36
    delete p1;//delete和new是搭配的 delete会走析构函数和free
37
    return 0;
38
}

1
class A {
2
private:
3
    int n = 0;
4
    int *p = nullptr;//NULL 宏定义 0 nullptr 是空指针 void*
5
public:
6
    A(int _size) {
7
        if (_size > 0) {
8
            n = _size;
9
            p = (int*)malloc(sizeof(int)* n);
10
        }
11
    }
12
    //如果不加引用在通过实参创建形参的过程中，还会调用拷贝构造函数
13
    //还会有实参创建形参的过程导致无限循环该过程
14
    A (const A &other) {
15
        this->n = other.n;
16
        this->p = other.p;
17
        cout << "调用了拷贝构造函数" << endl;
18
    }
19
};
20
int main() {
21
    A a(1);
22
    A b(a);
23
    A c(3);
24
    c = b;//会走赋值运算符，把对象赋值给一个已经存在的实例
25
    cout << "-----------------" << endl;
26
    A d = c;//用对象初始化对象会走拷贝构造函数
27
    return 0;
28
}

1
class grandFather {
2
public:
3
  int a;
4
};
5
class father:virtual public grandFather {
6
public:
7
};
8
class mather:virtual public grandFather {
9
};
10
class child:public father, public mather {
11
public:
12
};

1
class father {
2
public:
3
  virtual void fun() {//虚函数
4
  }
5
}

1
//多态：父类指针指向子类对象：父类指针动态的调用子类对象里面的重写函数
2
class duck {//纯虚类(抽象类) 作为基类
3
  string country;
4
  string color;
5
  int weight;
6
public:
7
  virtual void Swimming() = 0;
8
  void Lay_eggs() {
9
    cout << "下蛋嘿嘿嘿" << endl;
10
  }
11
};
12
class psyduck:public duck {//可达鸭
13
public:
14
  virtual void Swimming() {
15
    cout << "可达鸭会玩铁男但是不会游泳" << endl;
16
  };
17
  void Lay_eggs() {
18
    cout << "可达鸭下单嘿嘿嘿" << endl;
19
  }
20
};
21
class ugly_duckling:public duck {//丑小鸭
22
public:
23
  virtual void Swimming() {
24
    cout << "会游泳但是不会打联盟" << endl;
25
  };
26
};
27
class Roasted_Duck:public duck {//烤鸭
28
public:
29
  virtual void Swimming() {
30
    cout << "烤鸭不会游泳，但是香" << endl;
31
  };
32
};
33
int main() {
34
  //通过父类指针指向不同的子类对象，父类指针动态的去调用子类对象中重写的函数
35
  ugly_duckling *d = new ugly_duckling();
36
  d->Swimming();
37
  d->Lay_eggs();
38
  cout << endl;
39

40
  Roasted_Duck *d1 = new Roasted_Duck();
41
  d1->Swimming();
42
  d1->Lay_eggs();
43
  cout << endl;
44

45
  psyduck *d2 = new psyduck();
46
  d2->Swimming();
47
  d2->Lay_eggs();
48
  //函数隐藏，子类中只需要函数名和父类中的函数名相同就会发生函数隐藏
49
  //函数隐藏具体执行父类中的同名函数还是子类中的同名函数，看调用这个函数的类型
50
  return 0;
51
}

1
#include<queue>//使用前要先添加头文件
2
que.push(i);//把i放进优先级队列里
3
que.pop();//弹出堆顶元素
4
que.top();//获取堆顶元素但不弹出
5
que.size();//优先级队列中元素个数
6
que.empty();//判断优先级队列是否为空，如果为空返回1，不为空返回0

1
stack<int> s;//定义 stack<数据类型> 名称;
2
s.push();//入栈 将元素放到栈顶
3
s.top();//获取栈顶元素
4
s.pop();//弹出栈顶元素
5
s.empty();//判断栈是否为空 为空返回1 不为空返回0
6
s.size();//返回栈中元素个数

1
queue<string> q;//定义 queue<数据类型> 名称;
2
q.push("Hello, World!");//队列先进先出 所以push是向队尾放元素
3
q.pop();//弹出队首元素 即最前面那个
4
q.size();//返回队列元素个数 返回类型为unsigned int
5
q.empty();//判断是否为空 空返回1 不空返回0
6
q.front();//返回队首元素
7
q.back();//返回队尾元素

1
#include<stack>//栈 先进后出
2
#include<queue>//队列 先进先出
3
int main() {
4
    stack<int> stk;//栈里面放的元素类型是int
5
    stk.push(1);
6
    stk.push(2);
7
    stk.push(3);
8
    stk.push(4);
9
    stk.push(5);
10
    while (!stk.empty()) {
11
        cout << "栈顶元素" << stk.top() << endl;
12
        stk.pop();
13
    }
14
    queue<int> que;
15
    for (int i = 0; i < 4; ++i) {
16
        que.push(i);
17
    }
18
    while (!que.empty()) {
19
        cout << "队列的首元素：" << que.front() << "队列的尾元素：" << que.back() << endl;
20
        que.pop();
21
    }
22
    return 0;
23
}

1
#pragma once
2
//.h文件声明类中的函数，结构体变量等
3
#include<iostream>
4
#include<vector>
5
using namesapce std;
6
//结构体和类使一样的，只是默认访问权限不同
7
struct Node {//链表的节点
8
    int val;//数据域
9
    Node* next;//指针域：存放下一个节点的地址
10
    Node (int val) {
11
        this->val = val;
12
        next = nullptr;
13
    }
14
};
15
class List {
16
private:
17
    Node *Head = nullptr;//头节点 链表中第一个节点帮助访问整个链表
18
    Node *Tail = nullptr;//尾节点 链表中最后一个节点帮助插入节点
19
public:
20
    List (vector<int> vec);
21
    Node *GetListHead();
22
    void PrintList();
23
    void DeleteNode(int val);
24
    void AddNode(int val, int newVal);//在节点值等于val的后面增加一个新节点 例如在2后买你加val值为0的节点
25
};