C语言基础总结

  //欲练此功必先自宫!!!  
  //第一天:C语言的基础
    //进制
    //2进制, 10进制, 8进制, 16进制
    //注:8进制数前加0, 16进制数前加0x
    
    //进制转换:
    //10 -> n: 连除到取余
    //n -> 10: 按权求和法(基数, 位权)
    //n -> n: 1个8进制位 = 3个2进制位, 1个16进制位 = 4个2进制位
    
    //字节
    //1字节 = 8位2进制
    
    //单行注释: //
    //多行注释: /* */
    //注:注释不参与程序编译, 可以出现在任何位置
    
    //main函数: 是程序入口, 只能有一个
    
    //数据类型
    //基本类型: 1.整型: short int long 2.浮点型: float double 3.字符型: char
    //构造类型: 1.数组[] 2.结构体struct 3.枚举enum
    //指针类型: *
    //空类型: void
    
    //变量
    //定义: 数据类型 变量名 = 初值
    //注: 变量要先定义, 才能使用
    
    //变量名的命名规范
    //1.由数字, 字母, 下划线构成, 不能以数字开头
    //2.在同一作用域内, 不能重名
    //3.不能用系统的关键字(看颜色)
    //4.见名知意(不用使用拼音, 汉字, 中英交叉)
    //5.小驼峰法
    
    //常量
    //1, 19.9, 'c', "abc"
    
    //运算符(单目, 双目, 三目)
    //1.赋值运算符: =
    //2.算术运算符: +, -, *, /, %, ++, --
    //3.复合运算符: +=, -=, *=, /=, %=
    //4.逻辑运算符: &&, ||, !
    //5.关系运算符: >, >=, <, <=, ==, != (BOOL)
    //6.条件运算符: ? :
    
    //表达式 = 变量 + 常量 + 运算符
    
    //语句: 程序执行的最小单元(见到;即语句)
    
    //printf("Hi");
    //printf("%d", a);
    
    //格式化输出符
    //char           %c    %d
    //short          %hd
    //int            %d
    //long           %ld
    //float          %f
    //double         %lf
    //BOOL           %d
    //字符串          %s
    //unsigned int   %u
    //unsigned long  %lu
    //八进制          %o
    //十六进制        %x
    //指针            %p
    //以回车结束输入    %[^\n]
    //%-10.2f:
    
    //转义字符
    //换行  \n
    //tab  \t
    //%    %%
    //"    \"
    // \   \\
    
    //scanf("%d", &a);
    //注: ""内不能加\n, 后面写变量的地址
    
    //第二天: 分支结构
    //C语言的三大结构: 顺序结构, 分支结构, 循环结构
    
    //if
    //第一种形式
    /*
     if (<#condition#>) {
     <#statements#>
     }
    */
    
    //第二种形式
    /*
    if (<#condition#>) {
        <#statements#>
    } else {
        <#statements#>
    }
    */
    
    //第三种形式
    /*
    if (<#condition#>) {
        <#statements#>
    } else if (<#expression#>) {
        <#statements#>
    } else {
        <#statements#>
    }
    */
    
    //注: 三种形式可以相互嵌套使用


    //enum
    enum 枚举名{
枚举值1,
        枚举值2,
…
    }
    枚举值:枚举值默认从零开始,也可以指定数值;
    枚举值常与switch合用
    
    //switch
    
    /*
    switch (<#expression#>) {
        case <#constant#>:
            <#statements#>
            break;
        case <#constant#>:
            <#statements#>
            break;
        default:
            break;
    }
    */
    //注:1.switch后的表达式是整型表达式
    //2.case后面的值是常量
    //3.case和default中需要加break
    //4.如果在case中定义变量, 需要case内部添加括号
   /*
    int a = 10;
    switch (a) {
        case 10:
        {
            int b = 100;
            break;
        }
        default:
            break;
    }
    */
    
    /*
    //const用于修饰那一部分不能修改
    //判断步骤
    //1.去掉数据类型
    //2.const后的就是不能修改的部分
    int a = 10;
    int b = 100;
    const int *p1 = &a;//*p1不能修改
    int const *p2 = &a;//*p2不能修改
    int * const p3 = &a;//p3不能修改
    const int * const p4 = &a;//p4和*p4不能修改
    */
    
    /*
    int max = 0, a = 5, b = 10;
    max = a > b ? a : b;
    
    if (a > b) {
        max = a;
    } else {
        max = b;
    }
    */
    
    //第三天:循环结构
    
    //for循环
    /*
    for (<#initialization#>; <#condition#>; <#increment#>) {
        <#statements#>
    }
     */
    
    //while循环
    /*
    while (<#condition#>) {
        <#statements#>
    }
    */
    
    //do...while循环
    /*
    do {
        <#statements#>
    } while (<#condition#>);
    */
    
    //知道循环的次数, 使用for循环
    //知道循环结束的条件, 使用while循环
    //do...while循环使用比较少
    
    //随机数公式[a, b]
    //arc4random() % (b - a + 1) + a
    
    //break: 跳出本层循环
    //continue: 跳出本次循环, 加速循环的执行
    //return: 跳出函数, 返回数值
    
    //第四天:数组
    //用于存储多个相同数据类型的有序队列
    
    //数据类型 数组名[元素个数] = {};
    //注: 元素个数可以省略, 由后面赋值来决定元素个数
    
    //数值的使用
    //1.数组不能够直接参与运算
    //2.数组中的元素可以参与运算
    
    //元素的访问
    //1.通过下标访问数组元素
    //2.下标从0开始, 到(元素个数 - 1)结束
    
    //遍历数组
    //遍历n维数组, 要嵌套n层for循环
    
    //冒泡排序
    /*
    int array[5] = {12, 20, 3, 48, 5};
    for (int i = 0; i < 5 - 1; i++) {
        for (int j = 0; j < 5 - 1 - i; j++) {
            if (array[j] > array[j + 1]) {
                int temp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = temp;
            }
        }
    }
    */
    
    //字符数组 = 字符串
    //打印字符串: %s
    
    //字符串函数
    //strlen: 字符串长度
    /*
    char string[10] = "iPhone";
    printf("%lu\n", strlen(string));//长度:6
    printf("%lu\n", sizeof(string));//字节数:10
    */
    //strcpy: 字符串拷贝
    //strcat: 字符串拼接
    //strcmp: 字符串比较
    
    /*
    int c = 5;
    int array[c] = {};//数组定义时, 元素个数不能使用变量
    */
    
    //第五天: 多维数组
    //定义
    //数据类型 数组名[维度1][维度2][...] = {};
    
    //字符数组, 一维数组
    //字符串, 一维数组
    //字符串数组, 二维数组
    
    /*
    char string[5][20] = {"zhangsan", "lisi", "asan", "erhu", "guangtouqiang"};
    //冒泡排序(a-z)
    
    for (int i = 0; i < 5 - 1; i++) {
        for (int j = 0; j < 5 - 1 - i; j++) {
            if (strcmp(string[j], string[j + 1]) > 0) {
                char temp[20] = {0};
                strcpy(temp, string[j]);
                strcpy(string[j], string[j + 1]);
                strcpy(string[j + 1], temp);
            }
        }
    }
    */
    
    //第六天: 函数
    //具有特定功能的代码段
    
    //一个严格的函数包括
    //1.函数声明
    //2.函数定义
    //3.函数调用
    
    //函数定义
    /*
    返回值类型 函数名(参数类型 参数名, ...) {
    
    }
    */
    //注: 1.没有返回值, 使用void
    //2.没有参数, 括号不能省略
    //3.参数类型相同, 类型不能省略
    //4.函数之间是并列的关系, 不能嵌套定义
    
    //函数调用
    //函数名(实参, ...)
    
    //实参: 函数调用时的参数
    //形参: 函数定义时的参数
    //注: 函数调用时, 把实参的值拷贝给形参
    
    //主调函数: 在函数a中调用了函数b, 函数a就称为函数b的主调函数
    
    //局部变量: 定义在函数体内部的变量
    //全局变量: 定义在函数体外部的变量
    //注: 尽量不要使用全局变量
    
    //函数可以嵌套调用
    
    //递归函数, 一定要有出口
    
    //*.h中写 函数声明
    //*.m中写 函数定义
    //如果在其他文件使用函数, 需要引入头文件
    
    //数组作为函数的参数
    //1.,数组名[],数组的元素个数省略
    //2.多添加一个参数, 用于传递数组元素个数
    
    //第七天: 结构体
    //结构体是用户自定义的数据类型
    
    //结构体声明
    /*
    struct <#struct name#> {
        <#struct fields#>
    };
    */
    //注:1.结构体名字用小驼峰法
    //2.每一个成员变量以分号结束
    //3.结构体声明写在.h中
    
    //结构体变量
    //struct 结构体名 变量名 = 初值
    //注: 1.结构体变量可以直接参与运算
    //2. 结构体变量不能够直接打印
    
    //结构体变量的成员变量
    //使用点语法访问
    
    //使用typedef对结构体重命名
    //typedef 原结构体名 新结构体名
    //注: 新结构体名要是大驼峰法
    
    //结构体所占的字节数
    //1.最大数据类型的倍数
    //2.交换成员变量的位置, 会影响结构体所占的字节数
    
    //char   1
    //short  2
    //int    4
    //long   4或8
    //float  4
    //double 8
    //指针    4或8
    
    //结构体和数组相互嵌套使用
    //1.结构体声明时, 成员变量是数组类型
    //2.数组内存放的都是结构体类型的变量(结构体数组)
    
    //第8天: 指针
    //内存的地址编号
    
    //&: 取地址运算符
    //%p 打印地址
    
    //指针变量: 用于存储地址
    //数据类型 *变量名 = NULL
    //注:1. 指针变量所占的字节数和数据类型无关, 只有操作系统的位数相关
    //2.数据类型决定*p取内容时, 取多少个字节
    //3.数据类型决定p + 1时, 跳转多少个字节
    
    //*: 取值运算符
    
    //指针变量被重新赋值, 意味着指针变量重定向
    
    //指针的运用
    //指针在数组中的运用
    
    //数组的名字就是数组的首地址
