源码学习初章-基础知识储备

---

---

学前准备

源码地址

cJSON库地址
sqlite-github源码地址
sqlite官方网址
wireshark源码

引言

• 引言参考的是sqlite和wireshark的部分代码，第二篇开始进入cJSON正式篇
• 第一篇暂时不涉及github的源码，参考的是sqlite官网发布的shell.c sqlite3.h .c等文件进行简单的知识储备
• 另外由于工作中多是linux环境所以把vstdio卸载了，但是为了在windows下学习sqlite源码所以我采用的是Qt5.14.1 MinGW32进行开发
• 本文只会使用cpp的new和delete，其他语法将均为c的语法
• 面向对象只是一种设计模式，如果你愿意，你可以用汇编来实现面向对象

---

extern “C”

• 声明：
  这么做的目的是把c作为底层开发库，这样任何一个编程语言都可以调用c写的库了
• 区别
  1、因为在 C 语言中，默认的函数调用约定是 C 调用约定（C calling convention），参数通过栈传递，由调用者清理栈。
  2、在 C++ 中，默认的函数调用约定是 C++ 调用约定（C++ calling convention），其实质是通过名称修饰（Name Mangling）来支持函数重载，参数传递方式和 C 调用约定类似，但由于函数名被修饰，因此 C++ 编译器能够识别重载的函数
• 做法
  在头文件中 所有的 函数 结构体 变量 等能想到的所有内容都放在两个 "{}"中

#ifdef __cplusplus
extern "C" {
#endif
void fun1();
void fun2();
static struct Stu{
	int a;
	char b;
}stu{0,0};
int a=10;
#ifdef __cplusplus
}
#endif

宏定义

平台宏

跨平台宏

#if (defined(_WIN32) || defined(WIN32)) && !defined(_CRT_SECURE_NO_WARNINGS)
#define _CRT_SECURE_NO_WARNINGS
#endif
#include <windows.h>
#elif define(__linux__)
#include <socket.h>
#endif

总结:
- !defined(_CRT_SECURE_NO_WARNINGS)是为了防止C4996报错
- defined(_WIN32)和defined(WIN32)用来判断是否是windows，defined(WIN64)是在win系统基础上判断是不是win64位

vstdio平台禁用警告宏

#if defined(_MSC_VER)
#pragma warning(disable : 4054)// 禁用类型转换警告。此警告提示可能存在的类型转换问题。
#pragma warning(disable : 4055)//禁用类型转换警告。此警告提示可能存在的类型转换问题。
#pragma warning(disable : 4100)//禁用未使用的形参警告。此警告提示声明了但未在函数体内使用的形式参数。
//等
#endif /* defined(_MSC_VER) */

连接、双层宏定义

#include <stdio.h>

// 定义连接运算符宏
#define CONCAT(x, y) x##y

//双层宏定义
/*
 * 双重宏的第一个宏用于接收参数，并进行预处理操作。
 * 第二个宏则负责将经过预处理的参数传递给其他宏或函数，或者用于宏展开后的标识符构造
 * */
// 第一个宏，用于将宏参数转换为字符串常量
#define SHELL_STRINGIFY_(f) #f
// 第二个宏，用于传递参数给第一个宏进行处理
#define SHELL_STRINGIFY(f) SHELL_STRINGIFY_(f)

int main() {
    // 使用连接运算符宏
    int CONCAT(number, 1) = 42; // 等同于 int number1 = 42;
    printf("Value: %d\n", number1);
    // 注意：下面这个例子在预处理阶段将连接运算符宏展开为"Hello"，而不是一个新的标识符
    printf("%s\n", "Hello" "World");
    printf("The value is: %s\n", SHELL_STRINGIFY(number1));//使用双层宏定义
    return 0;
}

函数宏

系统函数宏

将系统函数变成我们自己的宏即可省去后期我们大量调用时的麻烦
当然也可以自己写个函数通过宏实现

