文章很多处理论，没办法写出来，（linux的一些理论问题，我有时间后，会逐个解决）

文章大多数的理论来字这个链接，

C语言快速入门-C语言基础知识-CSDN博客

一. linux（Ubuntu）

1. 基础命令（未完成，稍后补）

1.1. vim

vim是一个文本编辑器，挺强的

1.1.1 安装vim

（1）检查是否已安装 Vim：

vim --version

• 如果显示版本信息，说明已安装。

• 如果提示未安装，继续下一步。

（2）安装完整版 Vim：

sudo apt update && sudo apt install vim

• Ubuntu 默认可能安装的是 vim-tiny（精简版），建议替换为完整版。

1.1.2 Vim 的基本使用

Vim 是一个模态编辑器，分为 普通模式（Normal Mode）、插入模式（Insert Mode） 和 命令行模式（Command-Line Mode）。 

---

1.1.3 基本操作流程

1. 启动 Vim（打开/新建文件：）

vim 文件名  # 打开文件（若文件不存在则新建）

 2.进入插入模式

• 按下 i：在光标前进入插入模式。

• 按下 a：在光标后进入插入模式。

• 按下 o：在下一行插入新行并进入插入模式。

3.推出插入模式

• 按下 Esc 键返回普通模式。

4.保存与退出

• :w：保存文件。

• :q：退出 Vim。

• :wq 或 :x：保存并退出。

• :q!：强制退出（不保存修改）。

1.2 gdb工具

1.2.1 如何调试

1.2.2 设置断点（p，n，continue）

1.3 vsc中的调试

二. c语言基础知识

1 基础语法

-g：          使用该参数编译可以执行文件，得到调试表。
gdb ./a.out
list：         list 1 列出源码。根据源码指定 行号设置断点。
b：            b 20 在 20 行位置设置断点。
run/r:         运行程序
n/next:      下一条指令（会越过函数）
s/step:      下一条指令（会进入函数）
p/print：    p i 查看变量的值。
continue：继续执行断点后续指令。
finish：      结束当前函数调用。
quit：        退出 gdb 当前调试。

2 二进制（符号位）（结合数据类型的范围来讲）（从Linux来讲）

1.源码

2.反码

3.补码

负整数存的是补码

3 数据类型

1.数据类型

char           //字符数据类型

short          //短整型

int              //整形

long           //长整型

long long   //更长的整形

float           //单精度浮点数

double       //双精度浮点数

C语言中没有String字符串类型吗？？？？

c语言中string用char的数组形式来表示。下方代码有举例。

#include <stdio.h>int main() {char a = 'a'; // 字符型变量 achar a1[] = {'h', 'e', 'l', 'l', 'o', '\0'}; // 字符型数组 a1，注意加上结束符 '\0'char str1[] = "Hello"; // 字符数组表示字符串，即java中的stringchar *str2 = "World";  // 字符指针表示字符串short b = 10; // 短整型变量 bint c = 10; // 整型变量 clong d = 10; // 长整型变量 dfloat f = 10.0f; // 单精度浮点数 fdouble g = 10.00000; // 双精度浮点数 g// 输出变量的值printf("字符 a: %c\n", a);printf("字符数组 a1: %s\n", a1);printf("%s %s\n", str1, str2); printf("Length of str1: %zu\n", strlen(str1));//输出str1的长度，即为5printf("短整型 b: %d\n", b);printf("整型 c: %d\n", c);printf("长整型 d: %ld\n", d);printf("单精度浮点数 f: %.2f\n", f);printf("双精度浮点数 g: %.5f\n", g);return 0;}

2.intger型

int              //整形

