day10-c语言基础

阅读目录

• 4.1 编译器安装
• 4.2 IDE安装
• 4.3 clion中文乱码问题
• 5.1 整形
• 5.2 浮点型
• 5.3 常量
• 5.4 运算符
• 5.5 if 判断
• 5.6 循环
• 5.7 函数
• 5.8 字符和字符串
• 5.9 数组
• 6.1 定义指针类型变量和取变量地址
• 6.2 指针类型变量解引用
• 6.3 修改变量的值
• 6.4 指针的零值和长度
• 6.5 通过指针修改原变量值
• 6.6 指针类型参数
• 6.7 数组的指针(指针运算)
• 6.8 指针的指针
• 6.9 字符串案例
• 7.1 基本使用
• 7.1 单向链表
• 7.3 双向链表
• 7.4 双向环状链表
• 8.1 预处理
• 8.2 头文件
• 8.3 Python源码中头文件的使用

四 C语言编译器安装

## 学习c语言的原因
一般公司的apk，基于Java实现的加密。
	- jadx反编译java，分析代码
	
NB公司的的apk，基于Java+C语言实现加密（JNI开发）。
	- jadx反编译java，分析代码
	- ida反编译c语言，分析代码
    
## c语言动态链接库so文件反编译工具
在C语言中，生成的可执行文件或共享库（.so文件）可以被反汇编和反编译，以还原源代码或了解其实现细节。下面是一些常用的C语言so文件反编译工具：
 
IDA Pro：IDA Pro是一款强大的逆向工程工具，支持多种平台和架构，包括C语言。它提供了反汇编、反编译、调试等功能，能够帮助你还原C语言so文件的源代码。但需要注意的是，IDA Pro是商业软件，需要购买授权。
 
Ghidra：Ghidra是一款由美国国家安全局（NSA）开发的开源逆向工程工具。它支持多种平台和架构，并提供反汇编、反编译、脚本编写等功能，可以用于分析和还原C语言so文件的代码。
 
Radare2：Radare2是一个开源的逆向工程框架，提供了反汇编、反编译、调试等功能。它可以用于分析和还原C语言so文件的源代码，支持多种平台和架构。
 
Hopper Disassembler：Hopper Disassembler是一款反汇编工具，支持多种平台和架构。它可以将C语言so文件反汇编为汇编代码，并提供可视化界面和一些高级分析功能。

回到顶部

4.1 编译器安装

# C语言是编译型语言，编写好代码之后，需要由编译器编译后成不同平台的可执行文件才能执行，常见的编译器GCC、MSVC、Clang
 
# mac，linux： 默认自带gcc，不需要额外安卓，mac如果没有就去直接安装xcode。
  xcode:  https://developer.apple.com/xcode/
 
# win：MinGW
MInGW全称为：Minimalist GNU on Windows.将经典的开源C语言编译器GCC移植到了Windows平台下，并且包含了Win32API,因此可以将源代码编译为在Windows中运行的可执行程序
 
而且还可以使用一些Windows不具备的，Linux平台下的开发工具。概括来讲：MinGW 是GCC的Windows版本
 
# MinGW-w64与MinGW的区别：
MinGW只能编译生产32位可执行程序；
MinGW-w64可以编译成64bit或者32bit可执行程序
 
# MinGW-w64安装，参照教程
	https://zhuanlan.zhihu.com/p/355510947
    https://sourceforge.net/projects/mingw-w64/files/mingw-w64/mingw-w64-release/  
# 我们安装 MinGW
	-下载：https://osdn.net/projects/mingw/downloads/68260/mingw-get-setup.exe/
    -下载不成功，用这个地址：https://sourceforge.net/projects/mingw/files/latest/download
        
# 安装路径加入环境变量，测试
	
    
    
# 编写代码  main.c
 
# include <stdio.h>
 
int main(int argc, char const *argv[]) {
    
    printf("hello world\n");
    
    return 0;
}
 
# 编译并运行（在终端）
gcc main.c
a.exe
 

回到顶部

4.2 IDE安装

# 我们使用jetbrains公司的CLion作为IDE
#下载地址：（破解方案同pycharm和idea）
https://www.jetbrains.com/clion/download/other.html
 
# 一路下一步安装，成功后打开，创建项目

回到顶部

4.3 clion中文乱码问题

4.3.1 解决方案一

