C语言第一个程序
    #include <stdio.h>
    程序员所编写的代码都不是标准的C代码，需要一段程序翻译成标准C代码，负责翻译的程序叫做预处理器，
    翻译的过程叫做预处理，被翻译的语句叫做预处理指令，以#靠开头一段语句都是预处理指令
        #include的功能是把一个头文件导入（拷贝）到当前位置
            #include <xxx.h>
                从系统指定的路径下查找并加载头文件
            #include "xxx.h"
                先从当前工作路径查找，如果找不到再从系统指定路径查找并加载
        stdio.h
            头文件：以.h结尾，里面存储的是一些辅助性的代码，绝大多数都是函数的声明
            源文件：以.c结尾，里面存储的是实际的功能性的代码
            C语言标准委员会为C语言以函数形式提供的一些基础功能，这些函数都被封装在libc.so(标准C库)
            然后通过很多的头文件对不同功能的标准库函数进行了说明，stdio.h就是其中之一，常用：stdlib.h
            string.h
    int main()
        C语言中函数是管理代码的最小单位，一个函数就是一个功能的实现
        main函数是整个程序的入口，有且只有一个，main函数是由操作系统调用，所以它的返回值给了操作系统，
        反应了程序是如何结束的
        int是一种数据类型，表示main函数的执行结果是一个整数值
    {
        printf("Hello World!\n");
            printf/scanf 是标准库的输出/输入函数，一般用于调试代码
            转义字符：键盘上有一些不好直接表示的符号，通过一些特殊字符搭配来表示，这种字符搭配成为转义字符
                \n 换行
                \t 制表符，Tab键
                \a 铃响
                \b 退格，光标后退一个字符
                \r 光标回到行首
                %% 显示一个%
                \\ 显示一个\
        return 0;
            return的作用：
            1、返回一个执行结果给函数的调用者
                正数    出现异常（别人导致）
                0       一切正常
                负数    出现错误（自己导致）
            2、提前结束函数
                main函数遇到return语句程序结束
    }

编译器：
    负责把人能看得懂的文本文件，翻译成计算机能看懂的二进制文件，由预处理器、编译器、链接器组成
    gcc编译器是GNU社区为了编译Linux内核代码而开发一款免费的编译器，默认语法标准是C99或者C89
    常用的编译参数：
        -E      只显示预处理结果
        -S      生成汇编文件
        -c      只编译不链接
        -o      指定编译结果的名字
        -I      指定头文件的加载路径
        -l      指定要使用的代码库 -lm导入数学库
        -wall   尽可能多地产生警告信息
        -werror 把警告当错误处理
        -std    设置编译语法标准 -std=gnu89/99

C代码如何从源文件变成课执行文件的过程：
    1、预处理：把源文件翻译成预处理文件
        gcc -E xxx.c    显示预处理结果到终端
        gcc -E xxx.c -o xxx.i 把预处理的结果存储到xxx.i预处理文件中
    2、编译：把预处理文件翻译成汇编文件
        gcc -S xxx.i    生成以.s结尾的汇编文件
    3、汇编：把汇编文件翻译成二进制的目标文件
        gcc -c xxx.s    生成以.o结尾的目标文件
    4、链接：把若干个目标文件合并成一个可执行文件
        gcc a.o b.o c.o ... 生成a.out可执行文件

C语言中的文件类型：
    .c 源文件
    .h 头文件
    .h.gch 头文件的编译结果文件，会被优先使用
    .i 预处理文件
    .s 汇编文件
    .o 目标文件
    .so 共享库文件
    .a 静态库文件             

数据类型
    为什么对数据进行分类？
        1、现实中的数据就是自带类别属性的
        2、对数据进行分类可以节约内存存储空间、提高运行速度
    存储空间的单位：
        Bit 比特 存储一个二进制位，只能存储0或者1，计算机存储数据的最小单位
        Byte 字节 存储8个二进制位，计算机存储数据的基本单位
        Kb 1024字节 Mb 1024Kb Gb 1024Mb Tb 1024Gb Pb 1024Tb
    C语言中数据分为两大类别：自建（程序员自己设计的）、内建（C语言自带的）