#include <stdio.h>  // 引入stdio.h头文件以使用printf函数
#include <limits.h> // 引入limits.h头文件以获取取数据类型的范围
int main()
{/* 数据类型*/int a = 10;                            // 整数类型 （设置变量默认类型）float b = 3.14f;                       // 浮点数类型 （设置变量默认类型）char c = 'A';                          // 字符类型 （设置变量默认类型）short d = 5;                           // 短整型 （设置变量默认类型）long e = 100000L;                      // 长整型 （设置变量默认类型）long long f = 10000000000LL;           // 长长整型 （设置变量默认类型）unsigned int g = 20;                   // 无符号整数类型 （设置变量默认类型）unsigned char h = 'B';                 // 无符号字符类型 （设置变量默认类型）unsigned short i = 10;                 // 无符号短整型 （设置变量默认类型）unsigned long j = 100000UL;            // 无符号长整型 （设置变量默认类型）unsigned long long k = 10000000000ULL; // 无符号长长整型 （设置变量默认类型）// 打印变量的值printf("a = %d\n", a); // 注意：%d用于打印整数printf("b = %f\n", b); // 注意：%f用于打印浮点数// 打印数据类型的范围printf("int 最小 = %d,int 最大 = %d", INT_MIN, INT_MAX);                                  // 打印int类型的最小值printf("\nfloat 最小 = %e,float 最大 = %e", __FLT_MIN__, __FLT_MAX__);                    // 打印float类型的最小值和最大值printf("\nchar 最小 = %d,char 最大 = %d", CHAR_MIN, CHAR_MAX);                            // 打印char类型的最小值和最大值printf("\nshort 最小 = %d,short 最大 = %d", SHRT_MIN, SHRT_MAX);                          // 打印short类型的最小值和最大值printf("\nlong 最小 = %ld,long 最大 = %ld", LONG_MIN, LONG_MAX);                          // 打印long类型的最小值和最大值printf("\ndouble 最小 = %e,double 最大 = %e", __DBL_MIN__, __DBL_MAX__);                  // 打印double类型的最小值和最大值printf("\nlong long 最小 = %lld,long long 最大 = %lld", LLONG_MIN, LLONG_MAX);            // 打印long long类型的最小值和最大值printf("\nunsigned int 最小 = %u,unsigned int 最大 = %u", 0, UINT_MAX);                   // 打印unsigned int类型的最小值和最大值printf("\nunsigned char 最小 = %u,unsigned char 最大 = %u", 0, UCHAR_MAX);                // 打印unsigned char类型的最小值和最大值printf("\nunsigned short 最小 = %u,unsigned short 最大 = %u", 0, USHRT_MAX);              // 打印unsigned short类型的最小值和最大值printf("\nunsigned long 最小 = %lu,unsigned long 最大 = %lu", 0, ULONG_MAX);              // 打印unsigned long类型的最小值和最大值printf("\nunsigned long long 最小 = %llu,unsigned long long 最大 = %llu", 0, ULLONG_MAX); // 打印unsigned long long类型的最小值和最大值return 0;
}

3. bool型

非真即假

#include <stdio.h>
int main(int argc, char const *argv[])
{/* bool */// 使用if判断为真，条件代码执行，非真，条件代码不执行if (0){printf("0为假\n");}else{printf("0为真\n");}if (1){printf("1为真\n");}else{printf("1为假\n");}return 0;
}

4. float浮点型

float           //单精度浮点数

