Linux-C语言基础总结（全）

最新推荐文章于 2025-05-13 13:09:10 发布

JCBP_

最新推荐文章于 2025-05-13 13:09:10 发布

阅读量1.8k

点赞数 61

CC 4.0 BY-SA版权

文章标签： c语言开发语言汇编 linux vscode

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文链接：https://blog.csdn.net/JCBP_/article/details/146026034

Linux-C语言基础总结（全）
- 第一周
  - 一、Linux命令
    - 1.基本知识
      - 根目录： /
      - 家目录: /home/hq ~
      - hq 用户名 whoami
      - @ 间隔符
      - ubuntu 主机名 hostname
      - ：间隔符
      - :和$中间位置：当前路径 pwd
      - $ 输入提示符
      - 默认在家目录 /home/hq
      - 绝对路径：从根目录开始逐级向下 /home/hq/a/b/c
      - 相对路径：以当前位置为参照找上一级或下一级 a/b/c
      - $ : 普通用户
      - #: 超级用户 root
    - 2.新建
      - mkdir 文件夹名：创建文件夹
      - touch 文件：创建普通文件（带后缀名）
      - 连级创建：mkdir -p 需要创建的路径
      - 同时新建多个文件夹：mkdir a b c 名字中间空格隔开
      - 同时新建多个文件：touch file1.c file2.c
      - 多层嵌套：mkdir -p 122/123/124
      - 相同路径下，不能创建同名文件夹，会报错。
    - 3查看
      - ls：显示当前路径下的文件
      - ls -l：显示当前路径下文件的详细信息
      - ls -a: 显示当前路径下的所有文件，包含隐藏文件.
      - ls -al：显示当前路径下所有文件包含隐藏文件的详细信息
        通过颜色区分文件类型
        蓝色：文件夹
        白色：普通文件
        绿色：可执行文件
      - 文件类型 7种 bcd-lsp
        b 块设备文件 /dev
        c 字符设备文件键盘，鼠标 /dev/input
        d 目录文件文件夹
        - 普通文件 .c .h .txt
        l 软链接文件 <LinuxC高级>
        s 套接字文件 <网络编程>
        p 管道文件 <IO>
      - 文件权限
        rwx ：可读可写可执行 r-- ：可读不可写不可执行(只读)
        rwx rwx rwx 自己组内其他
        r:4 w:2 x:1 -:0
        rwx:7 r-x:5
        修改权限：chmod 777 文件、文件夹
        显示内容：
        -rw-rw-r-- 1 hq hq 0 Dec 23 17:53 1.txt
        第一列：当前文件的类型以及权限
        第二列：连接数（当前文件中包含几个文件夹）
        第三列：用户名
        第四列：组名
        第五列：文件大小字节
        第六七八列：最后修改的时间最后一列：文件名
    - 4.路径切换
      - cd 路径：切换到当前目录下的一个路径
      - cd ：直接切换到家目录
      - cd ~：切换到家目录
      - cd .. :切换到上一级目录
      - cd . :在当前目录下切换，没有效果的
      - . :当前路径
      - ..:上一级目录
      - cd / :切换到根目录
    - 5.快捷键
      - ctrl+shift+'+':终端窗口放大
      - ctrl+'-':缩小
      - ctrl+'l':清屏
      - tab：自动补全
      - 切换中英文：ctrl + 空格
      - 终止程序：ctrl + ‘c’
      - 上下键：可以查找之前敲过的命令
      - 在代码中输入main，按下tab键，自动补全main函数
      - ctrl+'/':单行注释代码 ctrl + 'shift'+'a':多行注释代码
    - 6.删除
      - rm 普通文件：删除文件
      - rm -r 文件夹:删除文件夹
    - 7.复制
      - cp 文件名路径：复制文件
      - cp 文件夹路径 -r ：复制文件夹
    - 8.移动重命名改名
      - 移动：mv 文件/文件夹路径：移动文件或文件夹
      - 重命名： mv 旧名称新名称
      - 移动时改名：mv 旧名称路径 / 新名称
  - 二、编译
    - 1.编程语言的发展历程
      - 机器语言：01010101010
      - 汇编语言：二进制的文本形式
      - 高级语言：C语言 java c++（计算机不能直接看懂）
    - 2.vi编辑器
      - 打开：vi 文件名
      - 三种模式
        命令行模式：此模式下只能进行一些特定指令的操作，默认进入此模式
        插入模式（编辑模式）：可以编写内容
        底行模式：进行一些特定指令的操作（退出）
      - 模式之间的切换
        命令行模式 ---a/i/o--> 插入模式 ---esc--> 命令行模式
        命令行模式 ---shift+：/ 空格----> 底行模式
      - 命令行
        复制：yy 多行 nyy（n:表示的是行数）
        删除（剪切）：dd ndd
        粘贴：p
        撤销：u
        反撤：ctrl+r
        光标的移动：移动到首行：gg 移动到末行：G 移动到行首：0 移动到行尾：$
        整理代码的格式：gg=G
      - 底行模式
        指定行的复制：5,10y
        指定行的删除：5,10d
        保存：w
        退出：q
        保存并退出：wq
        暂时退出：！
        查找：/str
        替换: s/str1/str2 将光标所在行的第一个str1替换成str2
        全文替换：%s/str1/str2 /g
        设置行号：set nu
        取消行号：set nonu
        取消高亮：nohl
    - 3.简单的编辑流程
      - 创建一个c程序文件：touch hello.c
      - 打开此文件：vi hello.c / code hello.c
      - 写代码
      - 编译代码：gcc 文件名---> gcc hello.c （使用gcc编译器，编译.c文件，默认生成a.out可执行文件）
      - 执行代码：./a.out
    - 4.gcc编译器
      - 四步：1.预处理 2、编译 3、汇编 4、链接
      - 1、预处理：删除注释，展开头文件，替换宏定义
      - 命令：gcc -E hello.c -o hello.i
      - 2、编译检查语法错误，有错报错，没有问题转换为汇编语言文件
      - 命令：gcc -S hello.i -o hello.s
      - 3、汇编将汇编文件转成二进制文件
      - 命令： gcc -c hello.s -o hello.o
      - 4、链接链接库文件最终生成机器可以识别的可执行文件
      - 命令： gcc hello.o -o hello 执行：./hello
  - 三、C语言
    - 1.计算机数据表示形式
      - 数值型数据
        二进制：0b开头八进制：0或0o开头十六进制：0x开头
      - 非数值型数据
        '\0' 0 字符串结束标志
        '\n' 10 换行
        ' ' 32 空格
        '0' 48 字符0
        'A' 65
        'a' 97
        
        '2' - 48 = 2
        'A' + 32 = 'a'
        'a' - ' ' = 'A'
        字符型数字转成数值型数据：字符0-48=数字0
        字符型数据-48=数值型数据
        大小写转换：A:65 ---> a:97
        大写转小写：大写字母+32=小写字母
        小写转大写：小写字母-32=大写字母
      2.词法符号
      - 分类
        关键字标识符运算符分隔符标点符号
      - 关键字 32
        存储类型：auto（自动） static(静态) extern（外部引用） register（寄存器）
        数据类型：char(字符) short(短整型) int(整型) long(长整型) float(单精度浮点型) double(双精度浮点型) signed(有符号) unsigned(无符号)
        构造类型：struct(结构体) union(共用体） enum(枚举)
        选择类型：if（判断） else(否则) switch case default
        循环语句：for while goto do break continue
        其他类型：void（空） typedef(重定义) const (常量化) sizeof(计算数据的空间大小) volatile(防止编译器优化) return（返回值）
      - 标识符
        标识符用于给变量宏名函数名重定义名
        命名规则： 1.由数字字母下划线组成 2.数字不能开头 3.不能和关键字重名 4.见名知义
      - 变量
        概念：在程序的运行过程中会发生变化的数据定义格式：存储类型（auto 省略不写）数据类型变量名
      - 运算符
        算术运算符
        + - * / % ++ -- /
        两个整数相除，结果会自动取整
        int a= 9 / 2= 4 // 4.5
        float a= 9/2； a=4.00000
        float a=9.0/2 ;a=4.5000
        
        逻辑运算符
        && 逻辑与：全真则真，一假则假
        || 逻辑或：一真则真，全假则假
        ! 逻辑非：非真即假，非假即真
        截断法则：逻辑与运算中，前边表达式结果为假，后边表达式不再执行，直接返回假逻辑或运算中，前边表达式结果为真，后边表达式不再执行，直接返回真
        
        位运算符
        二进制数 0 1
        & 位与：全1则1，有0则0
        | 位或：有1则1，全0则0
        ^ 异或：相同为0，不同为1
        ~ 取反：0变1,1变0
        << 左移
        >> 右移
        整数在存储时是以补码进行存储
        
        运算用补码进行运算，再转为原码。
        负数补码转反码：-1。
        左移快捷方式：-6 << 3 ---> -6*2^3=-48
        右移快捷方式：-32 >> 2 ---> -32/2^2=-8 如果除不尽的话，需要向下取整
        
        关系运算符
        > < >= <= == !=
        
        赋值运算符
        = += *= -= /=
        
        三目运算
        单目运算符：使用此符号运算时只需要一个操作数
        双目运算符：使用此符号运算时只需要两个操作数
        三目运算符：使用此符号运算时只需要三个操作数
        三目运算符（条件运算）： ?:
        语法：表达式1？表达式2：表达式3
        运算规则：判断表达式1是否成立？如果成立执行表达式2（：前面部分），如果不成立执行表达式3
        
        运算符优先级
        单目运算符 ! ~ ++ --
        算术运算符 * / % + -
        移位运算符 << >>
        关系运算符 < <= > >= == !=
        位与运算符 &
        异或运算符 ^ |
        逻辑运算符 && ||
        条件运算符？：
        赋值运算符 = += *= /= %= ...
        口诀：单算移关与异或逻条赋。单目运算，从右向左单条赋。逗号运算符优先级最低。
        
        置1/0公式
        置一公式：a|(1<<n)
        置零公式：a&(~(1<<n)) a=5===>101 010 5|（1<<1）=== 5|2 = 111
    - 3.变量
      - 概念:在程序的运行过程中会发生变化的数据
      - 定义:存储类型数据类型变量名
      - 数据类型
      - 变量分类
        全局变量：定义变量时定义在函数外部
        局部变量：定义变量时定义在函数内部
    - 4.常量
      - 概念:在程序的运行过程中不会发生变化的数据
      - 分类
        字符型常量
        使用' '引起来的数据都称之为字符型常量。
        'a'--->字符a
        '0'--->字符0
        '\n'--->换行符
        ' '只能引起来一个数据（一个字母一个数字一个符号）
        \ :代表转义，后面会跟随八进制十六进制一些字母符号；
        \?--->文本？
        ' \' '--->字符引号
        ' \\ '--->字符 \
        '\x41'--->字符A--->'A'--->'\101'
      - 字符串常量
        对于字符串数据程序会在最后添加\0，做为字符串结束的标志，"abc"---->3个占4个字节空间。
        "hello"--->字符串hello ---> 'h' 'e' 'l' 'l' 'o'。
        使用" "引起来的数据称之为字符串常量。
        整型常量
        int存储
        
        浮点型常量
        一般使用float存储
        
        指数常量
        3*10^2--->3e2 5*10^20--->5e20
        
        标识常量
        宏定义：起到标识作用，宏替换、宏代替
        定义格式：#define 宏名（一般大写）常量或者表达式
        特点：使用宏时，只做单纯替换，不进行计算
        #define N 2
        #define M N+3 // 2+3
        #define NUM N+M/2+1 // 2+2+3/2+1
        void main()
        { int a = NUM; // 6
        printf("%d\n",a); // 6 }
    - 5.输入输出
      - 按照字符输入输出
        函数：三要素：功能参数返回值
        getchar（）
        返回值：你输入的字符的ascii（int 类型）
        int a=getchar(); //输入A
        printf("%d\n",a);//输出65
        
        参数：没有参数
        功能：按照字符输入（从终端获取一个字符）
        putchar（）
        功能：向终端输出一个字符
        参数：你要输出的字符的ascii值，也可以写字符
        返回值：输出字符的ascii值
        putchar(97);//输出a
        putchar('\n');//换行
        
        按照格式输入输出
        int printf(const char *format, ...);
        功能：按照某种格式向终端输出一串信息
        参数：一个或者多个，一个字符串，用于填写想要呈现的信息内容，后续参数由前期字符串中的格式的个数决定。
        返回值：输出字符的个数。
        格式： int %d 整数
        float %f
        double %lf
        char %c
        字符串 %s
        十六进制 %#x %x
        八进制 %#o %o
        地址 %p
        指数 %e
        %-m.n 含义：m：位宽 n：保留几位小数 -：左对齐
- 第二周
  - 1.scanf
    - 功能：按照某种格式向终端输入一串信息
    - 参数：一个或者多个，一个字符串，用于填写想要呈现的信息内容，后续参数由前期字符串中的格式的个数决定。
    - 返回值：正确输入的个数，如果第一个参数输入错误，返回0
      - int a=10,b=10;
      - scanf("%d %d", &a, &b);
      - printf("a=%d,b=%d\n",a,b);
  - 2.垃圾字符回收机制
    - int ：不受影响。
    - char：空格也是字符，回车换行也会当作一个字符。
    - 解决方法
      - 通过空格回收一个或多个空格、Tab
      - *抑制符 (了解)：回收任意一个字符。
      - getchar()回收
        scanf输入'q'和'\n', 'q'赋值给变量a，'\n'进入暂存区，下次遇到输入输出时，优先从暂存区读取，'\n'被赋值给了变量b。
  - 3. 强制转换
  - 4.分支语句
    - if
      - 基本格式
        if (表达式1) { 表达式1成立，执行此代码 } else { 表达式1不成立，执行此代码 }
        if (0) # 0假非0为真 if (5 % 2) # 先计算，再判断
      - 多分支格式
        if (表达式1) { 表达式1成立，执行此代码 } else if(表达式2) { 表达式2成立，执行此代码 } else { 上边表达式都不成立，执行此代码 }
      - 嵌套格式
        if (表达式1) { if() { } }else { 表达式1不成立，执行此代码 }
      - 注意：
    - switch
      - 基本格式
        switch (变量或表达式) { case 常量1：语句块； break; case 常量2：语句块； break; default: 语句块； break; }
      - 注意：
        1.case对应的常量值不能为浮点数
        2.每个case对应的分支需要加break，如果不加break,程序会从符合条件的分支开始一直执行，直到switch执行结束或遇到break为止。
  - 5.循环语句
    - for
      - 基本格式
        for(表达式1；表达式2；表达式3) { // 代码块； } 表达式1：循环变量赋初值表达式2：终止条件表达式3：增值或减值
        执行顺序
        先执行表达式1，给循环变量赋初值，判断表达式2是否成立：成立会进入循环，执行语句块；执行表达式3，再执行表达式2... 若表达式2不成立，循环结束。
      - 双层for
        基本格式
        for(表达式1；表达式2；表达式3) { for(表达式4；表达式5；表达式6) { } } 外层循环修改一次，内层循环执行一轮
    - while
      - 基本格式
        int i=1; while(表达式) { 代码块；增值或减值； }
      - do...while
        基本格式
        do { 语句块； }while(表达式);
        执行顺序：先执行do，再判断
  - 6.循环控制语句
    - break ：结束所在循环。
    - continue：结束本次循环，继续下一次。
    - return：函数运行结束。
  - 7.数组
    - 定义
      - 由一个或多个相同类型的数据组成。特点：数据类型相同、内存连续
    - 格式
      - 存储类型(默认auto) 数据类型数组名[元素个数]；
        int arr[5]={2,5,8,3,6};
        char a[6]={'h','e','l','l','o'};
    - 元素访问
      - 数组名[下标] // 下标从0开始
        int arr[5]={2,5,8,3,6}; printf("%d %d %d\n",arr[0],arr[2],arr[4]);
      - 数组名[n]: n只有在定义时，表示元素个数；其他情况下，n表示下标位置。
    - 数组名
      - 数组名也是数组的首地址，是一个地址常量，不能为左值(=左边)
        int a[5]={2,5,7,8,9}; printf("%p\n",a); printf("%p\n",&a[0]);
    - 内存大小
      - int a[5]={2,5,7,8,9};printf("%ld\n",sizeof(a));
      - char b[5]={'a','b','c'};
      - printf("%ld\n",sizeof(b));
    - 初始化
      - 完全初始化
        int a[5]={2,5,7,8,9};
      - 部分初始化
        int a[5]={2,5}; printf("%d %d\n",a[2],a[4]); 未初始化部分，值为0
      - 未初始化
        int b[5]; printf("%d %d\n",b[2],b[4]); 值为随机值.
    - 循环遍历
      - int arr[5]={2,5,8,3,6}; for(int i = 0;i<5;i++) { printf("%d\n",arr[i]); }
  - 8.一维数组
    - 8.1.内存连续
      - int占4字节 char占1字节
    - 8.2. 清零函数
      - bzero
        #include <strings.h> void bzero(void *s, size_t n); 功能：数组内容清零参数：s:数组首地址 n:字节大小返回值：无
      - memset
        #include <string.h> void *memset(void *s, int c, size_t n); 功能：数组元素清零参数：s:数组首地址 c:要设置的值 n:字节大小返回值：数组首地址
        
        了解
        memset 按字节赋值 int=4字节 1字节=8位 0000 0001 0000 0001 0000 0001 0000 0001
    - 8.3.字符数组
      - 8.3.1定义
        用来存放字符串。由双引号" "包裹，以'\0'为结束标志(程序员在写代码时，不需要加上，但是要考虑其位置)。
      - 8.3.2输入输出
        循环
        
        %s
        
        gets
        char *gets(char *s); 功能：终端输入字符串参数：字符数组首地址返回值：字符数组首地址
        
        puts
        int puts(const char *s); 功能：终端输出字符串参数：字符数组首地址返回值：输出字符的个数
        
        练习
        
        功能：逆序输出
      - 8.3.3 获取字符串实际元素个数
        
        strlen()
        #include <string.h> size_t strlen(const char *s); 功能：计算字符串实际元素个数，不包括'\0' 参数：字符数组首地址返回值：实际元素个数
        
        练习：终端输入字符串，逆序输出
      - 8.3.4 strlen和sizeof的区别
        sizeof是关键字，strlen是函数。sizeof是计算元素实际开辟的空间大小，strlen是计算字符串的实际元素个数。char a[]="hello"; sizeof计算包括'\0', strlen计算不包括'\0'
    - 8.4. 冒泡排序
    - 8.5.选择排序
  - 9.二维数组
    - 9.1. 格式
      - 数据类型数组名[行下标][列下标]；
      - int a[2][3]={2,3,4,5,6,7};
      - a[0][0] a[0][1] a[0][2]
      - a[1][0] a[1][1] a[1][2]
      - int a[ ][3]={2,3,4,5,6,7}; // √ 可以省略行下标
      - int a[2][ ]={2,3,4,5,6,7}; // × 不能省略列下标
    - 9.2.初始化
      - 全部初始化
        int a[2][3]={2,3,4,5,6,7};
        int a[2][3]={{2,3,4},{5,6,7}}; // 按行赋值
      - 部分初始化
        int a[2][3]={2,3}; // 2 3 0 0 0 0
        int a[2][3]={{2},{5,6}}; // 2 0 0 5 6 0
      - 未初始化
        int a[2][3]; // 随机值
    - 9.3. 数组名
      - a 第一行首地址
      - a+1 第二行首地址
      - 二维数组的数组名是行地址，首行地址
    - 9.4. 字节大小
      - int a[2][3]={2,3,4,5,6,7};
      - 元素个数*数据类型大小 2*3*4=24
      - printf("%ld\n",sizeof(a));
    - 9.5.循环遍历
  - 10.指针
    - 10.1.定义
      - 指针就是地址，内存地址
      - 计算机以字节为单位，每个字节都有自己的地址编号
    - 10.2.一级指针
      - 指针变量：用来保存地址的变量
      - 格式：存储类型数据类型 *指针变量名; int a=88; int *p=&a;
        一级指针存放普通变量的地址
    - 10.3.指针操作符
      - &取地址取变量的地址 &a
      - *取内容取地址中存放的内容 *p *&a *和&互逆运算
      - *&a==a
      - 指针变量的数据类型要和普通变量的数据类型保持一致
    - 10.4.初始化
      - 指针变量在定义时必须初始化，未初始化的指针变量不能随便使用，会产生野指针。
    - 10.5.指针运算
      - 算术运算
      - 关系运算
    - 10.6.指针大小
      - 指针的大小取决于操作系统的位数 64位操作系统：8字节。32位操作系统：4字节。
  - 11.指针修饰
    - 11.1.const 常量化 read only
      - (1).const修饰变量，变量的值不能通过变量名修改可以通过指针间接修改变量的值。
      - (2).const修饰指针
        const int *p; // 修饰*p
        指针指向的内容不能修改，指针的指向可以修改
        
        int * const p; // 修饰p
        指针的指向不能改，指针指向的内容可以改
        
        int const *const p=&a;
        既修饰指针的指向，又修饰指向的内容
    - 11.2.void
      - void a;//× 不能修饰任何普通变量。
      - void *p=NULL; // 定义一个任意类型的指针，后边需要对p进行使用时，可以使用强制转换。
      - 或强制转换时，定义一个新的指针
  - 12.大小端
    - 计算机在进行超过1字节数据进行存储时，会出现存储顺序不同的情况：
    - 大端：低地址存放高字节数据，高地址存放低字节数据
    - 小端：低地址存放低字节数据，高地址存放高字节数据
      - 例： 0x12345678 小端： 0x78 0x56 0x34 0x12 大端： 0x12 0x34 0x56 0x78
  - 13.二级指针
    - 定义
      - 一级指针存放普通变量的地址
      - 二级指针存放一级指针的地址
    - 格式
      - 存储类型数据类型 **指针变量名；
        int **p;
    - 应用
      - 取变量a的值：**q *p a
        取变量a的地址：*q p &a
        p的地址：q &p

评论

被折叠的条评论为什么被折叠?

到【灌水乐园】发言

查看更多评论

添加红包

成就一亿技术人!

hope_wisdom

发出的红包

实付元

使用余额支付

点击重新获取

扫码支付

钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。