C/C++ 个人笔记

仅供个人复习，

C语言IO占位符表

%d十进制整数(int)
%ldlong
%lldlong long
%uunsigned int
%o八进制整型
%x十六进制整数/字符串地址
%c单个字符
%s字符串
%ffloat，默认保留6位
%lfdouble
%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位编译器

数据类型字节数
char1
short2
int2
long4
float4
double8
bool1
指针2

32位编译器

数据类型字节数
char1
short2
int4
long4
long long8
float4
double8
bool1
long double12
指针4

64位编译器

数据类型字节数
char1
short2
int4
long8
long long8
float4
double8
bool1
long double16
指针8

宏函数和内联函数的区别

宏函数（Macro Functions）：

  1. 替换规则：在编译预处理阶段的简单文本替换

  2. 参数展开：没有参数类型检查

  3. 适用场景：简单的、短小的代码片段，例如进行简单的数学计算、位操作等。

内联函数（Inline Functions）：

  1. 替换规则：编译阶段处理。编译器会尝试将函数调用处直接替换为函数体。

  2. 参数类型检查：参数和返回值检查与正常函数无异

  3. 适用场景：内联函数适用于较短小的函数，包含一些简单的代码逻辑，且频繁调用的情况。

  4. 推荐用法：一般来说，内联函数应该是在类的定义中实现的，以便于对其进行封装和管理，或者在头文件中避免函数重定义问题。inline关键字只能建议编译器进行内联，是否采纳取决于编译器

内联函数可以优化函数进入和离开的开销，但内联可能会导致编译后的代码体积增大，宏函数的使用更需要小心，因为它在文本替换阶段可能会引发一些意想不到的问题。

差异案例

#include <iostream>

#define SQUARE_MACRO(x) x * x

inline 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一起使用，但不会增加对象的引用计数。

今天到这里，改日再更

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/97105.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

LeetCode第6~10题解

LeetCode第6~10题解

CONTENTS LeetCode 6. N 字形变换&#xff08;中等&#xff09;LeetCode 7. 整数反转&#xff08;中等&#xff09;LeetCode 8. 字符串转换整数-atoi&#xff08;中等&#xff09;LeetCode 9. 回文数&#xff08;简单&#xff09;LeetCode 10. 正则表达式匹配&#xff08;困难&…
阅读更多...
Flutter 混合开发调试

Flutter 混合开发调试

针对Flutter开发的同学来说&#xff0c;大部分的应用还是Native Flutter的混合开发&#xff0c;所以每次改完Flutter代码&#xff0c;运行整个项目无疑是很费时间的。所以Flutter官方也给我们提供了混合调试的方案【在混合开发模式下进行调试】&#xff0c;这里以Android Stud…
阅读更多...
VUE笔记（四）vue的组件

VUE笔记（四）vue的组件

一、组件的介绍 1、组件的作用 整个项目都是由组件组成 可以让代码复用&#xff1a;相似结构代码可以做成一个组件&#xff0c;直接进行调用就可以使用&#xff0c;提高代码复用性 可以让代码具有可维护性&#xff08;只要改一处&#xff0c;整个引用的部分全部都变&#xf…
阅读更多...
Java8实战-总结17

Java8实战-总结17

Java8实战-总结17 引入流流操作中间操作终端操作使用流 小结 引入流 流操作 java.util.stream.Stream中的Stream接口定义了许多操作。它们可以分为两大类。再来看一下前面的例子&#xff1a; List<String> names menu.stream() //从菜单获得流 .filter(d -> d.get…
阅读更多...
SpringBoot - Google EventBus、AsyncEventBus

SpringBoot - Google EventBus、AsyncEventBus

介绍 EventBus 顾名思义&#xff0c;事件总线&#xff0c;是一个轻量级的发布/订阅模式的应用模式&#xff0c;最初设计及应用源与 google guava 库。 相比于各种 MQ 中间件更加简洁、轻量&#xff0c;它可以在单体非分布式的小型应用模块内部使用&#xff08;即同一个JVM范围…
阅读更多...
xml和json互转工具类

xml和json互转工具类

分享一个json与xml互转的工具类&#xff0c;非常好用 一、maven依赖 <!-->json 和 xm 互转</!--><dependency><groupId>org.dom4j</groupId><artifactId>dom4j</artifactId><version>2.1.3</version></dependency&g…
阅读更多...
c语言练习题--4

c语言练习题--4

阅读更多...
图形化管理工具ossbrowser

图形化管理工具ossbrowser

文章目录 一、OSS介绍二、通过工具管理OSS三、安装四、使用-通过AK五、免责声明摘抄 一、OSS介绍 云对象存储OSS&#xff08;Object Storage Service&#xff09;是一款海量、安全、低成本、高可靠的云存储服务&#xff0c;可提供99.9999999999%&#xff08;12个9&#xff09;…
阅读更多...
Javaweb入门

Javaweb入门

Spring Spring发展到今天已经形成一种开发生态圈&#xff0c;Spring提供若干个子项目&#xff0c;每个项目用于完成特定的功能。 Spring Boot可以帮助我们非常快速的构建应用程序、简化开发、提高效率 SpringBootWeb入门 需求&#xff1a;使用Spring Boot开发一个web应用&a…
阅读更多...
结构体(个人学习笔记黑马学习)