#include <stdio.h>  // 引入stdio.h头文件以使用printf函数
#include <limits.h> // 引入limits.h头文件以获取取数据类型的范围
#include <float.h>  // 引入float.h头文件以获取浮点数类型的范围int main(int argc, char const *argv[])
{/* 默认实型（浮点型，小数）为浮点型，默认整数为int型*/// float类型// float类型的精度为6位，范围为-3.4E+38到3.4E+38float a = 3.14f;                                                     // 单精度浮点数类型，占位符%f，精确度为6位printf("a = %f\n", a);                                               // 注意：%f用于打印浮点数，默认打印小数点后6位printf("float 最小 = %f,float 最大 = %f", __FLT_MIN__, __FLT_MAX__); // 打印float类型的最小值和最大值printf("\nfloat 精度 = %d", FLT_DIG);                                // 打印float类型的精度，6位，科学计数法%fprintf("a=%.17f,float类型的字节数为=%lu\n", a, sizeof(float));       // 打印float类型的长度，小数点后六位不精确// double类型// double类型的精度为15位，范围为-1.7E+308到1.7E+308double b = 3.1455555555555555555;                                        // 双精度浮点数类型，占位符%lf，精确度为15位，默认打印小数点后6位printf("\nb = %lf\n", b);                                                // 注意：%lf用于打印双精度浮点数printf("double 最小 = %lf,double 最大 = %lf", __DBL_MIN__, __DBL_MAX__); // 打印double类型的最小值和最大值printf("\ndouble 精度 = %d", DBL_DIG);                                   // 打印double类型的精度，15位，科学计数法%lfprintf("b=%.16lf,double类型的字节数为=%lu\n", b, sizeof(double));        // 打印double类型的长度，小数点后15位不精确// long double类型// long double类型的精度为19位，范围为-1.1E+4932到1.1E+4932long double c = 3.1455555555555555555555;                                            // 长双精度浮点数类型，占位符%Lf，精确度为19位,默认打印小数点后6位printf("\nc = %Lf\n", c);                                                            // 注意：%Lf用于打印长双精度浮点数printf("long double 最小 = %Le,long double 最大 = %Le", __LDBL_MIN__, __LDBL_MAX__); // 打印long double类型的最小值和最大值printf("\nlong double 精度 = %d", LDBL_DIG);                                         // 打印long double类型的精度，19位，科学计数法%Lfprintf("c=%.20Lf,long double类型的字节数为=%lu\n", c, sizeof(long double));          // 打印long double类型的长度，小数点后19位不精确//printf("c=%20.10f\n", a); // 打印float类型的长度return 0;
}

5. char (string)型

char           //字符数据类型

#include <stdio.h>int main()
{/*// 字符charchar c = 'A';printf("%c\n", c); // 输出字符，终端输出为A// 字符输出为ascll码printf("%d\n", c);// 字符串char str[] = "Hello, World!";printf("%s\n", str);*/// 转移符//  \n 换行printf("Hello\nWorld\n");// \t 制表符printf("Hello\tWorld\n");printf("\173\n"); // 173是八进制表示的123printf("\x41\n"); // 41是十六进制表示的65// \\ 反斜杠printf("反斜杠：""a\\b\n");// \' 单引号printf("单引号：", "a\'b\n");// \" 双引号printf("双引号：,""a\"b\n");// \0 字符串结束符char str2[] = "a, b!\0";printf("%s\n", str2);// \b 退格符printf("Hello\bWorld\n");// \r 回车符printf("Hello\rWorld\n");return 0;
}

4 变量/常量

1 变量

1.1 定义变量

简而言之变量即使可以更改的量，其数值可以被更改。

1.2 变量的分类 

1.全局变量

  （1）即作用于代码运行全过程的变量

2.局部变量

  （2）即作用于部分代码块的变量

#include <stdio.h>
// 全局变量
int globalVar = 10; // 全局变量，作用域为整个文件
void function() {// 局部变量int localVar = 5; // 局部变量，作用域仅限于此函数内printf(" 函数内 局部变量 localVar 的值: %d\n", localVar);printf(" 函数内 全局变量 globalVar 的值: %d\n", globalVar);
}int main() {printf("全局变量 globalVar 的值: %d\n", globalVar); // 可以访问全局变量function();//调用上方的函数// printf("局部变量 localVar 的值: %d\n", localVar); // 这行代码会报错，因为 localVar 作用域仅限于 function 函数return 0;
}

1.3. 变量的使用

使变量等于输入两个值，使这两个变量进行加减乘除，结果取小数点后两位。

#include <stdio.h>
int main() {// 定义变量float num1, num2; // 用于存储输入的两个数float sum, difference, product, quotient; // 用于存储运算结果// 提示用户输入两个数，scanf的标准用法，于printf很相似printf("请输入第一个数: ");scanf("%f", &num1); // 读取第一个数printf("请输入第二个数: ");scanf("%f", &num2); // 读取第二个数// 进行运算sum = num1 + num2; // 加法difference = num1 - num2; // 减法product = num1 * num2; // 乘法quotient = num1 / num2; // 除法（注意：需要确保 num2 不为 0）// 输出结果，%.2f即为取余，小数点后两位，%.3f即为小数点后3位，以此类推。printf("加法结果: %.3f\n", sum);printf("减法结果: %.3f\n", difference);printf("乘法结果: %.3f\n", product);// 除法结果的输出需要检查除数是否为0if (num2 != 0) {printf("除法结果: %.2f\n", quotient);} else {printf("除法结果: 无法除以零\n");}return 0;
}