//    int a[5] = {1, 2, 3, 4, 5};
    //*a        a[0]
    //*(a + 1)  a[1]
    //*(a + i)  a[i]
    
//    int *p = a;
    
    //p 和 a 的区别
    //1. 数组的名字a是一个常量指针, 不能重定向(修改)
    //2. sizeof, p: 求指针所占的字节数; a: 求数组所占的字节数
    
    //指针在字符串中的运用
//    char string[] = "iOS";
//    printf("%s\n", string);
//    printf("%s\n", string + 1);
//    
//    char *q = string;
//    printf("%s\n", q);
    
    //第9天: 指针高级
    
    //指针数组: 数组中元素类型是指针类型
    int a = 10;
    int b = 20;
    int c = 30;
    
    int *p[3] = {&a, &b, &c};
    //p[0]  &a  *p
    //p[1]  &b  *(p + 1)
    //p[2]  &c  *(p + 2)
    
    //*p[0]  a  *(*p)
    //*p[1]  b  *(*(p + 1))
    //*p[2]  c  *(*(p + 2))
    
    //指针作为函数的参数
    //作用: 在函数内部修改外部变量的值
    //(int array[], int count)
    //(int *array, int count)
    
    //指针在结构体变量中的使用
    //定义一个结构体指针变量 指向 结构体变量的首地址
    //可以用->(指向操作符), 访问结构体的成员变量
    
    //指针在结构体数组中的使用
    struct student {
        char name[20];
        int age;
        float score;
    };
    typedef struct student Student;
    
    Student array[3] = {
        {"zhangsan", 18, 59.9},
        {"lisi", 20, 69},
        {"wangmazi", 40, 30}
    };
    
    //array[0].name  (*array).name
    //array[1].name  (*(array + 1)).name
    //array[2].name  (*(array + 2)).name
    
    //array->name
    //(array + 1)->name
    //(array + 2)->name
    
    //第10天: 动态内存分配
    //内存的五大分区(地址编号由高到底)
    //1.栈区(局部变量, 系统控制)
    
    //2.堆区(由开发人员手动申请, 手动释放)
    //申请 malloc
    //释放 free  p = NULL
    
    //3.静态全局区(全局变量和static修饰的变量, 系统控制)
    //static变量特点
    //a. 存在静态全局区
    //b. 只能被初始化一次
    //c. 没有赋初值, 默认为0
    
    //4.常量区(常量, 系统控制, 常量区的内容是只读的)
    
    //5.代码区(函数,语句, 系统控制)
    
    //第11天: 函数指针
    //函数的名字就是函数的首地址
    
    //函数指针类型确定的步骤
    //1.把函数名换(*)
    //2.去掉函数体和参数名
    //int (*)(int, int)
    
    /*
    int printHello(int a, int b) {
        
    }
    */
    
    //函数指针变量
    //int (*p)(int, int) = NULL
    //注: 变量名写在*后面
    
    //使用typedef重命名函数指针类型
    //typedef int (*Type)(int, int)
    //注: 新类型名, 写在*后面
    
    //Type p = NULL
    
    //指针指向函数的首地址
    //p = printHello;
    
    //printHello(3, 4)
    //p(3, 4)
    
    //回调函数: 使用函数指针变量调用函数
    
    //函数指针变量作为函数的参数, 函数可以实现多种功能
    //前提: 函数指针类型相同


    //宏
    //无参宏 只做简单地替换
    //有参宏 #define kSum(A,B) ((A)+(B))
    //表达式中的每一个参数加括号,整个表达式也要加括号


    //条件编译
    //三种条件编译
/*
#ifdef   标识符
 代码段1
 #else 
 代码段2
 #endif
如果 标识符 被 #define 过 ，编译器编译代码段1，否则编译代码段2。


#ifndef   标识符
代码段1
 #else
代码段2
 #endif
如果 标识符 未被 #define 过 编译器编译代码段1，否则编译代码段2。

#if 常量表达式
 代码段1
 #else
 代码段2
 #endif
如果 常量表达式结果 非0  编译器编译代码段1，否则编译代码段2。
三种形式一样,以后主要用于版本控制;
*/
    //经前人总结,若不自宫也能成功!!!