# define GETPID (int)GetCurrentProcessId//获取当前进程函数

#include <stdio.h>
#include <windows.h>

// 定义宏，用于获取当前进程ID
#define GETPID (int)GetCurrentProcessId

// 定义宏，用于检查给定的字符是否为空白字符（包括空格、制表符、换行符等）
#define IsSpace(X)  isspace((unsigned char)X)

// 定义宏，用于检查给定的字符是否为十进制数字字符（0-9）
#define IsDigit(X)  isdigit((unsigned char)X)

// 定义宏，用于将给定的字符转换为小写字符
#define ToLower(X)  (char)tolower((unsigned char)X)

// 定义宏，用于将给定的字符转换为大写字符
#define ToUpper(X)  (char)toupper((unsigned char)X)

int main() {
    // 使用宏来获取当前进程ID
    int pid = GETPID();

    // 输出当前进程ID
    printf("Current process ID: %d\n", pid);

    // 另外，我们也可以直接调用 GetCurrentProcessId 函数来获取进程ID
    int pid_direct = GetCurrentProcessId();
    printf("Current process ID (direct call): %d\n", pid_direct);

    // 测试字符处理的宏
    char ch = 'a';

    // 使用 IsSpace 宏来检查字符 ch 是否为空白字符
    if (IsSpace(ch)) {
        printf("The character is a whitespace character.\n");
    } else {
        printf("The character is not a whitespace character.\n");
    }

    // 使用 IsDigit 宏来检查字符 ch 是否为数字字符
    if (IsDigit(ch)) {
        printf("The character is a digit.\n");
    } else {
        printf("The character is not a digit.\n");
    }

    // 使用 ToLower 宏将字符 ch 转换为小写形式，并输出转换后的字符
    printf("The lowercase of the character is: %c\n", ToLower(ch));

    // 使用 ToUpper 宏将字符 ch 转换为大写形式，并输出转换后的字符
    printf("The uppercase of the character is: %c\n", ToUpper(ch));

    return 0;
}

自定义函数宏

//宏定义自己的函数
//注意显示转换不是必须的，但写上更加直观
#include <iostream>
using namespace std;

#define MIN(x,y) (int)min((int)x, (int)y)
int min(int a,int b) {
    int ret = a<b?a:b;
    cout<<"min is "<<ret<<endl;
    return ret;
}

int main()
{
   cout<<MIN(10,5);

   return 0;
}

多语句执行宏do while0

# define CONTINUE_PROMPT_RESET \
  do {setLexemeOpen(&dynPrompt,0,0); trackParenLevel(&dynPrompt,0);} while(0)

• 当有多条语句要执行时需要用{}将函数括起来，而用{}需要用do while循环好处：
  1、使宏的用法更像函数调用，增加了代码的可读性和可维护性
  2、可以避免一些编译器警告，因为使用了多条语句，编译器会认为这是一个复合语句
  3、do-while(0) 循环体会执行一次，因为条件永远为真。这并不会引起运行时额外的开销，因为优化后的编译器会将其优化掉
• 重点：宏中需要一行写完，如果分行需要用 \ 进行换行

#include <stdio.h>
// 假设这是全局变量，实际情况下可能是其他类型的全局变量
int dynPrompt;

// 假设这是虚拟的函数，实际情况下可能是其他具体的函数
void setLexemeOpen(int* prompt, int arg1, int arg2) {
    // 这里省略函数的具体实现
    dynPrompt = -1;
    printf("setLexemeOpen called with arguments: %d, %d\n", arg1, arg2);
}

void trackParenLevel(int* prompt, int arg) {
    // 这里省略函数的具体实现
    printf("trackParenLevel called with argument: %d\n", arg);
}

// 定义宏
#define CONTINUE_PROMPT_RESET \
    do { \
        setLexemeOpen(&dynPrompt, 0, 0); \
        trackParenLevel(&dynPrompt, 0); \
    } while(0)