整型：
    signed 有符号
        最高位为符号位，0是正数
        类型名             字节数                  数据范围
        signed char         1                      -128~127
        signed short        2                    -32768~32767
        signed int          4                      正负20亿
        signed long         4/8(操作系统32/64位)
        signed long long    8                      正负9×10^18
            char == signed char
    unsigned 无符号
        类型名              字节数                  数据范围
        unsigned char         1                    0~255
        unsigned short        2                    0~65535
        unsigned int          4                    正40亿
        unsigned long         4/8(操作系统32/64位)
        unsigned long long    8                    正18×10^18
    由于定义无符号是数据时比较麻烦，标准库中把这些类型重新定义成了新的类型名
        需要包含头文件<stdint.h>
        uint8_t\uint16_t\uint32_t\uint64_t
浮点型：
    float       4       单精度浮点型
    double      8       双精度浮点型
    long double 12/16
    采用科学计数法、在二进制与真实数据之间余姚进行换算过程，因此浮点数的运算使用速度比
    整型要慢得多，所以编程时尽量使用整型，大部分操作系统只对小数点后6位有效
模拟型：
    字符型：char
        字符就是图案或符号，字符在内存中依然存储成整数，需要显示成字符时，
        操作系统会根据ASCII码表中的对应关系把整数显示成对应的符号或图案
        '\0'    0   特殊字符 空字符
        '0'     48 
        'A'     65
        'a'     97 
        char想要显示成整数时：%hhd
            想要显示成字符时: %c
    布尔型：bool
        先有的C语言后有的bool类型，C语言中不可能有真正的布尔类型，都是在
        <stdbool.h>中对布尔类型使用整数进行模拟
        bool true false

变量与常量
    什么是变量：在程序运行期间值可以发生变化的叫做变量，相当于存放数据的盒子
    定义：
        类别名 变量名；
            int num;
            取名规则：
                1、由字母、数字、下划线组成
                2、不能以数字开头
                3、不能与C语言32个关键字重名
                4、见名知意
    使用：
        赋值：      变量名 = val；
        参与运算：  变量名*10；
    变量的输入、输出：
        int printf(corst char *format，...)；
        功能：输出数据
        format:"提示信息+占位符"
        ...：   变量名列表
        返回值：成功输出的字符个数

        类型占位符：C语言通过占位符的方式传递变量的类型
        signed    %hhd %hd %d %ld %lld
        unsigned  %hhu %hu %u %lu %llu
        float %f    double %lf   long double %LF
        字符型：char %c

    int scanf(const char *format, ...);
    功能：输入数据
    format："占位符"
     ... :  变量地址列表
            注意：scanf需要变量类型和地址
                变量地址 == &变量名
    返回值：成功输入的变量个数

    什么是常量：在程序运行期间数值不变化的叫做常量
        10      默认int
        10l     long
        10ll    long long
        10u     unsigned int
        10lu    unsigned long
        10llu   unsigned long long 
        3.14    默认double
        3.14f   float
        3.14l   long double

数据的格式化输出
    %nd    显示n个字符宽度，不足时补空格，右对齐        
    %-nd   显示n个字符宽度，不足时补空格，左对齐  
    %0nd   显示n个字符宽度，不足时补0，右对齐
    %n.mf  显示n个字符宽度(小数点也算一位)，不足时补空格，右对齐，m表示小数点后显示的位数(四舍五入)
    %g     不显示小数点后多余的0