按住 Ctrl+Shift+Alt+/ 选中Registry...

4.3.2 解决方案二

五 基础语法

回到顶部

5.1 整形

类型	存储大小	值范围
char	1 字节	-128 到 127 或 0 到 255
unsigned char	1 字节	0 到 255
signed char	1 字节	-128 到 127
int	2 或 4 字节	-32,768 到 32,767 或 -2,147,483,648 到 2,147,483,647
unsigned int	2 或 4 字节	0 到 65,535 或 0 到 4,294,967,295
short	2 字节	-32,768 到 32,767
unsigned short	2 字节	0 到 65,535
long	4 字节	-2,147,483,648 到 2,147,483,647
unsigned long	4 字节	0 到 4,294,967,295

#include <stdio.h>
int main() {
    char i=99;
    printf("%d\n",i);
    printf("%c\n",i);
 
    unsigned char i1=99;
    printf("%d\n",i1);
    printf("%c\n",i1);
    //short i=32767;  // 默认有符号，整数最大32767
    //signed short i=32767;  // 默认有符号，整数最大32767
    unsigned short i1=65535;  // 有符号，正数最大 65535
 
    //int i2=65536;
    long i3=65536;
    printf("%d",i3);
    
    // 各种类型的存储大小与系统位数有关，但目前通用的以64位系统为主
    // int 在64位机器上，占4字节
    int i9=9999;
    printf("%d\n",sizeof(i9));
    printf("%d\n",sizeof(int));
    return 0;
}

回到顶部

5.2 浮点型

类型	存储大小	值范围	精度
float	4 字节	1.2E-38 到 3.4E+38	6 位有效位
double	8 字节	2.3E-308 到 1.7E+308	15 位有效位
long double	16 字节	3.4E-4932 到 1.1E+4932	19 位有效位

#include <stdio.h>
int main() {
    printf("float 存储最大字节数 : %d \n", sizeof(float));
    printf("double 存储最大字节数 : %d \n", sizeof(double));
    printf("long double 存储最大字节数 : %d \n", sizeof(long double));
    // %f代表一般计数法输出，%e代表指数计数法输出
    float f1=365.123456789F;
    printf("%f---%e\n",f1,f1);
 
    double f2=365.123456789;
    printf("%f---%e\n",f2,f2);
 
    long double f3=365.123456789L;
    printf("%Lf---%Le\n",f3,f3);
 
    return 0;
}

回到顶部

5.3 常量

#include <stdio.h>
int main() {
    const int MAX_VALUE =99;
    //MAX_VALUE =199;
    printf("%d\n",MAX_VALUE );
    return 0;
}

回到顶部

5.4 运算符

• 算术运算符

A 的值为 10，变量 B 的值为 20

运算符	描述	实例
+	把两个操作数相加	A + B 将得到 30
-	从第一个操作数中减去第二个操作数	A - B 将得到 -10
*	把两个操作数相乘	A * B 将得到 200
/	分子除以分母	B / A 将得到 2
%	取模运算符，整除后的余数	B % A 将得到 0
++	自增运算符，整数值增加 1	A++ 将得到 11
--	自减运算符，整数值减少 1	A-- 将得到 9

#include <stdio.h>
 
int main() {
    int a = 10;
    int b = 20;
    int c;
 
    c = a + b;
    printf("a+b结果是 %d\n", c);
    c = a - b;
    printf("a-b结果是 %d\n", c);
    c = a * b;
    printf("a * b 结果是%d\n", c);
    c = b / a;
    printf("b / a的值是 %d\n", c);
    c = 10 % 3;
    printf("10 % 3取整除的值是 %d\n", c);
    c = a++;  // 赋值后再加 1 ，c 为 10，a 为 11
    printf("赋值后再加 的值是 %d,a的值为：%d\n", c, a);
    c = a--;  // 赋值后再减 1 ，c 为 11 ，a 为 10
    printf("赋值后再减 1的值是 %d,a的值为：%d\n", c, a);
    return 0;
}
// a++ 与 ++a 的区别

• 关系运算符

运算符	描述
==	检查两个操作数的值是否相等，如果相等则条件为真。
!=	检查两个操作数的值是否相等，如果不相等则条件为真。
>	检查左操作数的值是否大于右操作数的值，如果是则条件为真。
<	检查左操作数的值是否小于右操作数的值，如果是则条件为真。
>=	检查左操作数的值是否大于或等于右操作数的值，如果是则条件为真。
<=	检查左操作数的值是否小于或等于右操作数的值，如果是则条件为真。