输出：

1.4. 变量的作用域与生命周期 

作用域：

作用域（scope）是程序设计概念，通常来说，一段程序代码中所用到的名字并不总是可用的

而限定这个名字的可用性的代码范围就是这个名字的作用域。

1. 局部变量的作用域是变量所在的局部范围。

2. 全局变量的作用域是整个代码运行过程。

生命周期：

变量的生命周期指的是变量的创建到变量的销毁之间的一个时间段

1. 局部变量的生命周期是：进入作用域生命周期开始，出作用域生命周期结束。

2. 全局变量的生命周期是：整个程序的生命周期，同理。

1.5. 定量 / 常量

1 常量定义

简而言之，定量即使不变的量。

2 常量类型

1. 字面常量

2. const 修饰的常变量（java中常用）

3. #define 定义的标识符常量

4. 枚举常量

#include <stdio.h>// 使用 #define 定义标识符常量
#define PI 3.14159 // 圆周率常量// 定义枚举常量
enum Color {RED,    // 默认第一个为0，以此类推。GREEN,  // GREEN = 1BLUE    // BLUE = 2
};int main() {// 字面常量int a = 10; // 整数字面常量float b = 5.5; // 浮点数字面常量// const 修饰的常量const int MAX_VALUE = 100; // 最大值常量，不能被修改// 输出各个常量的值printf("字面常量 a: %d\n", a);printf("字面常量 b: %.2f\n", b);printf("标识符常量 PI: %.5f\n", PI);printf("const 常量 MAX_VALUE: %d\n", MAX_VALUE);// 使用枚举常量enum Color myColor = GREEN; // 赋值为枚举常量printf("枚举常量 myColor: %d\n", myColor); // 输出枚举常量的整数值return 0;
}

输出：

 5. 字符串+转义字符+注释+格式修饰符

1. 字符串

1. 即Java中的String，用来表示多个字符在一起的样子。但是C中没有String的概念，所以字符串用char【】（字符型数组）来表示。

2. 下方的代码，用了四种方式来表示String，具体看代码注释，写的很清楚。

//可以简单认为include与java中的import是同一个意思。
#include <stdio.h>   // 引入标准输入输出库，提供输入输出函数，如printf和scanf
#include <stdlib.h>  // 引入标准库，包含内存分配（如malloc、free）、进程控制和转换等函数
#include <string.h>  // 引入字符串处理库，提供字符串操作函数，如strcpy、strlen等int main() {// 1. 使用字符数组定义字符串char str1[] = "hello world"; // 字符数组，自动添加'\0'char str11[] ={'0','1','2','3','4','\0'}; // 字符数组，自动添加'\0'<规范>// 2. 使用字符指针定义字符串const char *str2 = "hello world"; // 字符指针指向字符串常量// 3. 动态内存分配，malloc 返回的是 void* 类型的指针，表示它可以指向任何类型的内存。//指针相当于一种特殊类型的变量char *str3 = (char *)malloc(12 * sizeof(char)); // 开辟一个char类型，12长度的内存空间变量为str3这个指针变量if (str3 == NULL) { // 检查内存是否分配存在printf("内存分配失败\n");return 1; // 返回1表示异常，并输出内存分配失败}strcpy(str3, "hello world"); // // 输出所有字符串printf("%s\n", str1); // 输出字符数组printf("%s\n", str11); // 输出字符数组printf("%s\n", str2); // 输出字符指针printf("%s\n", str3); // 输出动态分配的字符串// 释放动态分配的内存free(str3);return 0; // 返回0表示程序正常结束
}

输出：

2. 转义字符

转义字符 释义（转义字符顾名思义就是转变意思。）

\？      在书写连续多个问号时使用，防止他们被解析成三字母词

\'         用于表示字符常量'

\"        用于表示一个字符串内部的双引号

\\        用于表示一个反斜杠，防止它被解释为一个转义序列符。