结构体(个人学习笔记黑马学习)

1、结构体的定义和使用 #include <iostream> using namespace std; #include <string>struct Student {string name;int age;int score; }s3;int main() {//1、struct Student s1;s1.name "张三";s1.age 18;s1.score 100;cout << "姓名&a…
阅读更多...
便携式水质自动采样器可应用的场景

便携式水质自动采样器可应用的场景

便携式水质自动采样器符合中国环境保护部HJ/T 372-2007《水质自动采样器技术要求及检测方法》&#xff0c;是集流量测量、水样采集&#xff0c;自动分瓶、一体的多功能环境监测仪器。 具有体积小&#xff0c;方便移动、操作简捷、环保节能等特点。适用于各级环境监测站、监察机…
阅读更多...
go vet中的那些检测项

go vet中的那些检测项

go vet 是 Go 语言自带的一个工具&#xff0c;用于分析 Go 代码中的常见错误和潜在问题。它可以检查代码中可能存在的各种问题&#xff0c;例如&#xff1a; 未使用的变量、函数或包 可疑的函数调用 错误的函数签名 程序中的竞态条件 错误的类型转换等 本文意图指令当前go vet所…
阅读更多...
【VUE】数字动态变化到目标值-vue-count-to

【VUE】数字动态变化到目标值-vue-count-to

vue-count-to是一个Vue组件&#xff0c;用于实现数字动画效果。它可以用于显示从一个数字到另一个数字的过渡动画。 插件名&#xff1a;vue-count-to 官方仓库地址&#xff1a;GitHub - PanJiaChen/vue-countTo: Its a vue component that will count to a target number at a…
阅读更多...
VueX 与Pinia 一篇搞懂

VueX 与Pinia 一篇搞懂

VueX 简介 Vue官方&#xff1a;状态管理工具 状态管理是什么 需要在多个组件中共享的状态、且是响应式的、一个变&#xff0c;全都改变。 例如一些全局要用的的状态信息&#xff1a;用户登录状态、用户名称、地理位置信息、购物车中商品、等等 这时候我们就需要这么一个工…
阅读更多...
【二等奖方案】大规模金融图数据中异常风险行为模式挖掘赛题「Aries」解题思路

【二等奖方案】大规模金融图数据中异常风险行为模式挖掘赛题「Aries」解题思路

第十届CCF大数据与计算智能大赛&#xff08;2022 CCF BDCI&#xff09;已圆满结束&#xff0c;大赛官方竞赛平台DataFountain&#xff08;简称DF平台&#xff09;正在陆续释出各赛题获奖队伍的方案思路&#xff0c;欢迎广大数据科学家交流讨论。 本方案为【大规模金融图数据中…
阅读更多...
查局域网所有占用IP

查局域网所有占用IP

查局域网所有占用IP 按&#xff1a;winr 出现下面界面&#xff0c;在文本框中输入 cmd 按确定即可出现cmd命令界面 在cmd命令窗口输入你想要ping的网段&#xff0c;下面192.168.20.%i即为你想要ping的网段&#xff0c;%i代表0-255 for /L %i IN (1,1,254) DO ping -w 1 -n 1…
阅读更多...
尚硅谷SpringMVC

尚硅谷SpringMVC

五、域对象共享数据 1、使用ServletAPI向request域对象共享数据 首页&#xff1a; Controller public class TestController {RequestMapping("/")public String index(){return "index";} } <!DOCTYPE html> <html lang"en" xmln…
阅读更多...
十五、模板方法模式

十五、模板方法模式

一、什么是模板方法模式 模板方法&#xff08;Template Method&#xff09;模式的定义如下&#xff1a;定义一个操作中的算法骨架&#xff0c;而将算法的一些步骤延迟到子类中&#xff0c;使得子类可以不改变该算法结构的情况下重定义该算法的某些特定步骤。 模板方法模式包含以…
阅读更多...
Sharding-JDBC（九）5.3.0版本，实现按月分表、自动建表、自动刷新节点

Sharding-JDBC（九）5.3.0版本，实现按月分表、自动建表、自动刷新节点

目录 一、简介二、Maven依赖三、配置文件application.ymlsharding.yaml 四、代码实现1.自动建表、自动刷新节点思路2.创建表结构3.TimeShardingAlgorithm.java 分片算法类4.ShardingAlgorithmTool.java 分片工具类5.ShardingTablesLoadRunner.java 初始化缓存类6.SpringUtil.ja…
阅读更多...
postgresql-子查询

postgresql-子查询

postgresql-子查询 简介派生表IN 操作符ALL 操作符ANY 操作符关联子查询横向子查询EXISTS 操作符 简介 子查询&#xff08;Subquery&#xff09;是指嵌套在其他 SELECT、INSERT、UPDATE 以及 DELETE 语句中的 查询语句。 子查询的作用与多表连接查询有点类似&#xff0c;也是为…
阅读更多...
最新文章

Copyright @ 2022~2023