• 逻辑运算符

运算符	描述
&&	称为逻辑与运算符。如果两个操作数都非零，则条件为真。
||	称为逻辑或运算符。如果两个操作数中有任意一个非零，则条件为真。
!	称为逻辑非运算符。用来逆转操作数的逻辑状态。如果条件为真则逻辑非运算符将使其为假。

#include <stdio.h>
#include <stdbool.h>
 
int main() {
    bool isTrue = true;
    int a = 10;
    int b = 20;
    if (a && b) {
        printf("条件为真\n");
    }
    return 0;
}

• 赋值运算符

运算符	描述
=	简单的赋值运算符，把右边操作数的值赋给左边操作数
+=	加且赋值运算符，把右边操作数加上左边操作数的结果赋值给左边操作数
-=	减且赋值运算符，把左边操作数减去右边操作数的结果赋值给左边操作数
*=	乘且赋值运算符，把右边操作数乘以左边操作数的结果赋值给左边操作数
/=	除且赋值运算符，把左边操作数除以右边操作数的结果赋值给左边操作数
%=	求模且赋值运算符，求两个操作数的模赋值给左边操作数
<<=	左移且赋值运算符
>>=	右移且赋值运算符
&=	按位与且赋值运算符

#include <stdio.h>
int main() {
    int a = 21;
    int c;
    c += a;
    printf("%d\n", c);
    c *= a;
    printf("%d\n", c);
    return 0;
}

• 其它

运算符	描述	实例
sizeof()	返回变量的大小。	sizeof(a) 将返回 4，其中 a 是整数。
&	返回变量的地址。	&a; 将给出变量的实际地址。
*	指向一个变量。	*a; 将指向一个变量。
? :	条件表达式	如果条件为真 ? 则值为 X : 否则值为 Y

#include <stdio.h>
#include <stdbool.h>
 
int main() {
    int a = 4;
 
    printf("%d\n", sizeof(a));
 
 
    int *ptr = &a;
    printf("a 的值是 %d,ptr的值是%p\n", a, ptr);
 
    a = 10;
    int b = (a == 1) ? 20 : 30;
    printf("b 的值是 %d\n", b);
 
    return 0;
}
 

回到顶部

5.5 if 判断

#include <stdio.h>
#include <stdbool.h>
 
int main() {
 
    int num;
    printf("输入一个数字 : ");
    scanf("%d", &num);
    if (num > 90) {
        printf("优秀");
    } else if (num > 60 && num < 90) {
        printf("及格");
    } else {
        printf("不及格");
    }
 
    return 0;
}

回到顶部

5.6 循环

循环类型	描述
while 循环	当给定条件为真时，重复语句或语句组。它会在执行循环主体之前测试条件。
for 循环	多次执行一个语句序列，简化管理循环变量的代码。
do...while 循环	除了它是在循环主体结尾测试条件外，其他与 while 语句类似。

#include <stdio.h>
#include <stdbool.h>
 
int main() {
 
    int num = 0;
    // while循环
//    while (num<10){
//        printf("%d\n",num);
//        num++;
//    }
 
//do while 循环
//    do {
//        printf("%d\n", num);
//        num++;
//    } while (num < 10);
 
// for 循环
//    for (int i = 0; i < 10; ++i) {
//        printf("%d\n", i);
//    }
 
//死循环
    for (;  ; ) {
        printf("我是死循环");
    };
    return 0;
}
 

回到顶部

5.7 函数

返回值类型 函数名( 参数类型 形参 )
{
  函数体;
}

#include <stdio.h>
 
 
int add(int a, int b) {
    return a + b;
}
 
int main() {
 
    int a = add(10, 10);
    printf("%d", a);
    return 0;
}
 

回到顶部

5.8 字符和字符串

在C语言中没有字符串。

用 字符数组 创造出字符串出来（每个字符占1个字节）。

#include <stdio.h>
 
int main() {
    // 定义字符
    char a = 'a';
    printf("%c\n", a);
    // 定字符串
    char s[]="justin";
    char s1[]= {'j','u','s','t','i','n','\0'};
    printf("%s\n", s);
    printf("%s\n", s1);
 
    return 0;
}

