C/C++/Qt 修炼手册
C/C++是偏底层的高级程序涉及语言，有很多细节问题并不符合常规印象，该手册会用于持续记录C/C++各种奇形怪状的坑，也用于记录一些用到就被忘掉的接口函数，混杂一些业务八股。
C语言
C语言细节
char数组的初始化
1 | char ch[MAXSIZE]={0}; //这意味这每个字符都是'\0',而不是整数0 |
%x和%p打印
%x用于打印十六进制数，一般接收unsigned int类型，输出没有0x，也不会补0；
%p也是打印16进制的（不是绝对），不过这里的16进制专门针对地址的16进制，也就是常说的指针，地址有多少位就输出多少位，高位补0，前缀带0x；
struct结构体
匿名结构体：即定义了结构体，也进行了实例化：
1
2
3
4struct {
struct buf buf[NBUF];
struct Hash_bcache[MAX_CBlock];
} bcache;1
2
3
4
5struct bcache{
struct buf buf[NBUF];
struct Hash_bcache[MAX_CBlock];
}; //定义
struct bcache bcache; //实例化typedef用法混淆： 1
2
3
4
5typedef struct{
struct buf buf[NBUF];
struct Hash_bcache[MAX_CBlock];
}bcache; //定义
bcache bcache; //实例化
回调函数
记录一种概念：回调函数。所谓callback函数，目前理解为函数作为形参的函数，当在一个函数中调用了这个形参的函数，就说调用了回调函数。一个简单例子:
例如LibDoSth库是模板库的函数，但是模板库作者可能会在这个地方留下个性化的功能，例如一种其他设备的初始化函数等，因为每个对象的初始化是不同的，但是它们无一例外需要接受一个int类型参数，返回void变量，于是就设计了函数指针，我们需要做的就是将函数指针对象mytest补充完整，即完成回调函数并调用。
1
2
3
4
5
6
7
8
9
10
11//定义回调函数
void mytest(int num){
printf("%d",num);
}
typedef void (*callback_t)(int); //定义函数指针callback_t类型
void LibDoSth(callback_t cbfunc){ //函数指针作形参
int n = 0;
cbfunc(n); //调用回调函数
}
difine拼接宏、字符串化
1 |
|
__cxa_demangle类型名转换
在泛型中可能需要获取某个类、数据类型的名称，通过typeid能够得到，然而不同的编译平台这个name可能并非就是我们指定的名称，例如gcc、clang下Person可能被写成了12Person或者其他奇奇怪怪的标识符，因此需要abi::__cxa_demangle返回正确的名称，其中两个nullptr参数分别指定缓冲区和缓冲区大小，为nullptr时会自动计算，转换成功返回status=0；对于非GUN编译器，例如MSVC可能没有这种问题，或者只需要简单的处理。
在mingw和MSVC编译该代码会出现对比的效果： 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
using namespace std;
class Persox_Axx1_23n {
public:
int a = 10;
};
template<typename T>
static string Nameof(const T& obj) {
const char* name = typeid(obj).name();
cout << "original_name:" << name << endl; //15Persox_Axx1_23n，MSVC则为原名
cout << "this is Clang/GCC.." << endl;
int status;
char* demangled = abi::__cxa_demangle(name, nullptr, nullptr, &status); //Qt使用__cxxabiv1::__cxa_demangle
if (status == 0) {
cout << "After process:" << demangled;
return demangled;
}
return name;
}
int main() {
Persox_Axx1_23n person;
Nameof(person);
return 0;
}
调试文件、某行、某函数：
返回： 1
2
3printf("%s",__FILE__); //C:\Users\24364\C_git\C+single\main.cpp
printf("%d",__LINE__); //67
printf("%s",__func__); //main
前向声明
当两个头文件的类互相引用时，其中一方不能#include头文件，否则导致循环引用从而编译失败；而是应该使用类前向声明，将#include头文件放在源文件，这样的操作是有条件的，需要满足当前头文件只使用了引用类的指针/引用，意味着以下情况不能应用前向声明：
当前类在头文件中： 1. 直接使用了引用类的成员变量；
使用了引用类的拷贝语义；
引用类作为了返回值；
调用了引用类的成员函数/内部结构；
C语言函数接口
字符串转整数atoi()
int atoi(const char *nptr); 相比于C++的stoi，缺少了很多异常处理机制，转换失败就直接返回0；
C++
C++细节
cin与getline与streamstring
cin遇到空格或者换行符都会停止读取，getline(cin,变量名)只有遇到换行符才会停止。
如果遇到一些字符串：0 1 2 3 4（回车\\n结尾
在不指明长度的情况下现有的方法读取往往很麻烦，要么使用
cin.get()=='\n'判断回车，要么使用新的工具——stringstream：
1
2
3
4
5
6
7
8
9
10
11
string str;
getline(cin,str);
stringstream ss;
ss<<str; //字符串转字符串流，能够从其中提取整数、浮点数、子字符串等（自动忽略空格字符）
//或者stringstream ss(str),不能使用stringstream ss<<str!!!!
int number;
while(ss>>number) //提取int整数
cout<<number<<" "; //每次输出一个int，按空格
cin与getline混用问题
遇到一些输入： 1
25
a b c d e f g1
2cin>>num;
getline(cin,input);
几种正确的做法： 1
2
3
4
5
6
7
8
9
10
11
12
131. while + getline，让getline统一处理
2. 使用cin参数忽略
cin.ignore(numeric_limits<streamsize>::max(), '\n');
3. 读取但不使用
cin>>num;
//读取空格
char ch;
cin >> ch;
getline...
enum与enum class
C++ 11引入了enum class限定作用域：在11以前，枚举字段不能被同时两类枚举类型使用：
1
2
3
4
5
6
7
8
9enum Sex{
Boy,
Girl
}
enum Student{ //冲突
Boy,
Gril
}enum class可解决： 1
2
3
4
5
6
7
8
9enum class Sex{
Boy,
Girl
}
enum class Student{ //ok
Boy,
Gril
}
结构体的隐式转换
如例子：通过operator bool()可以隐式将test结构体对象转成bool类型，遇到时应该清楚其返回了什么；
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15struct test{
test(int a):a_(a){}
int a_;
operator bool(){
return a_;
}
};
int main(){
test t1(0);
test t2(10);
if(!t1&&t2)
cout<<"I am bool"<<endl;
return 0;
}
数组参数传递退化成指针
在函数参数传递中要传递一个关于vector的数组，写下了vector<int>& test[2]的参数竟然发生报错，正当费尽心思知道正确数组引用写法应当是vector<int>(&test)[2]，却发现这是基本无用功，因为之前的我忽略了一点：在C++中数组作为参数均会退化成指针传递，换言之即使参数为vector<int> test[2]，也是指针传递而不是数组拷贝的值传递，函数体内写值数组实参会发生变化，一个验证代码如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
using namespace std;
void printInfo(vector<int>test[2]){
for(const auto&i : test[0]){
cout<<i <<" ";
}
cout<<endl;
for(const auto&i : test[1]){
cout<<i <<" ";
}
}
void write1(vector<int>test[2]){
int num = 0;
for(auto& i:test[0]){
i = num;
num++;
}
for(auto& i:test[1]){
i = num;
num++;
}
}
void write2(vector<int> (&test)[2]){
int num = 0;
for(auto& i:test[0]){
i = num;
num++;
}
for(auto& i:test[1]){
i = num;
num++;
}
}
int main(){
vector<int>test1(10,3);
vector<int>test2(10,2);
vector<int>test[2]={test1,test2};
printInfo(test);
cout<<"=====================11"<<endl;
write1(test);
printInfo(test); //test被修改
cout<<"=====================22"<<endl;
write2(test);
printInfo(test); //test被修改
return 0;
}
C++函数接口
字符串转整数stoi()
1 | int stoi(const std::string& str, std::size_t* pos = nullptr, int base = 10); |
移除指针remove_pointer<T>
remove_pointer是一种类型萃取，对于remove_pointer<T>::type，如果T是一个指针类型，能返回去除指针的类型T，例如以下将双层指针处理成单层：并且使用is_same<T1,T2>()比较；
1
cout<<std::is_same<std::remove_pointer<int**>::type,int*>()<<endl;
在类的泛型编程中很有作用，例如在一个类中通过this指针拿到该类任意一个函数：
1
2
3
GETFUNC(add) //拿到本类的add函数
C++日期格式化输出/程序测时
测试命令耗时： 1
2
3
4auto start = std::chrono::system_clock::now();
.......//do something
auto time = std::chrono::system_clock::now() - start;
cout<<"time:"<< std::chrono::duration_cast<std::chrono::milliseconds>(time).count() <<endl;
格式化输出时刻： 1
2
3
4
5
6
7
8
9
auto now = chrono::system_clock::now();
std::time_t nowTime = chrono::system_clock::to_time_t(now);
//cout<<"write"<<ctime(&nowTime)<<endl;
cout<<std::put_time(std::localtime(&nowTime), "%Y-%m-%d %H:%M:%S")<<endl; //自定义格式化：2024-xx-xx 20:31:59
cout<<ctime(&nowTime)<<endl; //标注输出：Tue Mar 12 14:30:45 2024
C/C++差异化
malloc、free和new、delete差异
1. malloc与new差异
malloc和new分别是C和C++动态分配内存方式，new的底层也是通过malloc分配，使用差异主要有：
malloc需要使用sizeof自行计算空间大小，new只需要指定类型即可自动计算。malloc返回一个void*空间，需要进行类型转换才能使用；new返回的就是内存空间指针，无需类型转换。malloc失败返回空，使用二次判断即可；new分配失败抛出异常，异常处理应该是catch(const bad_alloc &e)malloc是一种堆分配空间系统调用，Linux中，128K以下空间申请使用sbrk系统调用，扩大内存空间指针；128K以上使用mmap系统调用；new是一种重载操作符，它开辟大小合适的空间，并且调用构造函数执行成员初始化，malloc则没有初始化成员的功能。
注意一些操作系统底层：sbrk只会逻辑上增加内存，实际使用会触发缺页中断，才进行真正的物理内存分配。
2. free和delete
delete的底层实现也是free，主要差别就是free接受void*指针，delete接受对象类型指针，其余原理是几乎相同的：
释放原理：
如果是sbrk系统调用分配的空间，这个空间会重新回到空间分配表。如果是mmap分配的空间，会调用munmap系统调用取消映射，回收内存。free只有指针信息，如何知道释放空间大小：
malloc分配空间时会在起始空间多占据16字节用于存储控制信息，包括分配空间大小，调用free时会在读取固定偏移获取空间大小，进行回收。
using与typedef
众所周知typedef可以用于给变量起别名，但是在函数指针中其规范并不遵循typedef 原名 别名的格式，例如：
1
2typedef int myInt
typedef void(*func)(int,bool)func就是void(*)(int,bool)函数指针的别名,如：
1
2
3
4
5
6
7
8
9typedef int(*func)(int,int);
int add(int a,int b){
return a+b;
}
//main调用：
func addFunc = add;
cout << addFunc(2,3);
C++11
以后using除了可以用于命名空间，也可以用于给变量起别名，包括函数指针指定：
1
using func = int(*)(int,int)
using提高了函数指针的可读性，同时，其可以结合模板一起使用，而typedef则没有这个特性：
1
2template <typename T>
using MyVector = std::vector<T>;using的可读性也挺好：
1
2
3
4
5// 使用 typedef
typedef std::map<std::string, std::vector<int>> MapType;
// 使用 using
using MapType = std::map<std::string, std::vector<int>>;
Qt
某些细节和C++是通用的。
setParent
setParent(this)的重要性：当两个类x和y同时继承一个类，例如常见的QObject/QWidget等，x来自Qt某个类，y是我们编写的类，y中有一个x实例，通过：
1
x->setParent(this); //this将指向y实例指针
宏Q_DECL_EXPORT、Q_DECL_IMPORT
在Qt的一些库中，常常看到这种写法： 1
class Q_WEBSOCKETS_EXPORT QWebSocket : public QObject
其中宏定义为： 1
2
3
4
关键在于Q_DECL_EXPORT和Q_DECL_IMPORT：此二者用于标记一个类和函数是否需要导出接口到动态库/静态库使用，精细化控制接口的可见性。上述意思是如果我们尝试build
这个WebSocket的库(宏QT_BUILD_WEBSOCKETS_LIB生效)，此时应该将该类标记成导出，代表该类会被其他类使用；而非build该库情况时，应该从该库进行导入接口，给用户的库使用该类和函数。
extern "C"
1 | extern "C" Q_DECL_EXPORT void foo(void*){ |
该代码除了使用Q_DECL_EXPORT代表导出该函数给其他代码使用，还指定了extern "C"代表使用C编译器编译该函数代码，最大的区别在于C编译器不会进行名称修饰(Name
Mangling)，因为C++需要支持函数重载等多态特性，其函数名在底层并非使用原名。
断言Q_ASSERT与Q_ASSERT_X
二者均用于断言报错，后者能打印更详细的自定义消息，例如：
1
2
3
4
5
6Q_ASSERT(a!=nullptr);
//断言报错：ASSERT : "a!=nullptr" int file .../main.cpp, line 13
Q_ASSERT_X(a!=nullptr, "OnSolution","a is nullptr");
//原型：void Q_ASSERT_X（bool test, const char *where, const char *what）
//断言报错：ASSERT failure in OnSolution: "a is nullptr", file .../main.cpp, line 13
