c++各种总结（更新中）

#include <bits/stdc++.h>
c++编写细节！！！：
字符串数字互相转换：
c++ 字符串转为数字（str to int)———stoi
c++ 数字转字符串——to_string

定义一个新指针需要手动初始化： Node* ptr = new node;或者使它指向现有的内存：Node* ptr = pre;否则会运行报错。
声明一个指针变量并不会自动分配任何的内存，对指针执行间接访问前，指针必须初始化：或者使它指向现有的内存，或者为其分配动态内存。
定义一个指针时，如果不进行初始化，系统会为这个变量自动分配一个地址，这个地址的值就是指针的值可能为0Xxxxxxxxx,不初始化这个指针的值的话，操作这个指针就想当于操作这个0Xxxxxxxxx这个地方的内容，就会出现问题，因为你并不知道这个指针指向地址的内容，可能为段系统代码，错改的话，可能会让系统崩溃。

栈
创建：
stack<int(数据类型)> s;
操作：
s.push(item); //将item压入栈顶
s.pop(); //删除栈顶的元素，但不会返回
s.top(); //返回栈顶的元素，但不会删除
s.size(); //返回栈中元素的个数
s.empty(); //检查栈是否为空，如果为空返回true，否则返回false

队列
queue q;
操作：
q.push(item) //将item压入队列尾部
q.pop() //删除队首元素，但不返回
q.front() //返回队首元素，但不删除
q.back() //返回队尾元素，但不删除
q.size() //返回队列中元素的个数
q.empty() //检查队列是否为空，如果为空返回true，否则返回false

哈希表
unordered_map<int,int> Hashmap;
建立迭代器
unordered_map<int,int>::iterator it;
哈希表操作：
1.插入键值对
insert函数
Hashmap.insert(make_pair<int,int>(1,3));
Hashmap.insert(make_pair(1,3));
以上两种皆可
2.通过键添加
Hashmap[3]=1;
3.其他函数
it = Hashmap.begin() //指向哈希表的第一个容器
it = Hashmap.end() //指向哈希表的最后一个容器，实则超出了哈希表的范围，为空
Hashmap.size() //返回哈希表的大小
Hashmap.empty() //判断哈希表是否为空，返回值为true/false
Hashmap.clear() //清空哈希表
4.通过key值查找键值对
it = Hashmap.find(2) //查找key为2的键值对是否存在 ,若没找到则返回Hashmap.end()
if(Hashmap.find(2)!=Hashmap.end()) //判断找到了key为2的键值对
5.通过key值查找该key值下的键值对对数
Hashmap.count(1) //返回 1
6.swap交换两个Hashmap的键值对
Hashmap1.swap(Hashmap2);
swap(Hashmap1,Hashmap2);

