C/C++ 个人笔记
仅供个人复习，
C语言IO占位符表
| %d | 十进制整数(int) |
|---|---|
| %ld | long |
| %lld | long long |
| %u | unsigned int |
| %o | 八进制整型 |
| %x | 十六进制整数/字符串地址 |
| %c | 单个字符 |
| %s | 字符串 |
| %f | float，默认保留6位 |
| %lf | double |
| %e | 科学计数法 |
| %g | 根据大小自动选取f或e格式，去掉无效0 |
转义符表
转义符可以取消关键字符的特殊性，下面是常见的转义符使搭配
printf("\b");//退格符printf("\n");//换行printf("\a");//响铃，电脑真的响一下，不可思议printf("\t");//水平制表符printf("\v");//垂直制表符printf("\130");//输出char对应130的字符printf("%% %d",12);//%的转义使用%,而不是\
C/C++ 语言数据类型大小
ANSI/ISO规范
sizeof(short int)<=sizeof(int)
sizeof(int)<=sizeof(long int) short
int至少应为16位（2字节）
long int至少应为32位。
16位编译器
| 数据类型 | 字节数 |
|---|---|
| char | 1 |
| short | 2 |
| int | 2 |
| long | 4 |
| float | 4 |
| double | 8 |
| bool | 1 |
| 指针 | 2 |
32位编译器
| 数据类型 | 字节数 |
|---|---|
| char | 1 |
| short | 2 |
| int | 4 |
| long | 4 |
| long long | 8 |
| float | 4 |
| double | 8 |
| bool | 1 |
| long double | 12 |
| 指针 | 4 |
64位编译器
| 数据类型 | 字节数 |
|---|---|
| char | 1 |
| short | 2 |
| int | 4 |
| long | 8 |
| long long | 8 |
| float | 4 |
| double | 8 |
| bool | 1 |
| long double | 16 |
| 指针 | 8 |
宏函数和内联函数的区别
宏函数（Macro Functions）：
-
替换规则：在编译预处理阶段的简单文本替换
-
参数展开：没有参数类型检查
-
适用场景：简单的、短小的代码片段，例如进行简单的数学计算、位操作等。
内联函数（Inline Functions）：
-
替换规则：编译阶段处理。编译器会尝试将函数调用处直接替换为函数体。
-
参数类型检查：参数和返回值检查与正常函数无异
-
适用场景：内联函数适用于较短小的函数，包含一些简单的代码逻辑，且频繁调用的情况。
-
推荐用法：一般来说，内联函数应该是在类的定义中实现的，以便于对其进行封装和管理，或者在头文件中避免函数重定义问题。inline关键字只能建议编译器进行内联，是否采纳取决于编译器
内联函数可以优化函数进入和离开的开销，但内联可能会导致编译后的代码体积增大，宏函数的使用更需要小心，因为它在文本替换阶段可能会引发一些意想不到的问题。
差异案例
#include <iostream>#define SQUARE_MACRO(x) x * xinline int square_inline(int x) {return x * x;
}int main() {int num = 5;// result = (++num) * (++num) 直接把参数替换进函数int result_macro = SQUARE_MACRO(++num); // 使用宏函数num = 5;//先自增再传入int result_inline = square_inline(++num); // 使用内联函数std::cout << "Number: " << num << std::endl;std::cout << "Result (Macro): " << result_macro << std::endl;std::cout << "Result (Inline): " << result_inline << std::endl;return 0;
}
STL标准库
通用的算法API
条件排序
#include <algorithm>// 使用 lambda 表达式按照姓名升序排序std::sort(v.begin(), v.end(), [](const Person& a, const Person& b) {return a.name < b.name;});//运算符重载
struct Person {int age;Person(int a) : age(a) {}// 重载 < 运算符，按照年龄升序排序bool operator<(const Person& other) const {return age < other.age;}
};sort(v.begin(),v.end());
移除符合条件的元素
#include <algorithm>
//返回的是移除后的逻辑结尾的迭代器,将符合条件的置于尾端
auto newEnd = std::remove_if(v.begin(), v.end(), [](T item)
{return ...
});
//真正的移除
numbers.erase(newEnd, numbers.end()); // 删除废弃的元素
vector
优点：
- 内存是连续分配的，访问元素的速度较快。
- 在末尾插入和删除元素的时间复杂度为常数。
缺点：
- 在中间插入或删除元素的时间复杂度较高，需要移动后续元素。
- 在内存不足时，可能会导致重新分配内存和复制元素。
#include <vector>std::vector<int> v;v.push_back(10); // 在末尾插入元素
v.pop_back(); // 删除末尾的元素
v.size(); // 返回容器中的元素数量
v.empty(); // 检查容器是否为空
v.clear(); // 清空容器中的所有元素
v.at(index); // 访问指定索引的元素
v.begin(); // 返回指向容器第一个元素的迭代器
v.end(); // 返回指向容器最后一个元素之后的迭代器
list
优点：
- 支持在任意位置快速插入和删除元素。
- 在中间插入和删除元素的时间复杂度为常数。
缺点：
- 元素在内存中不连续存储，访问元素的速度慢。
- 占用更多内存，每个节点需要存储额外的指针。
#include <list>std::list<int> lst;lst.push_back(10); // 在末尾插入元素
lst.push_front(20); // 在开头插入元素
lst.pop_back(); // 删除末尾的元素
lst.pop_front(); // 删除开头的元素
lst.size(); // 返回容器中的元素数量
lst.empty(); // 检查容器是否为空
lst.clear(); // 清空容器中的所有元素
lst.front(); // 访问首元素
lst.back(); // 访问末尾元素
lst.begin(); // 返回指向容器第一个元素的迭代器
lst.end(); // 返回指向容器最后一个元素之后的迭代器forawrd_list
与list类似，仅支持单向访问，效率更佳一些
#include <forward_list>
std::forward_list<T> fl;fl.push_front(const value_type& value); // 在头部插入元素
fl.pop_front(); // 从头部删除元素
fl.insert_after(pos, const value_type& value); // 在指定位置后插入元素
fl.erase_after(pos); // 在指定位置后删除元素
fl.front(); // 访问第一个元素
fl.begin(); // 返回指向第一个元素的迭代器
fl.end(); // 返回指向最后一个元素之后的迭代器deque
优点：
- 支持在两端快速插入和删除元素。
- 内存是分块分配的，访问元素的速度较快。
缺点：
- 难以在中间插入或删除元素
- 存储多个分块，占用较多内存
#include <deque>std::deque<int> dq;dq.push_back(10); // 在末尾插入元素
dq.push_front(20); // 在开头插入元素
dq.pop_back(); // 删除末尾的元素
dq.pop_front(); // 删除开头的元素
dq.size(); // 返回容器中的元素数量
dq.empty(); // 检查容器是否为空
dq.clear(); // 清空容器中的所有元素
dq.front(); // 访问首元素
dq.back(); // 访问末尾元素
dq.begin(); // 返回指向容器第一个元素的迭代器
dq.end(); // 返回指向容器最后一个元素之后的迭代器map
优点：
- 存储键值对，支持按键进行高效的查找和插入。
- 根据键的顺序遍历元素。
缺点：
- 内存使用较多，每个键值对都需要额外的内存存储键。
- 没有连续存储，访问元素的速度相对较慢。
#include <map>std::map<std::string, int> m;m["one"] = 1; // 插入键值对
m["two"] = 2;
m.find(const key_type& k); // 查找键的位置
m.count(const key_type& k); // 计算具有特定键的元素数量
m.size(); // 返回容器中的键值对数量
m.empty(); // 检查容器是否为空
m.clear(); // 清空容器中的所有键值对
m.begin(); // 返回指向容器第一个键值对的迭代器
m.end(); // 返回指向容器最后一个键值对之后的迭代器set
优点：
- 存储唯一的元素，支持按值进行高效的查找和插入。
缺点：
- 内存使用较多，每个元素都需要额外的内存存储。
- 不连续存储，访问元素的速度相对较慢。
#include <set>std::set<int> s;s.insert(const value_type& val); // 插入元素
s.find(const key_type& k); // 查找元素
s.size(); // 返回容器中的元素数量
s.empty(); // 检查容器是否为空
s.clear(); // 清空容器中的所有元素
s.begin(); // 返回指向容器第一个元素的迭代器
s.end(); // 返回指向容器最后一个元素之后的迭代器unordered_map (C++11)
优点：
- 使用哈希表实现，支持快速的查找和插入操作，平均时间复杂度为常数。
- 对于大数据集，查找效率高于std::map。
缺点：
- 内存占用较高，需要存储哈希表和键值对。
- 不保证元素的顺序。
#include <unordered_map>std::unordered_map<std::string, int> um;um["one"] = 1; // 插入键值对
um["two"] = 2;
um.find(const key_type& k); // 查找键的位置
um.count(const key_type& k); // 计算具有特定键的元素数量
um.size(); // 返回容器中的键值对数量
um.empty(); // 检查容器是否为空
um.clear(); // 清空容器中的所有键值对
um.begin(); // 返回指向容器第一个键值对的迭代器
um.end(); // 返回指向容器最后一个键值对之后的迭代器unordered_set (C++11)
优点：
- 使用哈希表进行实现，支持快速的查找和插入操作，平均时间复杂度为常数。
- 对于大数据集，查找效率高于std::set。
缺点：
- 内存占用较高，因为需要存储哈希表和元素。
- 不保证元素的顺序。
#include <unordered_set>std::unordered_set<int> us;us.insert(const value_type& val); // 插入元素
us.find(const key_type& k); // 查找元素
us.size(); // 返回容器中的元素数量
us.empty(); // 检查容器是否为空
us.clear(); // 清空容器中的所有元素
us.begin(); // 返回指向容器第一个元素的迭代器
us.end(); // 返回指向容器最后一个元素之后的迭代器stack
#include <stack>std::stack<T> s;s.push(const value_type& value); // 将元素压入堆栈顶部
s.pop(); // 弹出堆栈顶部的元素
s.top(); // 访问堆栈顶部的元素
s.empty(); // 检查堆栈是否为空
s.size(); // 返回堆栈中元素的数量queue
#include <queue>std::queue<T> q;q.push(const value_type& value); // 将元素推入队列尾部
q.pop(); // 从队列头部弹出元素
q.front(); // 访问队列头部元素
q.back(); // 访问队列尾部元素
q.empty(); // 检查队列是否为空
q.size(); // 返回队列中元素的数量priority_queue
#include <queue>std::priority_queue<T> pq;pq.push(const value_type& value); // 将元素推入优先队列
pq.pop(); // 从优先队列中弹出元素
pq.top(); // 访问优先队列中优先级最高的元素
pq.empty(); // 检查优先队列是否为空
pq.size(); // 返回优先队列中元素的数量#include <iostream>
#include <queue>
#include <vector>struct MyStruct {int value;// 比较操作符，根据 value 来比较 ，越大优先级越高bool operator<(const MyStruct& other) const {return value < other.value;}
};int main() {std::priority_queue<MyStruct> pq;pq.push({5});pq.push({2});pq.push({8});pq.push({1});// 遍历优先队列按优先级输出while (!pq.empty()) {std::cout << pq.top().value << " ";pq.pop();}return 0;
}
// 8 5 2 1
构造函数执行顺序
- 先成员的构造，再当前类型的构造
- 父类构造优先于子类构造
- 成员初始化按书写顺序，低于构造顺序
- 虚基类只构造一次，非虚构造两次
例题：问输出结果是多少
#include <iostream>class A {
public:A() {std::cout << "A Constructor" << std::endl;}
};class B : public A {
public:B() {std::cout << "B Constructor" << std::endl;}
};class C : public A {
public:C() {std::cout << "C Constructor" << std::endl;}
};class D : public B, public C {
public:D() {std::cout << "D Constructor" << std::endl;}
};int main() {D d;return 0;
}
智能指针
- std::shared_ptr：允许多个智能指针共享同一个对象，通过引用计数来管理对象的生命周期。当最后一个引用被释放时，对象会被销毁。
auto sp = std::make_shared<int>(); // 分配堆空间，创建智能指针
auto sp2 = sp; // 创建另一个智能指针
-
std::unique_ptr：用于独占地拥有一个对象，不能被多个智能指针共享。它提供了更轻量级的智能指针，适用于不需要共享所有权的情况。
-
std::weak_ptr：用于解决std::shared_ptr的循环引用问题。它可以与std::shared_ptr一起使用，但不会增加对象的引用计数。
今天到这里，改日再更