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
    A (const A &other) {//深拷贝
14
        this->n = other.n;
15
        p = (int *)malloc(sizeof(int)* n);
16
        cout << "调用了拷贝构造函数" << endl;
17
    }
18
    ~A () {
19
        if (p != nullptr) {
20
            free(p);
21
            cout << "调用了析构函数释放了堆区空间" << endl;
22
        }
23
    }
24
};
25
int main() {
26
    A a(1);
27
    A b(a);
28
    return 0;
29
}

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
    A (const A &other) {//浅拷贝
13
        this->n = other.n;
14
        this->p = other.p;
15
        cout << "调用了拷贝构造函数" << endl;
16
    }
17
    ~A () {
18
        if (p != nullptr) {
19
            free(p);
20
            cout << "调用了析构函数释放了堆区空间" << endl;
21
        }
22
    }
23
};
24
int main() {
25
    A a(1);
26
    A b(a);
27
    return 0;
28
}

1
class father {
2
public:
3
  virtual void fun() {//虚函数
4
  }
5
  father() {
6
    cout << "father的构造函数" << endl;
7
  }
8
  ~father() {
9
    cout << "father的析构函数" << endl;
10
  }
11
};
12
class child:public father {
13
public:
14
  child() {
15
    cout << "child的构造函数" << endl;
16
  }
17
  ~child() {
18
    cout << "child的析构函数" << endl;
19
  }
20
}

1
class father {//抽象类(纯虚类)
2
public:
3
  virtual void fun() = 0;//纯虚函数
4
  father() {
5
    cout << "father的构造函数" << endl;
6
  }
7
  ~father() {
8
    cout << "father的析构函数" << endl;
9
  }
10
};
11
class child:public father {
12
public:
13
  child() {
14
    cout << "child的构造函数" << endl;
15
  }
16
  void fun() {
17
    cout << "子类的fun" endl;
18
  }
19
  ~child() {
20
    cout << "child的析构函数" << endl;
21
  }
22
};

1
#include<iostream>
2
#include<queue>
3
using namespace std;
4
int main()
5
{
6
  priority_queue<int,vector<int>,greater<int> > q;
7
  q.push(3);     //入队
8
  q.push(5);
9
  q.push(1);
10
  cout<<q.top()<<endl;     //获取队首元素
11
  return 0;
12
}

1
// 使用friend其排序与sort排序刚好相反
2
struct node
3
{
4
  string name;
5
  int price;
6
  //friend bool operator<(const node &f1,const node &f2)
7
  //建议使用上面的引用来提高效率
8
  friend bool operator<(node f1,node f2)
9
  {
10
    return f1.price<f2.price;
11
  }
12
};
13
priority_queue<node> q;
14
// 不使用 friend 友元将它写在外面
15
struct node
16
{
17
  string name;
18
  int price;
19
};
20
struct cmp
21
{
22
  bool operator() (node f1,node f2)
23
  {
24
    return f1.price>f2.price;
25
  }
26
 }
27
priority_queue<node,vector<node>,cmp>;

1
priority_queue<int, vector<int>, greater<int>> que;//最小堆
2
priority_queue<int> q;//默认优先级队列
3
for (int i = 0; i < 5; ++i) {
4
    que.push(i);
5
}
6
que.pop();//弹出堆顶元素
7
cout << que.top() << endl;//获取堆顶元素但不弹出
8
que.size();//优先级队列中元素个数
9
que.empty();//判断优先级队列是否为空，如果为空返回1 不为空返回0
10
priority_queue<int, vector<int>, less<int>> que2;//最大堆
11
que.push(6);
12
que.push(1);
13
que.push(8);
14
que.push(2);
15
que.push(7);
16
cout << que.size() << endl;
17
cout << "堆顶元素" << que.top() << endl;
18
que.pop();
19
cout << "移除堆顶元素后" << endl;
20
cout << que.top << endl;
21
cout << "优先级队列是否为空" << que.empty() << endl;

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
    Node* FindNode(int val);//查找节点值为val的节点并且返回节点的地址 例如查找0
26
};

1
//.cpp实现.h中的声明
2
#include"List.h"
3
List::List(vector<int> vec) {
4
    //用vec初始化链表
5
    Node* node = nullptr;
6
    for (int i = 0; i < vec.size(); ++i) {
7
        node = new Node(vec[i]);//通过节点的构造函数创建新的节点
8
        if (Head == nullptr) {//链表中还没有节点，新的节点就是链表的头节点并且也是链表的尾节点
9
            Head = node;
10
            Tail = node;
11
        }
12
        else {//否则链表已经有节点了，只需要向链表尾部(Tail)去添加节点并且更新Tail
13
            Tail->next = node;
14
            Tail = Tail->next;
15
        }
16
    }
17
}
18
Node* List::GetListHead() {
19
    return Head;
20
}
21
void List::PrintList() {
22
    Node* p = Head;
23
    while (p != nullptr) {
24
        cout << p->val << " ";
25
        p = p->next;
26
    }
27
}
28
void List::DeleteNode(int val) {
29
    //删除节点值等于val的第一个节点
30
    //遍历链表 找到要删除的节点
31
    //找到要删除的节点之后，判断当前节点是不是头节点
32
      //如果是头节点 Head = Head->next;
33
      //如果不是头节点 p的前驱节点的next 等于p->next
34
    //delete p;
35
    Node* p = Head;
36
    Node* pre = nullptr;
37
    while (p != nullptr) {
38
        if (p->val == val) {
39
            if (p == Head) {
40
                Head = Head->next;
41
            } else {
42
                pre->next = p->next;
43
            }
44
            delete p;
45
            p = nullptr;//防止野指针
46
            return;
47
        }
48
        //如果p不是要删除的节点
49
        pre = p;//记录p的前驱节点
50
        p = p->next;
51
    }
52
}
53
void List::AddNode(int val, int newVal) {
54
    Node* p = Head;
55
    Node* newNode = new Node(newVal);
56
    while (p != nullptr) {
57
        if (p->val == val) {
58
            newNode->next = p->next;
59
            p->next = newNode;
60
        }
61
        p = p->next;
62
    }
63
}
64
Node* List::FindNode(int val) {
65
    Node* p = Head;
66
    while (p != nullptr) {
67
        if (p->val == val) {
68
            return p;
69
        }
70
        p = p->next;
71
    }
72
    return nullptr;
73
}

1
#include<iostream>
2
#include<unordered_map>
3
#include<map>
4

5
using namespace std;
6
int main() {
7
    unordered_map<int, int> p;
8
    p.insert(make_pair(3, 3));
9
    p.insert(make_pair(1, 2));
10
    unordered_map<int, int>::iterator it = p.begin();
11
    p[1] = 4;
12
    p[5] = 5;//既可以插入又可以修改 慎用
13
    if (p.find(3) != p.end()) {
14
        cout << p.find(3)->first << p.find(3)->second << endl;
15
    }
16
    for (;it != p.end(); it++) {
17
        cout << it->first << " " << it->second << endl;
18
    }
19
    map<int, int> _map;
20
    _map[1] = 1;
21
    _map[0] = 0;
22
    _map[3] = 3;
23
    map<int, int>::iterator it_map = map.begin();
24
    for (;it_map != _map.end(); it_map++) {
25
        cout << it_map->first << " " << it_map->second << endl;
26
    }
27
}