回到顶部

5.9 数组

对于数组来说，内部元素是挨个存放，内存地址相邻。

它可以存储一个固定大小的相同类型元素的顺序集合。数组是用来存储一系列数据，是一系列相同类型的变量

char v2[]= {'j','u','s','t','i','n','\0'};
int v3[3] = {11,22,33};

• 元素固定
• 类型固定（每个元素在内存中占据长度相同）

#include <stdio.h>
 
int main() {
 
    char v3[] = "justin";
    
    printf("第0个位置值：%c，内存地址：%p \n", v3[0], &v3[0]); 
    printf("第1个位置值：%c，内存地址：%p \n", v3[1], &v3[1]); 
    printf("第2个位置值：%c，内存地址：%p \n", v3[2], &v3[2]); 
    
    
    //int a[3];  定义没有初始化
    //int a[3]={1,2,3}; // 定义并初始化
    int a[]={1,2,3}; // 定义并初始化,大小可以不填，但是定义完后，大小也固定
    printf("%d\n",a[0]);
    printf("%d\n",a[1]);
    printf("%d\n",a[2]);
    // 数组大小
    printf("%d",sizeof(a) / sizeof(a[0]));
 
    return 0;
}

# include <stdio.h>
 
int main() {
    int v3[] = {11, 22, 33, 44, 55, 66};  // 每个整型4字节
    printf("第0个位置值：%d，内存地址：%p \n", v3[0], &v3[0]); // 值所在的内存地址 0x00000
    printf("第1个位置值：%d，内存地址：%p \n", v3[1], &v3[1]); // 0x00004
    printf("第2个位置值：%d，内存地址：%p \n", v3[2], &v3[2]); // 0x00008
    return 0;
}

六 指针

指针是存储变量内存地址的变量

回到顶部

6.1 定义指针类型变量和取变量地址

#include <stdio.h>
int main() {
    int v1 = 666;
    int *v2 = &v1;   // & 取地址符，得到是 指针类型（64位操作系统，8字节）
    printf("v2的值为：%p", v2);
 
    return 0;
}

回到顶部

6.2 指针类型变量解引用

#include <stdio.h>
 
 
int main() {
    int v1 = 666;
    int *v2 = &v1;   // & 取地址符，得到是 指针类型（64位操作系统，8字节）
    printf("v2的值为：%p\n", v2);
    printf("v2解引用后：%d\n",*v2);
    return 0;
}

回到顶部

6.3 修改变量的值

#include <stdio.h>
 
 
int main() {
    int v1 = 666;
    int *v2 = &v1;   // & 取地址符，得到是 指针类型（64位操作系统，8字节）
    printf("v2的值为：%p\n", v2);
    printf("v2解引用后：%d\n",*v2);
 
    // 修改v1的值，查看v2
    v1 = 999;
    printf("v1的值为：%p\n", v1);
    printf("v2的值为：%p\n", v2);
    printf("v2解引用后：%d\n",*v2);
 
    return 0;
}
 

回到顶部

6.4 指针的零值和长度

#include <stdio.h>
 
 
int main() {
    //int *v2;   // & 取地址符，得到是 指针类型（64位操作系统，8字节）
    //char *v2;   // & 取地址符，得到是 指针类型（64位操作系统，8字节）
    //long *v2;   // & 取地址符，得到是 指针类型（64位操作系统，8字节）
    long *v2 = NULL;   // & 取地址符，得到是 指针类型（64位操作系统，8字节）
    printf("%p\n", v2);
    printf("%d\n", sizeof(v2));
    if (!v2) {
        printf("指针为空");
    }
 
    return 0;
}
 

回到顶部

6.5 通过指针修改原变量值

#include <stdio.h>
 
 
int main() {
    int a=10;
    int *v2 = &a;
    *v2=99;
    printf("a的值为：%d\n",a);
    printf("v2的值为：%p\n",v2);
 
    return 0;
}
 

回到顶部

6.6 指针类型参数

#include <stdio.h>
 
void changPointA(int *p) {
    *p = 99;
}
 
void changA(int a) {
    a = 99;
}
 
int main() {
    int a = 10;
    int *v2 = &a;
    printf("v2的值为:%p\n", v2);
//    changPointA(v2); //传递到函数中，a的值被改变了
    changA(a); //传递到函数中，a的值没有被改变
    printf("v2的值为:%p\n", v2);
    printf("a的值为:%d\n", a);
 
 
    return 0;
}
 