int main() {
    printf("Before calling CONTINUE_PROMPT_RESET:\n");
    printf("dynPrompt = %d\n", dynPrompt);

    // 使用宏 CONTINUE_PROMPT_RESET
    CONTINUE_PROMPT_RESET;

    printf("\nAfter calling CONTINUE_PROMPT_RESET:\n");
    printf("dynPrompt = %d\n", dynPrompt);

    return 0;
}

# define CONTINUE_PROMPT_AWAITS(p,s) \
  if(p && stdin_is_interactive) setLexemeOpen(p, s, 0)
  //这个 if 是条件语句(单个条件语句),所以不用 do while0

普通宏定义

• 宏代表的是指针
  #define CONTINUE_PROMPT_PSTATE_PTR (&dynPrompt)
• 宏代表的是变量
  #define CONTINUE_PROMPT_PSTATE_VALUE dynPrompt
• 代表的是具体的常数
  #define CONTINUE_PROMPT_PSTATE_CONSTANT 42

#include <stdio.h>

// 假设这是全局变量，实际情况下可能是其他类型的全局变量
int dynPrompt = 42;

// 定义三个不同的宏
#define CONTINUE_PROMPT_PSTATE_PTR (&dynPrompt)
#define CONTINUE_PROMPT_PSTATE_VALUE dynPrompt
#define CONTINUE_PROMPT_PSTATE_CONSTANT 42

int main() {
    int *ptr = CONTINUE_PROMPT_PSTATE_PTR; // ptr 指向 dynPrompt 的地址
    int value = CONTINUE_PROMPT_PSTATE_VALUE; // value 的值是 dynPrompt 的值，即 42
    int constant = CONTINUE_PROMPT_PSTATE_CONSTANT; // constant 的值是 42

    printf("dynPrompt: %d\n", dynPrompt);
    printf("Address of dynPrompt: %p\n", &dynPrompt);
    printf("ptr: %p\n", ptr);
    printf("value: %d\n", value);
    printf("constant: %d\n", constant);

    return 0;
}

C的一些必备函数知识

回调函数和函数指针

#include <iostream>
using namespace std;
//函数指针
void (*funPtr)(int a,int b);
//下面的 max和min会赋值给函数指针
void max(int a,int b){
    int ret = a>b?a:b;
    cout<<"max is "<<ret<<endl;
}
void min(int a,int b) {
    int ret = a<b?a:b;
    cout<<"min is "<<ret<<endl;
}
//回调函数
typedef void (*callBack)(int a,int b);//回调函数比函数指针多了一个typedef
void sameFun(int a, int b , callBack fun){
    fun(a,b);
}
int main()
{
   cout << "Hello World" << endl;
   funPtr = max;
   funPtr(10,5);
   funPtr = min;
   funPtr(10,5);

    sameFun(10,5,max);
    sameFun(10,5,min);
   return 0;
}

回调函数wireshark-4.0.7源码例子

packet.h:76
typedef int (*dissector_t)(tvbuff_t *, packet_info *, proto_tree *, void *);//回调函数声明

packet.c:3310
/* Register a new dissector by name. */
dissector_handle_t
register_dissector(const char *name, dissector_t dissector, const int proto)
{
	struct dissector_handle *handle;

	handle = new_dissector_handle(DISSECTOR_TYPE_SIMPLE, dissector, proto, name, NULL, NULL);

	return register_dissector_handle(name, handle);
}

packet-ssh.c:4799
 ssh_handle = register_dissector("ssh", dissect_ssh, proto_ssh);

packet-ssh.c:676
 static int