\a       警告字符，蜂鸣

\b       退格符

\f        进纸符

\n       换行

\r        回车

\t        水平制表符

\v       垂直制表符

\ddd   ddd表示1~3个八进制的数字。 如： \130 X

\xdd   dd表示2个十六进制数字。 如： \x30 0

 举例：

仔细看注释。

#include<stdio.h>
#include<string.h>
// strlen - string length - 求字符串长度
int main()
{printf("%d\n", strlen("abcdef"));printf("%d\n", strlen("abcdefg")); // 输出字符串 "abcdef" 的长度// \62被解析成一个转义字符printf("%d\n", strlen("c:\test\628\test.c"));//会输出错误，因为系统编译会把\t认识为转义符printf("%d\n", strlen("c:\\test\\628\\test.c")); // 使用双反斜杠表示反斜杠，就没有问题了。return 0;
}

详细使用方法： 

#include <stdio.h>int main() {// 1. \? - 表示问号字符      原因: \? 不会被解析为转义字符，直接输出问号。 printf("这是一个问号: \?\n"); // 输出: 这是一个问号: ?// 2. \' - 表示单引号字符    原因: \' 被解析为单引号字符，用于在字符串中包含单引号。printf("这是一个单引号: \'\n"); // 输出: 这是一个单引号: '// 3. \" - 表示双引号字符    原因: \" 被解析为双引号字符，用于在字符串中包含双引号。printf("这是一个双引号: \"\n"); // 输出: 这是一个双引号: "// 4. \\ - 表示反斜杠字符    原因: \\ 被解析为一个反斜杠字符，用于在字符串中包含反斜杠。printf("这是一个反斜杠: \\\n"); // 输出: 这是一个反斜杠: \// 5. \a - 表示警告音（响铃）原因: \a 表示响铃字符，某些终端或系统可能会发出声音。printf("这将响铃: \a\n"); // 可能会发出警告音（依赖于终端设置）// 6. \b - 表示退格符        原因: \b 将光标移动到前一个字符位置，覆盖该字符。printf("这是一个退格符: Hello\bWorld\n"); // 输出: HelloWorld（“Hello”中的最后一个字母被删除）// // 7. \f - 表示换页符        原因: \f 在某些终端中可能会导致换页，但在其他终端中可能没有明显效果。printf("这是一个换页符: Hello\fWorld\n"); // 输出: Hello（在某些终端中可能表现为换页）// 8. \n - 表示换行符        原因: \n 将光标移动到下一行，输出内容在新行显示。printf("这是一个换行符: Hello\nWorld\n"); // 输出: Hello//                                        //         World// 9. \r - 表示回车符        原因: \r 将光标移动到行首，后续字符会覆盖当前行的内容。printf("这是一个回车符: Hello\rWorld\n"); // 输出: World（“Hello”被覆盖）// 10. \t - 表示水平制表符   原因: \t 插入一个水平制表符的空格，增加字符之间的间距。printf("这是一个制表符: Hello\tWorld\n"); // 输出: Hello    World（“Hello”和“World”之间有一个制表符的空格）// 11. \v - 表示垂直制表符   原因: \v 在某些终端中可能表现为换行，但在其他终端中可能没有明显效果printf("这是一个垂直制表符: Hello\vWorld\n"); // 输出: Hello（可能会在某些终端中表现为换行）// 12. \ddd - 表示八进制数对应的字符    原因: 八进制数表示的字符在ASCII表中对应的字符。printf("这是一个八进制字符: \101\n"); // 输出: A（八进制101对应的字符是'A'）// 13. \xdd - 表示十六进制数对应的字符  原因: 十六进制数表示的字符在ASCII表中对应的字符。printf("这是一个十六进制字符: \x41\n"); // 输出: A（十六进制41对应的字符是'A'）return 0;}}}

3. 注释

1. 代码中有不需要的代码可以直接删除，也可以注释掉

2. 代码中有些代码比较难懂，可以加一下注释文字

vs Code 分为单行注释与多行注释，自己搜索，默认的我也忘了。嘿嘿嘿。

4. 格式说明符

格式说明符：