向量
vector
创建:
(1) vector a(10); //定义了10个整型元素的向量（尖括号中为元素类型名，它可以是任何合法的数据类型），但没有给出初值，其值是不确定的。
（2）vector a(10,1); //定义了10个整型元素的向量,且给出每个元素的初值为1
（3）vector a(b); //用b向量来创建a向量，整体复制性赋值
（4）vector a(b.begin(),b.begin+3); //定义了a值为b中第0个到第2个（共3个）元素
（5）int b[7]={1,2,3,4,5,9,8};
vector a(b,b+7); //从数组中获得初值
操作：
（1）a.assign(b.begin(), b.begin()+3); //b为向量，将b的0~2个元素构成的向量赋给a
（2）a.assign(4,2); //是a只含4个元素，且每个元素为2
（3）a.back(); //返回a的最后一个元素
（4）a.front(); //返回a的第一个元素
（5）a[i]; //返回a的第i个元素，当且仅当a[i]存在2013-12-07
（6）a.clear(); //清空a中的元素
（7）a.empty(); //判断a是否为空，空则返回ture,不空则返回false
（8）a.pop_back(); //删除a向量的最后一个元素
（9）a.erase(a.begin()+1,a.begin()+3); //删除a中第1个（从第0个算起）到第2个元素，也就是说删除的元素从a.begin()+1算起（包括它）一直到a.begin()+ 3（不包括它）
（10）a.push_back(5); //在a的最后一个向量后插入一个元素，其值为5
（11）a.insert(a.begin()+1,5); //在a的第1个元素（从第0个算起）的位置插入数值5，如a为1,2,3,4，插入元素后为1,5,2,3,4
（12）a.insert(a.begin()+1,3,5); //在a的第1个元素（从第0个算起）的位置插入3个数，其值都为5
（13）a.insert(a.begin()+1,b+3,b+6); //b为数组，在a的第1个元素（从第0个算起）的位置插入b的第3个元素到第5个元素（不包括b+6），如b为1,2,3,4,5,9,8 ，插入元素后为1,4,5,9,2,3,4,5,9,8
（14）a.size(); //返回a中元素的个数；
（15）a.capacity(); //返回a在内存中总共可以容纳的元素个数
（16）a.resize(10); //将a的现有元素个数调至10个，多则删，少则补，其值随机
（17）a.resize(10,2); //将a的现有元素个数调至10个，多则删，少则补，其值为2
（18）a.reserve(100); //将a的容量（capacity）扩充至100，也就是说现在测试a.capacity();的时候返回值是100.这种操作只有在需要给a添加大量数据的时候才 显得有意义，因为这将避免内存多次容量扩充操作（当a的容量不足时电脑会自动扩容，当然这必然降低性能）
（19）a.swap(b); //b为向量，将a中的元素和b中的元素进行整体性交换
（20）a==b; //b为向量，向量的比较操作还有!=,>=,<=,>,<

C++的 reverse函数被包含在头文件：#include 中。

可以对数组、字符串、vector容器中的元素进行翻转操作。

字符串和vector容器：

翻转操作挺常规的：reverse(str.begin(), str.end()); reverse(vec.begin(), vec.end());
reverse_copy函数和reverse函数的唯一区别在于：reverse_copy会将结果拷贝到另外一个容器中，不影响原容器的内容
reverse左闭右开

sort(first,last)

switch (IntegerExpression)
{
case ConstantExpression:
//在这里放置一个或多个语句
case ConstantExpression:
//在这里放置一个或多个语句

//case可被重复多次

default:
    //在这里放置一个或多个语句

}

双向队列:
deque。

void TestPriorityQueue()
{
// 默认情况下，创建的是大堆，其底层按照小于号比较
vector v{ 3, 2, 7, 6, 0, 4, 1, 9, 8, 5 };
priority_queue q1;// 构建优先级队列
for (auto e : v)
q1.push(e);//尾插
cout << “q1中元素个数:” << q1.size() << endl;
for (size_t i = 0;i<v.size();++i)
{
cout << q1.top() << " ";//输出栈顶的数据
q1.pop();//尾删
}
cout << endl;
cout << “q1中元素个数:” << q1.size() << endl;
cout << endl;
// 如果要创建小堆，将第三个模板参数换成greater比较方式
priority_queue<int, vector, greater> q2(v.begin(), v.end());
for (size_t i = 0; i<v.size(); ++i)
{
cout << q2.top() << " ";//输出栈顶的数据
q2.pop();//尾删
}
cout << endl;
}

四种强制类型转换：
https://www.cnblogs.com/JhonKing/p/5600816.html
父类指针指向子类对象：
https://blog.csdn.net/weixin_42814000/article/details/105723962

1.3.3 简述一下 C++ 的重载和重写，以及它们的区别
参考回答

重写

是指派生类中存在重新定义的函数。其函数名，参数列表，返回值类型，所有都必须同基类中被重写的函数一致。只有函数体不同（花括号内），派生类对象调用时会调用派生类的重写函数，不会调用被重写函数。重写的基类中被重写的函数必须有virtual修饰。

示例如下：

#include<bits/stdc++.h> using namespace std; class A { public: virtual void fun() { cout << “A”; } }; class B :public A { public: virtual void fun() { cout << “B”; } }; int main(void) { A* a = new B(); a->fun();//输出B，A类中的fun在B类中重写 }
重载