回到顶部

6.7 数组的指针(指针运算)

#include <stdio.h>
 
int main() {
    int a[3] = {11, 22, 33};
    int *p = &a;
    printf("数组的指针值为:%p\n", p);
    printf("取数组第0个元素方式一：%d\n",a[0]);
    printf("取数组第0个元素方式二：%d\n",*p);
 
    printf("取数组第1个元素方式一：%d\n",a[1]);
    printf("取数组第1个元素方式二：%d\n",*(++p));
 
 
    return 0;
}
 
 
// 指针数组和数组指针
 
#include <stdio.h>
#include <string.h>
 
int main() {
 
    int a[3] = {11, 22, 33};
    int *p = &a;
    printf("数组的指针：%p\n", p);
 
 
 
    int i = 10;
    int x = 20;
    int y = 30;
    int *p1[] = {&i, &x, &y};
    printf("指针数组：%d", **p1);
 
 
    return 0;
}
 

回到顶部

6.8 指针的指针

#include <stdio.h>
int main() {
 
    int a = 100;
    int *p1 = &a;
    int **p2 = &p1;
    int ***p3 = &p2;
    printf("p3的值为:%p\n", p3);
    printf("p2的值为:%p\n", *p3);
    printf("p1的值为:%p\n", **p3);
    printf("a的值为:%d\n", ***p3);
 
 
    return 0;
}
 

回到顶部

6.9 字符串案例

字符串格式化

#include <stdio.h>
 
int main() {
 
    char a[6];
    char *p = &a;
    // 格式化
    sprintf(p, "%c", 'j');
    p += 1;
    sprintf(p, "%c", 'u');
    p += 1;
    sprintf(p, "%c", 's');
    p += 1;
    sprintf(p, "%c", 't');
    p += 1;
    sprintf(p, "%c", 'i');
    p += 1;
    sprintf(p, "%c", 'n');
    printf("值为：%s", a);
 
 
    return 0;
}
 

判断字符串包含关系

#include <stdio.h>
#include <string.h>
 
int main() {
 
    char name[] = "justin is handsome";
 
    // 判断是name中是否存在子序列is
    char *res = strstr(name, "is");
    if (!res) {
        printf("不存在");
    } else {
        printf("存在，从位置 %p 匹配成功的\n", res);
    }
 
 
    return 0;
}
 

字符串相加-复制字符串

#include <stdio.h>
#include <string.h>
#include<stdlib.h>
 
int main() {
 
    char name[]="justin";
    char role[]="teacher";
    char *s = malloc(strlen(name) + strlen(role) + 1); // 申请一个这么大的指针
    strcpy(s, name);  //字符串复制，把name内容复制到s指针上
    strcat(s, role); // 字符串拼接，把s指针后面追加role字符串
    printf(s);
    return 0;
}
 

序号	函数 & 作用
1	strcpy(s1, s2); 复制字符串 s2 到字符串 s1。
2	strcat(s1, s2); 连接字符串 s2 到字符串 s1 的末尾。
3	strlen(s1); 返回字符串 s1 的长度。
4	strcmp(s1, s2); 如果 s1 和 s2 是相同的，则返回 0；如果 s1<s2 则返回小于 0；如果 s1>s2 则返回大于 0。
5	strchr(s1, ch); 返回一个指针，指向字符串 s1 中字符 ch 的第一次出现的位置。
6	strstr(s1, s2); 返回一个指针，指向字符串 s1 中字符串 s2 的第一次出现的位置。

七 结构体

一种用户自定义的数据类型，它允许存储不同类型的数据项

结构体中的数据成员可以是基本数据类型（如 int、float、char 等），也可以是其他结构体类型、指针类型等

回到顶部

7.1 基本使用

#include <stdio.h>
#include <string.h>
#include<stdlib.h>
 
// 定义结构体
struct Person {
    char name[30];
    int age;
};
 