%d 或 %i   解释：输出或输入有符号十进制整数。

%u             解释：输出或输入无符号十进制整数。

%f              解释：输出或输入十进制浮点数（float）。

%lf             解释：输出或输入双精度浮点数（double）。

%c             解释：输出或输入单个字符。

%s             解释：输出或输入字符串（字符数组）。

%p             解释：输出指针的地址（内存地址）。

%o             解释：输出无符号八进制整数。

%x 或 %X  解释：输出无符号十六进制整数。%x 使用小写字母，%X 使用大写字母。

%e 或 %E  解释：以科学计数法输出浮点数。%e 使用小写字母 e，%E 使用大写字母 E。

%g 或 %G  解释：根据数值的大小自动选择使用 %f 或 %e 的格式输出浮点数。%g 使用小写字母，

%G             解释：使用大写字母。

格式说明符代码解释 ：

#include <stdio.h>
int main() {// 1. %d 或 %i - 输出或输入有符号十进制整数    // 原因: %d 用于打印有符号整数，负数会正常显示。int signedInt = -42;printf("有符号十进制整数: %d\n", signedInt); // 输出: 有符号十进制整数: -42// 2. %u - 输出或输入无符号十进制整数    // 原因: %u 用于打印无符号整数，确保不会显示负号。unsigned int unsignedInt = 42;printf("无符号十进制整数: %u\n", unsignedInt); // 输出: 无符号十进制整数: 42// 3. %f - 输出或输入十进制浮点数（float）    // 原因: %f 默认输出六位小数，适用于浮点数。float floatNum = 3.14f;printf("十进制浮点数: %f\n", floatNum); // 输出: 十进制浮点数: 3.140000// 4. %lf - 输出或输入双精度浮点数（double）    // 原因: %lf 用于打印双精度浮点数，默认输出六位小数。double doubleNum = 3.141592653589793;printf("双精度浮点数: %lf\n", doubleNum); // 输出: 双精度浮点数: 3.141593// 5. %c - 输出或输入单个字符    // 原因: %c 用于打印单个字符。char character = 'A';printf("单个字符: %c\n", character); // 输出: 单个字符: A// 6. %s - 输出或输入字符串（字符数组）    // 原因: %s 用于打印字符串，直到遇到空字符 '\0'。char str[] = "Hello, World!";printf("字符串: %s\n", str); // 输出: 字符串: Hello, World!// 7. %p - 输出指针的地址（内存地址）    // 原因: %p 用于打印指针的地址，通常以十六进制格式输出。int *ptr = &signedInt;printf("指针地址: %p\n", (void *)ptr); // 输出: 指针地址: 0x7ffeedc3a5b4（地址会因运行而异）// 8. %o - 输出无符号八进制整数    // 原因: %o 用于打印无符号整数的八进制表示。printf("无符号八进制整数: %o\n", unsignedInt); // 输出: 无符号八进制整数: 50// 9. %x 或 %X - 输出无符号十六进制整数    // 原因: %x 用于打印小写十六进制，%X 用于打印大写十六进制。printf("无符号十六进制整数 (小写): %x\n", unsignedInt); // 输出: 无符号十六进制整数 (小写): 2aprintf("无符号十六进制整数 (大写): %X\n", unsignedInt); // 输出: 无符号十六进制整数 (大写): 2A// 10. %e 或 %E - 以科学计数法输出浮点数    // 原因: %e 和 %E 用于以科学计数法格式打印浮点数。printf("科学计数法 (小写): %e\n", floatNum); // 输出: 科学计数法 (小写): 3.140000e+00printf("科学计数法 (大写): %E\n", floatNum); // 输出: 科学计数法 (大写): 3.140000E+00// 11. %g 或 %G - 根据数值的大小自动选择格式输出浮点数    // 原因: %g 和 %G 根据数值的大小选择使用 %f 或 %e 格式输出。printf("自动选择格式 (小写): %g\n", doubleNum); // 输出: 自动选择格式 (小写): 3.14159printf("自动选择格式 (大写): %G\n", doubleNum); // 输出: 自动选择格式 (大写): 3.14159return 0;
}