我们在平时写代码中会用到几个函数但是他们的实现功能相同，但是有些细节却不同。例如：交换两个数的值其中包括（int, float,char,double)这些个类型。在C语言中我们是利用不同的函数名来加以区分。这样的代码不美观而且给程序猿也带来了很多的不便。于是在C++中人们提出了用一个函数名定义多个函数，也就是所谓的函数重载。函数重载是指同一可访问区内被声明的几个具有不同参数列（参数的类型，个数，顺序不同）的同名函数，根据参数列表确定调用哪个函数，重载不关心函数返回类型。

重定义（隐藏）：
函数重定义是什么
（1）不在同一个作用域（分别位于派生类与基类） ；
（2）函数名字相同；
（3）返回值可以不同；
（4）参数不同。此时，不论有无 virtual 关键字，基类的函数将被隐藏（注意别与重载以及覆盖混淆）；
（5）参数相同，但是基类函数没有 virtual关键字。此时，基类的函数被隐藏（注意别与覆盖混淆）；

#include<bits/stdc++.h> using namespace std; class A { void fun() {}; void fun(int i) {}; void fun(int i, int j) {}; void fun1(int i,

引用和指针的区别：

“指针指向一块内存，它的内容是所指内存的地址；而引用则是某块内存的别名，引用不改变指向。”
C语言程序生成.exe文件的过程可以分为四个阶段：预处理、编译、汇编和链接。

1. 预处理（Preprocessing）

预处理是C语言程序生成可执行文件的第一步。在这个阶段，预处理器根据程序员在源代码中定义的一些预处理指令（如“#include”和“#define”等）对源代码进行预处理。

预处理器的主要任务包括：

• 将源代码中的注释删除；

• 展开宏定义；

• 包含头文件；

• 进行条件编译。

在这个阶段结束后，预处理器将生成一个扩展名为.i的中间文件，它包含了所有预处理后的源代码。这个中间文件将作为下一个阶段的输入。

2. 编译（Compilation）

在预处理结束后，接下来的任务是将预处理后的源代码编译成汇编代码。编译器根据预处理后的中间文件创建一个代表源代码的汇编代码（扩展名为.asm或.s的文件）。

编译器主要执行以下步骤：

• 词法分析：将源代码分解成基本词汇单元（如标识符、关键字、操作符等）；

• 语法分析：根据C语言的语法规则检查词汇单元，并生成抽象语法树；

• 语义分析：检查程序的一致性和逻辑，例如变量的声明和类型检查；

• 中间代码生成：将抽象语法树转换为中间代码（例如三地址代码）；

• 优化：对中间代码进行优化，提高程序的执行效率；

• 目标代码生成：将优化后的中间代码编译成汇编代码。

3. 汇编（Assembly）

接下来，将由编译器生成的汇编代码文件转换为目标文件（即目标代码）。汇编器负责将汇编代码转换为机器语言。汇编器会生成一个扩展名为.obj或.o的目标文件。

4. 链接（Linking）

最后一个阶段是链接。在这个阶段，链接器将所有相关的目标文件和库文件（如果程序使用了外部库）链接成一个可执行文件（扩展名为.exe或.elf等）。链接器还负责处理函数和变量之间的引用关系以及解析库文件中的符号。

链接有静态链接和动态链接两种方式：

• 静态链接：将所有库文件和目标文件合并成一个独立的可执行文件。静态链接产生的可执行文件体积较大，但运行时不依赖于外部库文件。

• 动态链接：将程序使用的库文件作为依赖关系，在运行时加载库文件。动态链接产生的可执行文件体积较小，但运行时需要提供相应的库文件。

这就是通过C语言生成.exe文件的过程。如果你对该主题有兴趣，可以进一步研究编译器的设计和链接器的原理，从而更深入地了解编程语言的机制和工作原理。
类成员可访问范围：
三种权限：
公共权限 public 类内可以访问 类外可以访问
保护权限 protected 类内可以访问 类外不可以访问
私有权限 private 类内可以访问 类外不可以访问

要点：

缺省类型的成员为私有成员，即未明确可访问类型的变量。
类的公有成员函数内部的私有变量是可以访问到的。
类的私有成员变量只能由类的成员函数访问。原因之一：方便修改。