dissect_ssh(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
{
/*这里面是ssh解析的具体代码，不做展示*/
}

函数指针wireshark4.0.7源码例子

packet-ssh.c:185
truct ssh_flow_data {
    guint   version;

    gchar*  kex;
    int   (*kex_specific_dissector)(guint8 msg_code, tvbuff_t *tvb,
            packet_info *pinfo, int offset, proto_tree *tree,
            struct ssh_flow_data *global_data, guint *seq_num);//函数指针声明

    /* [0] is client's, [1] is server's */
#define CLIENT_PEER_DATA 0
#define SERVER_PEER_DATA 1
/*后续代码略*/
}
//---------------------------------------------------------------------------------
packet-ssh.c:1702
static void ssh_set_kex_specific_dissector(struct ssh_flow_data *global_data)
{
    const char *kex_name = global_data->kex;

    if (!kex_name) return;

    if (strcmp(kex_name, "diffie-hellman-group-exchange-sha1") == 0 ||
        strcmp(kex_name, "diffie-hellman-group-exchange-sha256") == 0)
    {
        global_data->kex_specific_dissector = ssh_dissect_kex_dh_gex;//函数指针赋值
    }
    /*dh group 和 ecdh 略*/
}
//---------------------------------------------------------------------------------
packet-ssh.c:1361
static int ssh_dissect_kex_dh_gex(guint8 msg_code, tvbuff_t *tvb,
        packet_info *pinfo, int offset, proto_tree *tree,
        struct ssh_flow_data *global_data, guint *seq_num)

结构体和关键字

结构体和联合体

结构体 struct

static struct DynaPrompt {
  char dynamicPrompt[PROMPT_LEN_MAX];
  char acAwait[2];
  int inParenLevel;
  char *zScannerAwaits;
} dynPrompt = { {0}, {0}, 0, 0 };

• 因为C没有构造函数，不能像cpp一样在构造函数对结构体进行赋初值，因此它赋初值的方法是在结构体定义的尾部赋值

• 每个成员变量含义：
  dynamicPrompt 数组被初始化为 {0}：即所有元素都是空字符 ‘\0’。
  acAwait 数组被初始化为{0}：即设置为两个空字符 ‘\0’。
  inParenLevel 被初始化为 0：表示括号的层级初始值为 0。
  zScannerAwaits被初始化为 0：它被初始化为 0，即指向空地址。

联合体 union

• 联合体的所有成员共用同一块内存空间，不同成员在内存中的位置是重叠的。
• 联合体的大小等于所有成员中占用内存最大的那个成员的大小
• 在同一时间，只能使用一个成员，存储一个成员的值会覆盖其他成员的值。

#include <stdio.h>
#include <string.h>

union Data {
    int integerData;
    float floatData;
    char stringData[20];
} data;

int main() {
    // 存储整数数据
    data.integerData = 42;
    printf("Integer Data: %d\n", data.integerData);

    // 存储浮点数数据
    data.floatData = 3.14;
    printf("Float Data: %.2f\n", data.floatData);

    // 存储字符串数据
    strcpy(data.stringData, "Hello, Union!");
    printf("String Data: %s\n", data.stringData);

    // 访问整数数据（此时整数数据会被覆盖）
    printf("Integer Data: %d\n", data.integerData);

    return 0;
}

关键字

• static和extern的作用是相反的

static

因为源码中有大量的static函数、结构体等。
静态函数的作用是：

• 函数隐藏在当前源文件中，对其他部分不可见，实现隐藏实现细节的目的
• 将函数声明为 static 可以限制其作用域，避免与其他文件中的同名函数冲突
• 这是一种常见的编程技巧，用于实现模块化的代码结构和增强程序的安全性。

extern

• 当在一个源文件中使用 extern 来声明函数时，它告诉编译器该函数是在另一个源文件中定义的，而不是在当前文件中定义的
• 通常，这样的声明会放在头文件中，然后在其他源文件中包含该头文件，以便其他源文件可以访问和调用声明的函数。

C++关键字 explicit

• 这个关键字加在构造函数前，保证代码安全性

class MyClass {
public:
    explicit MyClass(int value) {
        // 构造函数的实现
    }
};
//如果没有explicit关键字那么构造函数可以隐式调用
int num = 42;
MyClass obj = num; // 隐式调用构造函数，将整数转换为 MyClass 类型
//加上explicit关键字必须显式创建对象
int num = 42;
MyClass obj(num); // 显式调用构造函数，将整数转换为 MyClass 类型

标志位与位操作

& 、 |、<<、>>

1000&1010 = 1000
1000|1010 = 1010
1<<8 = 1*2的八次方（10000000）
256>>8 = 256/2的八次方( 10000000>>8)
可以简单地理解为加减法的关系，本处不做具体解释，可以参考网上其他信息

标志位(|加标志)(&减/检标志)

#include <stdio.h>

// 定义标志位的常量
#define FLAG_A (1 << 0) // 00000001
#define FLAG_B (1 << 1) // 00000010
#define FLAG_C (1 << 2) // 00000100

int main() {
    int flags = 0; // 初始标志位为 0

    // 设置标志位
    flags |= FLAG_A; // 将 FLAG_A 设置为 1
    flags |= FLAG_C; // 将 FLAG_C 设置为 1

    // 检查标志位
    if (flags & FLAG_A) {
        printf("标志位 A 已设置\n");
    } else {
        printf("标志位 A 未设置\n");
    }

    if (flags & FLAG_B) {
        printf("标志位 B 已设置\n");
    } else {
        printf("标志位 B 未设置\n");
    }

    if (flags & FLAG_C) {
        printf("标志位 C 已设置\n");
    } else {
        printf("标志位 C 未设置\n");
    }

    return 0;
}

过程

• flags = 00000000
• FLAG_A = 00000001
  flags = 00000000 | 00000001 = 00000001
• FLAG_C = 00000100
  flags = 00000001 | 00000100 = 00000101
• FLAG_A = 00000001
  flags = 00000101 & 00000001 = 00000001 (非零，表示标志位 A 已设置)
• FLAG_B = 00000010
  flags = 00000101 & 00000010 = 00000000 (为零，表示标志位 B 未设置)
• FLAG_C = 00000100
  flags = 00000101 & 00000100 = 00000100 (非零，表示标志位 C 已设置)
• 这样我们通过 | 加标志 再用 & 检查标志，我们就可以通过3bit的数据获得8种标志位情况
• 实际上我们不必用&检查标志位，因为8种情况我们都是知道的所以直接 == 0111(0x07) 或 0011(0x03)(等6种情况)即可
  注：各种源码这种标志位过于普遍，本处不再贴此类代码

代码习惯

if else

if( dynPrompt.inParenLevel>9 ){
  shell_strncpy(dynPrompt.dynamicPrompt, "(..", 4);
}else if( dynPrompt.inParenLevel<0 ){
  shell_strncpy(dynPrompt.dynamicPrompt, ")x!", 4);
}else{
  shell_strncpy(dynPrompt.dynamicPrompt, "(x.", 4);
  dynPrompt.dynamicPrompt[2] = (char)('0'+dynPrompt.inParenLevel);
}

if else break

if( nmb !=0 && noc+nmb <= ncmax ){
          //sss
}else break; 

函数定义

这种函数参数列表是第一次看到
工作中没有遇到过这种写法，但是这种注释确实比较方便，易读性很好
后续会对这种格式进行讨论

static char *shellFakeSchema(
  sqlite3 *db,            /* The database connection containing the vtab */
  const char *zSchema,    /* Schema of the database holding the vtab */
  const char *zName       /* The name of the virtual table */
){
//。。。
}

cJSON源码学习gitee链接

这是cJSON源码学习的gitee链接

其他内容后续补充

这个是为了cJSON库源码学习先初步学习的一些知识储备
目前 cJSON源码的学习基本结束(精力有限掌握原理，理清思路会使用是我的目标，每个人可以结合自己实际进行深入的学习)