int main() {
    // 使用结构体
    struct Person p1 = {"justin", 18};
    struct Person p2 = {"彭于晏", 18};
    struct Person p3 = {"古天乐", 18};
    printf("p1的名字为：%s\n", p1.name);
    printf("p2的名字为：%s\n", p2.name);
    printf("p3的年龄为：%d\n", p1.age);
 
    // 结构体指针
    struct Person *pointPerson =&p3;
    printf("p3的年龄为：%d\n", (*pointPerson).age);
    printf("p3的姓名为：%s\n", pointPerson->name);
 
    return 0;
}
 

回到顶部

7.1 单向链表

#include <stdio.h>
 
struct Node {
    int data;
    struct Node *next;
};
 
int main() {
 
    struct Node v3 = {33};
    struct Node v2 = {22, &v3};
    struct Node v1 = {11, &v2};
 
    printf("v1的数据为：%d\n", v1.data);                // 11
    printf("v1的下一个元素数据为：%d\n", v1.next->data); // 22
    printf("v1的下一个元素的下一个数据为：%d\n", v1.next->next->data); // 33
 
    return 0;
}
 

回到顶部

7.3 双向链表

#include <stdio.h>
 
struct Person
{
    int data;
    struct Person *next;
    struct Person *prev;
};
 
int main()
{
    struct Person p3 = { 33 };
    struct Person p2 = { 22 };
    struct Person p1 = { 11 };
 
    p1.next = &p2;
 
    p2.next = &p3;
    p2.prev = &p1;
 
    p3.prev = &p2;
 
    printf("p1的值: %d\n", p1.data);
    printf("p2的值: %d\n", p1.next->data);
    printf("p3的值: %d\n", p1.next->next->data);
 
    printf("p3的值: %d\n", p3.data);
    printf("p2的值: %d\n", p3.prev->data);
    printf("p1的值: %d\n", p3.prev->prev->data);
 
    return 0;
}
 

回到顶部

7.4 双向环状链表

# include <stdio.h>
 
struct Person
{
    int data;
    struct Person *next;
    struct Person *prev;
};
 
int main()
{   
    struct Person p3 = { 33 };
    struct Person p2 = { 22 };
    struct Person p1 = { 11 };
    p1.next = &p2;
    p1.prev = &p3;
 
    p2.next = &p3;
    p2.prev = &p1;
 
    p3.prev = &p2;
    p3.next = &p1;
 
    printf("p1的值: %d\n", p1.data);
    printf("p2的值: %d\n", p1.next->data);
    printf("p3的值: %d\n", p1.next->next->data);
 
    printf("p1的值: %d\n", p1.next->next->next->data);
    printf("p2的值: %d\n", p1.next->next->next->next->data);
    printf("p3的值: %d\n", p1.next->next->next->next->next->data);
 
    return 0;
}

八 预处理和头文件

回到顶部

8.1 预处理

预处理，在程序编译之前会先运行的。

# include <stdio.h>
 
# define ME  200
# define SIZE  18
 
int main() {
    int data = 19;
    //ME=99;  // 是常量，不能修改
    printf("%d-%d-%d \n", ME, SIZE, data);
    return 0;
}

# include <stdio.h>
 
# define ADD(x1, x2)(x1+x2+100)
 
int main() {
    int data = ADD(11, 22);
    printf("结果：%d \n", data);
    return 0;
}

# include <stdio.h>
 
# define DB(x1, x2)(x1*x2)
 
int main() {
    int data = DB(2 + 1, 4);
    printf("结果：%d \n", data);  // 结果是6，由于先运行，变成了2+1*4
    return 0;
}

回到顶部

8.2 头文件

项目目录
├── main.c
├── utils.c
└── utils.h

// utils.h
 
int add(int a,int b);

// utils.c
 
int add(int a,int b){
    return a+b;
}

//main.c
 
# include <stdio.h>
# include "utils.h"
 
int main() {
    int data = add(100,200);
    printf("结果：%d \n", data);
    return 0;
}

比如后期，我们要进行JNI开发时，我们会在自己的c文件用去引入C语言中提供、JNI中提供一些头文件，才能使用头文件中的功能。

回到顶部

8.3 Python源码中头文件的使用

https://www.python.org/downloads/source/
    
# github上cpython源码：https://github.com/python/cpython
#Objects 下会有咱们得列表，字典等结构体
https://github.com/python/cpython/tree/main/Objects# 
 
# 列表：的源代码
https://github.com/python/cpython/blob/main/Objects/listobject.c
    
# 列表的头文件
https://github.com/python/cpython/blob/main/Include/listobject.h