运算符
    自变运算符：
        ++/--   让变量的值自动加1或减1
        前自变：++/--num   立即有效
        后自变：num++/--   下一行语句才有效
        注意：不要在一行代码中多次出现自变运算符
    算术运算符：
        + - * / %
        整数/整数   只保留整数部分
        / %  除数不能为0，否则会在运行时出现浮点数例外(核心已转储)
        % 不能对浮点数求余
    
    关系运算符：
        == != > < >= <=
        会得到比较结果是1(成立)或0(不成立)，比较的结果还可以继续参与运算
        int n = -10;
        10 < n < 100;   与数学比较不一样，是永远为真
        注意：建议常量放== != 的左边，防止少些一个=
    
    逻辑运算符:
        && || !
        会先把运算对象转换成逻辑值：非零转为真，0转为假，然后再参与逻辑运算
        A && B  一假即假
        A || B  一真即真
        !A      求反
        && 和 || 的短路特性：
            当左边部分的值已经可以确定整个逻辑运算符的结果时，那么右边部分不执行
            也可以借助短路特性，实现简单的单分支效果        
    
    三目运算符：
        A ? B : C
            判断A的值如果为真(非0)则执行B，否则执行C
    
    赋值运算符：
        = += -= *= ...
        a += b;     a =a+b;
        注意：赋值运算符的运算结果是右边赋的数据

    位运算符：& | ~ ^ << >>

    sizeof  也是一个运算符

    注意：运算符是有优先级之分，如果记不住，那么多加小括号

类型转换问题
    只有相同类型的数据才能进行运算，如果类型不相同的数据需要先转换成相同的类型才能运算
    自动类型转换：
        转换规则：以不丢失数据为基础，可以适当地牺牲一些空间
            1、字节少的向字节多的转
            2、有符号的向无符号的转
            3、整型向浮点型转
            特殊特例：当运算对象类型只是 char或者short，且类型不同，编译器会做类型提升，提升为int再运算
    强制类型转换：
        (新类型名)数据;
        有丢失数据的风险，但是需要使用时还是得用

if分支语句
    if(表达式)  //  单分支语句
    {
        //  表达式的值为真(非0)，则执行此处代码
    }

    if(表达式)  //  双分支语句
    {
        //  表达式的值为真(非0)，则执行此处代码
    }
    else
    {
        //  表达式的值为假(0)，则执行此处代码
    }

    if(表达式1)  //  多分支语句
    {
        //  表达式1的值为真(非0)，则执行此处代码
    }
    else if(表达式2)
    {
        //  表达式2的值为真，则执行此处代码
    }
    ...
    else
    {
        //  所有表达式都为假，最后执行此处代码
    }

switch开关语句
    switch(n)   //n可以是数值、表达式，结果必须是整型
    {
        case val1:  //  val必须是常整数，如果n等于val，则打开执行开关
            break;  //  关闭执行开关
                    //  swtich不可以与continue配合
        case val2:
        default:    //  如果所有case都不打开，则最后打开此开关          //  无论位置在哪，都会最后执行
    }     

 for循环语句
    循环：就是一种让一段代码反复执行的方式，从而达到想要的效果
    for循环一般会使用一个变量来引导循环的进行，这个变量叫做该循环的循环变量 i  index
    for循环的变化很灵活，但也很危险(相比于其他循环)
    for([1];[2];[3])
    {
        [4]
    }
    [1]、给循环变量赋初值   
        C99、C11标准才可以在此处定义变量(改~/.vimrc)
        在for循环内定义变量，只能在for内使用，出了for后无法使用
        for循环内定义的变量，会屏蔽循环外定义的同名变量
    [2]、判断循环变量是否到达结束边界值
        如果判断为假，那么结束循环，反之继续循环
    [4]、被反复执行的代码，称为循环体
    [3]、改变循环变量的值，防止出现死循环，一般对循环变量自加或自减
    1、2、4、3、2、4、3、2、4、3、2...

    for的多种写法：
    for(;;)
    {
        //  死循环
    }

    int i=0;
    for(; i<10; i++)
    {

    }

    for(int i=0; i<10;)
    {
        if(xxx)
        {
            i++;
        }
    }
    for循环的大括号问题：
        1、for循环内只有一行代码时，大括号可以省略
            但是这样不利于后期代码扩展，一般的商业代码要求大括号不能省略
        2、建议上下对齐，括号内该缩进的要缩进

while循环语句
    while(条件) //  当条件为真时执行循环体，为假时结束循环
    {
        //  循环体
    }
    for(;条件;)
    {

    }
    while循环相当于for循环其中一个精简版本
    for循环是负责解决明确知道循环次数的问题
    while循环是负责只知道循环结束条件而不确定循环次数的问题

do-while循环语句
    do{
        //循环体
    }while(条件);   //  分号不能少
    先执行循环体，再判断循环条件，至少会执行一次
    适合先干活、再判断的特殊情况，例如：输入密码

循环嵌套
    循环语句中有循环语句
    外层循环执行一次，内层循环执行n次
    for(int i=0; i<10; i++)
    {   
        printf("@");    
        for(int j=0; j<10; j++)
        {
            printf("$");    
            for(int k=0; k<5; k++)
            {
                printf("*");    
            }
        }
        printf("\n");
    }   

跳转语句：
    goto    可任意在函数内任意跳转
    标签名:
        xxx;
        goto 标签名;

    注意：goto很容易破坏已经设计好的分支或者循环语句，因此绝大多数公司是禁止使用goto
        goto在驱动编程和硬件编程中非常时候处理异常
    
    break
        1、在switch中关闭case开关
        2、跳出循环，但如果有循环嵌套时，只能跳出最近的一层循环
    
    continue
        结束本次循环，直接进入下一次循环
    
    return
        1、返回一个返回值给函数的调用者
        2、提前结束函数，程序回到调用位置继续执行

数组
    什么是数组：变量的组合，是一种批量定义相同类型变量的方式
    定义：  类型名 数组名[数量];
            int arr[5];
            注意：数组的长度一旦确定，无法改变
    使用：数组名[下标];
        下标：从0开始，范围：0~数量-1   
    遍历：把数组的数据从头到尾显示或访问 
        一般与for循环配合，把循环变量i当做数组下标  
    初始化：
        类型名 数组名[数量] = {1,2,3,4,...};
        1、数组与变量一样，默认值随机，所以一般都要先初始化
        2、数组不能整体初始化，只能逐个初始化 
            int arr[20]=0 false
        3、这种初始化的语法只能在定义数组时使用
        4、初始化数据过多，编译器会产生警告并丢弃
        5、初始化数据不足，编译器会自动补0
        6、初始化数据可以全部省略，只写大括号，相当于全部成员初始化为0
        7、如果有初始化数据，则可以省略数组数量，因为编译器会自动统计数据的个数，然后确定数组的数量
            计算数组的总字节：sizeof(arr)
            计算数组成员的字节数：sizeof(arr[0])
            计算数组长度的公式：
                sizeof(arr)/sizeof(arr[0])
    
数组越界问题
    为了程序的运行效率考虑，C语言不检查数组下标是否越界
    数据越界的后果：
        1、一切正常
        2、段错误(核心已转储)
        3、脏数据

二维数组
    一维数组相当于把变量排成一排，通过编号来访问
    二维数组相当于把变量排成一个矩阵，通过行号和列号访问
    二维数组在内存中依然是连续存储的
    定义：
        类型名 数组名[行数][列数];
        int arr[4][5];
        [0,0][0,1][0,2][0,3][0,4]
        [1,0][1,1][1,2][1,3][1,4]
        [2,0][2,1][2,2][2,3][2,4]
        [3,0][3,1][3,2][3,3][3,4]

    使用：数组名[行下标][列下标];
        行下标：0~行数-1
        行下标：0~列数-1
    
    遍历：一般需要与双层for循环配合，外层循环负责遍历行，内层循环负责遍历列
        int arr[4][5];
        for(int i=0; i<4; i++)
        {   
            for(int j=0; j<5; j++)
            {
                printf("%d ",arr[i][j]);
            }
            printf("\n");
        } 

    初始化：
    类型名 数组名[行数][列数]={{第一行},{第二行},...};
    注意：
        1、大括号内数据可以全部省略，那么就自动补0
        2、大括号数据和列数不省略，行数可以省略，编译器会自动计算行数
        3、不能省略二维数组的列数

变长数组
    定义数组时，使用变量作为数组的长度，这种数组称为变长数组
    特点：在代码编译期间数组的长度是不确定的，当执行到数组的定义语句时长度才最终确定下来，并且一旦确定长度也无法改变
        int n = 0;
        scanf("%d",&n);
        int arr[n];
    优点：可以根据实际情况来确定数组的长度，从而节约内存
    缺点：初始化发生在编译期间，而可变长数组长度的确定发生在运行期间，因此可变长数组无法初始化