2018-09-07(指针,多级指针,指针数组,指针数组字符串,

• 定义一个函数, 要求能够在函数中修改传入变量的值

    int num = 6;
    printf("调用之前:num = %i\n", num);
//    change(num);
    change(&num);
    printf("调用之后:num = %i\n", num);
    return 0;
}
//void change(int value){
// 结论: 如果函数的形参是数组或者是指针,
// 那么就可以在函数中修改外界传入变量的值
void change(int *value){ // 相当于 int *value = #
    *value = 888;

• 需求: 要定定义一个函数, 在函数中交换传入变量的值

void main(){
    int num1=10,num2=20;
    chang(&num1,&num2);
    printf("num1=%i,num2=%i",num1,num2);

}
基本数据类型作为形参, 在函数内修改形参, 不会影响到函数外的实参,所以定义为指针变量,传进来地址
int chang(int *n1,int *n2){

    int mid=*n1;
    *n1=*n2;
    *n2=mid;
}

• 需求: 要求定义一个函数, 可以同时返回两个变量的和,差,积,商

     需要大家知道的是: 在C语言中, 默认情况下一个函数只能返回一个值
     如果想让某一个函数同时返回多个值, 可以借助指针来实现
#include <stdio.h>
//int sum(int num1, int num2);
void test(int num1, int num2, int *res1, int *res2, int *res3, int *res4);
int main()
{
    int a = 10;
    int b = 20;
//    int res = sum(a, b);
//    printf("res = %i\n", res);

    int d, e, f, g;
    test(a, b, &d, &e, &f, &g);
    printf("和 = %i\n", d);
    printf("差 = %i\n", e);
    printf("积 = %i\n", f);
    printf("商 = %i\n", g);
    return 0;
//    printf("return 后面的语句\n");
}

/**先输出/**,然后按住Ctrl旁边的Fn+回车键,自动生成以下注释
 * @brief test 可以同时返回两个变量的和,差,积,商
 * @param num1 参与运算的第一个变量
 * @param num2 参与运算的第二个变量
 * @param res1 和
 * @param res2 差
 * @param res3 积
 * @param res4 商
 */
void test(int num1, int num2, int *res1, int *res2, int *res3, int *res4){
    *res1 = num1 + num2;
    *res2 = num1 - num2;
    *res3 = num1 * num2;
    *res4 = num1 / num2;
}

注意点:return后面的语句执行不到
int sum(int num1, int num2){
    // 注意点:
    // return的作用是用于结束当前函数
    // 只要函数执行到return, 就会立刻停止往下执行
    // 所以return 后面不可以编写任何语句, 因为执行不到
    return num1 + num2;
//    return num1 - num2;
//    return num1 * num2;
//    return num1 / num2;
}
*/

• 多级指针

前面我们学习的指针我们称之为一级指针
     * 什么是多级指针
     * 指针中保存的又是其它指针的地址, 我们就称之为多级指针
     * 如何定义多级指针
     * 在要保存的指针变量的基础上加一颗星即可
     * 例如: int *p;  如果想保持指针变量p的地址, 只需在定义时多加一颗星即可 int **pp;
     *
     * 访问的规则:pp
     * 如果定义就如何访问, 例如: int *p; 访问 *p;  例如: int **pp; 访问 **pp;
     *
     * 定义指针的规律:
     * 1.将要指向的变量的定义拷贝过来
     * 2.再拷贝过来的代码的类型和变量名称中间加上一颗星
     * 3.修改变量名称
int num=6//int num;num=6;
int *p=#//int *p;p=#定义指针规律的意思就是把int num;拷贝过来,在int和num之间加*,在中间靠近谁都没关系,然后改变num的名称为p
int **p2=&p;
printf("&num = %p\n", &num); // &num =  0060FEAC
printf("p = %p\n", p); // p =  0060FEAC
printf("*pp = %p\n", *pp); // *pp = 0060FEAC

printf("&pp = %p\n", &pp); // &pp = 0060FEA4
 规律: 如果想通过多级指针获取某个变量的值, 那么是几级指针, 前面就写几颗星即可
 注意点: 在企业开发中, 最多二级指针, 三级顶天了, 四级没讲过

• 指针和数组

 int ages[3] = {1, 3, 5};

    for(int i = 0; i < 3; i++){
        printf("ages[%i] = %i\n", i, ages[i]);
    }
    数组名称保存的就是数组占用内存最小的那个地址
    既然数组名称保存的就是地址, 而指针也是用于保存地址的, 所以指针也可以指向数组
    int *p = &ages;
    printf("ages = %p\n", ages); // ages = 0060FEA0
    printf("&ages = %p\n", &ages); // ages = 0060FEA0
    int *p = ages;// int *p = &ages
    printf("p = %p\n", p); // 0060FEA0
    结论: 如果利用指针保存数组的地址之后, 那么 p = ages = &ages;

• 要求你写出三种访问数组元素的写法

     int ages[3] = {1, 3, 5};//第一种
     printf("ages[0] = %i\n", ages[0]);
     int *p = ages;//第二种
     printf("p[0] = %i\n", p[0]);
     printf("0[p] = %i\n", 0[p]);//第三种

• 指针遍历数组

int ages[3] = {1, 3, 5};
    int *p = ages;
//    printf("*p = %i\n", *p); // 1
//    printf("*(p + 1) = %i\n", *(p + 1)); // 3
//    printf("*(p + 2) = %i\n", *(p + 2)); // 5

//    printf("*p = %i\n", *p++); // 1
//    printf("*p = %i\n", *p++); // 3
//    printf("*p = %i\n", *p); // 5
//    printf("*p = %i\n", *(--p)); // 3


    for(int i = 0; i < 3; i++){
//        printf("ages[%i] = %i\n", i, ages[i]);
        printf("ages[%i] = %i\n", i, *p++);
    }

• 指针和字符串(用指针变量保存字符串)

指针和字符串
* 字符串的本质就是数组, 所以指针也可以指向字符串
* 正式因为如此, 所以定义字符串又多了一种方式

char str1[] = {'l', 'n', 'j', '\0'};
char str2[] = "lnj";//可以写成str2[i]
char *str4 = "lnj";//同样可以写成str2[i]
利用数组和指针定义字符串的区别:
     * 1. 存储的位置不同
     * 如果是通过数组定义的字符串, 那么存储在内存的栈中
     * 如果是通过指针定义的字符串, 那么存储在内存的常量区中
     *
     * 2.由于在内存中存储的位置不一样, 所以特性也不一样
     * 如果是通过数组定义的字符串, 我们是可以手动修改
     * 如果是通过指针定义的字符串, 我们不用手动修改
   char str[] = "lnj";
   char *str = "lnj";
   printf("str = %s\n", str);
   str2[1] = 'T';
   printf("str = %s\n", str);
     *
     * 3.由于在内存中存储的位置不一样, 所以特性也不一样
     * 如果是通过数组定义的字符串, 每次定义都会重新开辟存储空间
     * 如果是通过指针定义的字符串, 重复定义不会重新开辟存储空间

    char str1[] = "lnj";
    char str2[] = "lnj";
    printf("str1 = %p\n", str1); // 地址不一样
    printf("str2 = %p\n", str2);

    char *str1 = "lnj";
    char *str2 = "lnj";
    printf("str1 = %p\n", str1); // 地址一样
    printf("str2 = %p\n", str2);

• 接收和打印,字符串数组和指针的区别

 1.接收字符串的时候, 只能通过字符数组, 不能通过字符指针
char str[10];
char *str;//程序编译是不报错,运行时出现问题,这样定义接收不到
scanf("%s", str);
rintf("str = %s\n", str);
 2.如果函数中返回的字符串是通过数组创建的, 那么外界无法获取
    如果函数中返回的字符串是通过指针创建的, 那么外界可以获取
    char *res = demo();
    printf("res = %s\n", res);
char* demo(){//返回值为指针类型,所以有星号
    char str[] = "lnj";//函数外面接收不到
    char *str = "lnj"
    return str;//str保存的是常量区lnj\0的地址

/ 注意点: 学习了指针之后, 建议将过去形参的数组类型修改为指针类型
int ages[3] = {1, 3, 5};
     test(ages);
     printf("ages[1] = %i\n", ages[1]);

//void test(int nums[]){
void test(int *nums){//由于test(ages)传进来的就是地址,用指针更形象
 nums[1] = 6;

• 字符串数组

字符串数组
    // 字符串就是一个数组, 所以字符串数组就是一个二维数组

   char str[][] = {//字符串数组表示方法
       "lnj",
       "abc",
       "def"
    };

    // 字符串数组的第二种格式
    char *str[] = {
        "lnj",
        "abc",
        "def"
    };

• 练习
  1.实现strlen()函数

char *str = "lnj666";//此处注意字符串为char类型,形参处也为char类型
//    char str[10] = {'l', 'n', 'j', '\0'};
    // 注意点: strlen计算的是保存了多少个字符串
    // 计算规则, 就是返回字符串中\0之前有多少个字符
int res = myStrlen(str);
    printf("res = %i\n", res);
    return 0;
}
int myStrlen(char *str){
    // 1.定义变量记录当前有多少个
    int count = 0;
    while(*str++){
        count++;
    }
//    while(*str++ != '\0'){   方法二
//        count++;
//    }

//    while(str[count] != '\0'){     方法三
//        count++;
//    }
   return count;
}

2.实现strcat()函数

注意点: 第一个参数必须足够大
 //char *str1 = "lnj";  // 不能用于拼接,因为不能看出第一个字符空间大小
//    char *str2 = "it666";
    char str1[10] = "lnj";
    char str2[10] = "it666";
    myStrcat(str1, str2);
    printf("str1 = %s\n", str1);
    return 0;
}
void myStrcat(char *str1, char *str2){
方法一:
    while(*str1){
         str1++;
    }
 while(*str2){
        *str1 = *str2;
        str1++;
        str2++;
    }
*str1='\0';
}

方法二:
 // 1.拿到第一个数组\0的位置
    int index = 0;
    while(str1[index] != '\0'){
        index++;
    }
    // 2.将第二个数组添加到第一个数组末尾
    int count = 0;
    while(str2[count] != '\0'){
        str1[index] = str2[count];
        count++;
        index++;
    }

3.实现strcpy()

同样不能用指针定义字符串数组,
int main()
{
      char str1[9] = "lnj";
      char str2[10] = "it";
//    strcpy(str1, str2);
    myStrcpy(str1, str2);
    printf("str1 = %s\n", str1);
    return 0;
}
void myStrcpy(char *str1, char *str2){
    while(*str2){
        *str1 = *str2;
        str1++;
        str2++;
    }
    *str1 = '\0';
}
/*
void myStrcpy(char *str1, char *str2){
    int index = 0;
    while(str2[index] != '\0'){
        str1[index] = str2[index];
        index++;
    }
    str1[index] = '\0';
}
*/

4.实现strcmp()

int main()
{
    // strcmp
    char str1[9] = "125";
    char str2[10] = "124";
    // 两个字符串相同返回0
    // 第一个参数小于第二个参数 -1 负数
    // 第一个参数大于第二个参数 1 正数
    // 如果前面的内容都相同, 第一个参数的个数小于第二个参数, -1 负数
    // 如果前面的内容都相同, 第一个参数的个数大于第二个参数, 1 正数
//    int res = strcmp(str1, str2);
    int res = myStrcmp(str1, str2);
    printf("res = %i\n", res);
    return 0;
}
int myStrcmp(char *str1, char *str2){

//    while(*str1 != '\0' || *str2 != '\0'){
     while(*str1 || *str2){
        if(*str1 > *str2){
            return 1;
        }else if(*str1 < *str2){
            return -1;
        }
        str1++;
        str2++;
    }
    return 0;
}

/*方法二:
int myStrcmp(char *str1, char *str2){
    int index = 0; // 3
    //      \0                        \0
    while(str1[index] != '\0' || str2[index] !='\0'){
        //      3           3
        if(str1[index] > str2[index]){
            return 1;
        }else if(str1[index] < str2[index]){
            return -1;
        }
        index++;
    }
    return 0;
}
*/

---

• 指向函数的指针

  • 指针变量的作用: 专门用于保存地址
    * 指向函数的指针
    * 计算机也会给函数分配存储空间, 既然函数会分配内存空间,
    * 所以函数也有自己的地址, 所以指针变量也可以保存函数的地址
    *
    * 经过前面的学习, 我们知道数组名保存的就是数组的地址
    * 函数和数组很像, 函数名中保存的就是函数的地址
    *
    * 如何定义指针变量?
    * 1.将需要保存变量的定义拷贝过来
    * 2.在数据类型和变量名称中间添加一个*
    * 3.修改变量名称
    *
    * 如何定义保存函数的指针变量
    * 1.将函数的什么拷贝过来
    * 2.在函数返回值和函数名称总监添加一个*
    * 3.修改函数名称
    * 4.注意点: 需要将*和变量名称用括号括起来
    *
    * 我们说过指向函数的指针和指向数组的指针很像
    * 如果是数组, 我们可以直接将数组名称赋值给一个指针变量
    * 如果是函数, 我们也可以直接将函数名称赋值给一个指针变量
    *
    * 如果一个指针指向了数组, 那么访问数组就有了三种方式
    * 数组名称[索引];
    * 指针变量名称[索引]
    * *(指针编码名称 + 索引)
    *
    * 如果一个指针指向了函数, 那么访问方式也有多种方式
    * 函数名称();
    * ( *指针变量名称)();
    * 指针变量名称();

     int num;
     int *p;
     p = #

    int ages[3] = {1, 3, 5};
     int *p;
     p = ages;
    printf("ages[1] = %i\n", ages[2]);//三种方式访问数组
    printf("p[1] = %i\n", p[2]);
    printf("p[1] = %i\n", *(p+2));


    test(); // 第一种方式

    void (*funcP)();
    funcP = &test;//或者  funcP = test;
    (*funcP)(); // 第二种方式

    void (*funcP)();
    funcP = &test;//或者  funcP = test;
    funcP(); // 第三种方式
void test(){
    printf("test\n");
}

• 练习:定义指针指向这几个函数

    void (*p1)();
    p1 = say;
    p1();

    void (*p2)(int, int);
    p2 = sum;
    p2(10, 20);


    int (*p3)(int a, int b);
    p3 = minus;
    int res = p3(10, 20);
    printf("res = %i\n", res);

    char* (*p4)();
    p4 = test;
    char* res2 = p4();
    printf("res2 = %s\n", res2);
    return 0;
}
void say(){
    printf("Hello World\n");
}
void sum(int a, int b){
    printf("res = %i\n", a + b);
}
int minus(int a, int b){
    return a - b;
}
char* test(){
    char* name = "lnj";
    return name;
}

• 要求一个函数既可以计算两个变量的和, 也可以计算两个变量的差

//    int res1 = sum(10, 20);
//    printf("res1 = %i\n", res1);

//    int res2 = minus(10, 20);
//    printf("res2 = %i\n", res2);

    int res3 = test(10, 20, sum);//把sum地址传给test
    printf("res3 = %i\n", res3);

    int res4 = test(10, 20, minus);
    printf("res4 = %i\n", res4);
    return 0;
}
 注意点: 指向函数的指针,作为函数的形参时, 指针变量的名称, 就是形参的名称
// 如果指向函数的指针作为函数的参数, 那么这个可称之为回调函数
// 这里相当于, 给test函数传入了一个sum函数或者minus函数
// 然后又在test函数中调用了sum函数或者minus函
int test(int num1, int num2, int (*funP)(int, int)){
    return funP(num1, num2);//把num1和num2的值传给sum函数

int sum(int num1, int num2){
    return num1 + num2;
}
int minus(int num1, int num2){
    return num1 - num2;
}

• 作业
  1.要求从键盘输入一个字符串, 并且字符串中可以出现空格

• 2.将用户输入的字符串, 单词的首字母变成大写, 单词用空格划分
• hello world; --> Hello World;
• 3.将用户输入的字符串, 单词的首字母编程小写, 单词用空格划分
• Hello World; --> hello world;
• 4.要求定义一个函数, 既可以处理将首字母变为大写, 也可以处理将首字母变为小写
• 需要用到指向函数的指针

---

• 结构体

    /*
     * 什么是结构体?
     * 结构体时构造类型的一种
     *
     * 构造类型前面我们已经学习过了数组:
     * 数组的作用是用于存储一组相`同类型`的数据
     * 结构体的作用是用于存储一组`不同类型`的数据
     *
     * 保存一个人的信息
     * 姓名/年龄/身高 ...
     * char *
     * int
     * double
     *
     * 如何定义结构体变量
     * 1.先定义结构体类型
     * 2.通过结构体的类型定义结构体变量
     *
     * 如何定义结构体类型?
     * struct 结构体类型名称{
     *   数据类型 属性名称;
     *   数据类型 属性名称;
     *   ... ...
     * };
     *
     * 如何定义结构体变量
     * struct 结构体类型名称 变量名称;
     *
     * 如何访问结构体的属性
     * 结构体变量名称.结构体属性名称;
     */
    // 1.定义结构体类型
    struct Person{
        char *name; // name我们称之为结构体的属性名称
        int age; // age也称之为结构体的属性名
        double height; // height也称之为结构体的属性名称
    };
    // 2.定义结构体变量
    struct Person p;

    // 3.使用结构体变量
//    int ages[3] = {1, 3, 5};
//    ages[0] = 1;
    // 格式: 结构体变量名称.结构体属性名称
    p.name = "lnj";
    p.age = 35;
    p.height = 1.9;
    printf("name = %s\n", p.name);
    printf("age = %i\n", p.age);
    printf("height = %lf\n", p.height);
    return 0;
}

• 结构体变量初始化的几种方式

1.定义结构体类型
    struct Dog{
        char *name;
        int age;
        double height;
2.1先定义后初始化
//    struct Dog dd;
//    dd.name = "ww";
//    dd.age = 1;
//    dd.height = 1.5;
2.2定义的同时初始化
//    struct Dog dd = {"ww", 1, 1.5};
注意点: 如果在定义的同时初始化, 那么初始化的顺序必须和结构体类型中的顺序一致
struct Dog dd = {.age = 1, .name = "ww", .height = 1.5};//也可以指定初始化,可以部分初始化.
3.特殊的初始化方式
   数组只能在定义的同时完全初始化, 不能先定义再完全初始化
   但是结构体既可以在定义的同时完全初始化, 也可以先定义再完全初始

//    int ages[3] = {1, 3, 5};
//    int ages[3];
//    ages = {1, 3, 5};//数组不可以

 // 企业开发不推荐这样编写
    struct Dog{
        char *name;
        int age;
        double height;
    };
     struct Dog dd;
     dd = (struct Dog){"ww", 1, 1.5};//强制转换
     printf("name = %s\n", dd.name);
     printf("name = %i\n", dd.age);
     printf("name = %lf\n", dd.height);

• 定义结构体变量的方式

       1.先定义结构体类型, 再定义结构体变量
    /*
    struct Person{
        char *name;
        int age;
        double height;
    };
    struct Person p1;
    struct Person p11;
    */

     2.定义结构体类型的同时定义结构体变量
    /*
    struct Person{
        char *name;
        int age;
        double height;
    } p2;
    p2.name = "lnj";
    printf("name = %s\n", p2.name);
    struct Person p22;
    */
   3.定义结构体类型的同时省略结构体名称, 同时定义结构体变量
    // 匿名结构体
    // 特点: 结构体类型只能使用一次
    struct{
        char *name;
        int age;
        double height;
    } p3;
    p3.name = "it666";
    printf("name = %s\n", p3.name);
    return 0;

• 结构体作用域(和变量相同)
• 结构体数组及初始化

  struct Person{
        char *name;
        int age;
        double height;
    };
方法一:先定义在初始化
 //    struct Person p1 = {"lnj", 35, 1.90};
//    struct Person p2 = {"zs", 22, 1.2};
//    struct Person p3 = {"ls", 33, 1.4};
//    struct Person p4 = {"ww", 56, 1.8};
   数据类型 数组名称[元素个数];
    struct Person ps[4];
     ps[0] = p1;//ps[0] = {"lnj", 35, 1.90};下面也如此
     ps[1] = p2;
     ps[2] = p3;
     ps[3] = p4;
方法二:定义同时初始化
 struct Person ps[4] ={
         {"lnj", 35, 1.90},
         {"zs", 22, 1.2},
         {"ls", 33, 1.4},
         {"ww", 56, 1.8},
     };

• 结构体内存分析

注意点:
* 给整个结构体变量分配存储空间和数组一样, 从内存地址比较大的开始分配
* 给结构体变量中的属性分配存储空间也和数组一样, 从所占用内存地址比较小的开始分配
*
* 注意点:
* 和数组不同的是, 数组名保存的就是数组首元素的地址
* 而结构体变量名, 保存的不是结构体首属性的地址

 struct Person{
        int age;
        int score;
    };
    struct Person p;
    printf("p = %p\n", p); // p = 00000077
    printf("&p = %p\n", &p); // &p = 0060FEA8
    printf("&p.age = %p\n", &p.age); // &p.age = 0060FEA8
    printf("&p.score = %p\n", &p.score); // &p.score = 0060FEAC
    //结构体在分配内存的时候, 会做一个内存对齐的操作
    // 会先获取所有属性中占用内存最大的属性的字节
    // 然后再开辟最大属性字节的内存给第一个属性, 如果分配给第一个属性之后还能继续分配给第二个属性, 那么就继续分配
    // 如果分配给第一个属性之后, 剩余的内存不够分配给第二个属性了, 那么会再次开辟最大属性直接的内存, 再次分配
    //以此类推

• 结构体指针

结构体指针
* 因为结构体变量也会分配内存空间, 所以结构体变量也有内存地址, 所以也可以使用指针保存结构体变量的地址
*
* 规律:
* 定义指向结构体变量的指针的套路和过去定义指向普通变量的一样
*
* 如果指针指向了一个结构体变量, 那么访问结构体变量的属性就有3种方式
* 结构体变量名称.属性名称;
* (*结构体指针变量名称).属性名称;
* 结构体指针变量名称->属性名称;

struct Person{
        char *name;
        int age;
        double height;
    };
    struct Person per = {"lnj", 35, 1.9};//变量名为per
    struct Person *p;//定义一个指针变量p,struct Person为结构体类型
    p = &per;
   printf("per.name = %s\n", per.name);
    printf("per.name = %s\n", (*p).name);
    printf("per.name = %s\n", p->name);

• 结构体的嵌套(提高代码的复用性)

struct Person{
        char *name;
        int age;

        // 出生年月
        int year;
        int month;
        int day;

        // 死亡日期
        int year2;
        int month2;
        int day2;

        // 读幼儿园日期
        // 读小学日期
        // 读中学日期
所以可以把年月日写成一个结构体
// 1.定义了一个日期的结构体类型
    struct Date{
        int year;
        int month;
        int day;
    };
    // 2.定义一个人的结构体类型
    struct Person{
        char *name;
        int age;
        struct Date birthday;
    };
    struct Person p = {"lnj", 35, {2020, 12, 12}};

    printf("name = %s\n", p.name);
    printf("name = %i\n", p.age);
    printf("name = %i\n", p.birthday.year);
    printf("name = %i\n", p.birthday.month);
    printf("name = %i\n", p.birthday.day);

• 结构体和函数(强调结构体作用域和变量相同)

1.虽然结构体是构造类型, 但是结构体变量之间的赋值
* 和基本数据类型赋值一样, 是拷贝
2. 注意点: 定义结构体类型不会分配存储空间
* 只有定义结构体变量才会分配存储空间

struct Person{
        char *name;
        int age;
    };
    struct Person p1 = {"lnj", 35};
    struct Person p2;
    p2 = p1;
    p2.name = "zs";
    printf("p1.name = %s\n", p1.name); // lnj
    printf("p2.name = %s\n", p2.name); //  zs


把p1的name更改写在函数中,更改后内存会释放掉,最终name值不变
struct Person p1 = {"lnj", 35};
    printf("p1.name = %s\n", p1.name); // lnj
    test(p1);
    printf("p1.name = %s\n", p1.name); // lnj
    return 0;
}
void test(struct Person per){
    per.name = "zs";
  }

• 共用体(企业开发中用的比较少)

共用体
*
* 共用体的格式:
* union 共用体名称{
* 数据类型 属性名称;
* 数据类型 属性名称;
* ... ...
* }
* 共用体定义的格式和结构体只有关键字不一样, 结构体用struct,共用体用union
*
* 共用体特点:
* 结构体的每个属性都会占用一块单独的内存空间, 而共用体所有的属性都共用同一块存储空间(同样先分配占用属性最大的字节数)
* 只要其中一个属性发生了改变, 其它的属性都会受到影响
*
* 应用场景:
* 同一个变量, 在不同的时刻,需要表示不同类型数据的时候, 我们就可以使用共用体

     union Test{
        int age;
        char ch;
    };
    union Test t;
    printf("sizeof(p) = %i\n", sizeof(t));

    t.age = 33;
    printf("t.age = %i\n", t.age); // 33
    t.ch = 'a';
    printf("t.ch = %c\n", t.ch); // a
    printf("t.age = %i\n", t.age); // 97,,此时原来age的空间已经给ch用了

• 枚举(开发中经常用到)

枚举?
* 枚举用于提升代码的阅读性, 一般用于表示几个固定的值
* 所以还有一个名称, 叫做枚举常量
*
* 如果某些变量的取值是固定的, 那么就可以考虑使用枚举来实现
*
* 枚举的格式:
* enum 枚举类型名称{
* 取值1,
* 取值2,
* };
* 注意点: 和结构体,共用体不同, 枚举是用逗号隔开
*
* 规范:
* 枚举的取值一般以K开头,后面跟上枚举类型名称, 后面再跟上表达的含义
* K代表这是一个常量
* 枚举类型名称, 主要是为了有多个枚举的时候, 方便区分
* 含义, 你想表达的意思
*
* 枚举的取值:
* 默认情况下从0开是取值, 依次递增
* 也可以手动指定从几开始, 依次递增,例如KGenderMale = 9,从9开始递增

enum Gender{
        KGenderMale , //打印输出为0,可写成male,但是 KGenderMale表达更清晰,编写的时候会提示输出
        KGenderFemale, // 1,可写成female
                       // 2 ... ...
    };
 struct Person{
        char *name; // 姓名
        int age; // 年龄
        enum Gender gender; // 性别
    };
    struct Person p1;
    p1.name = "lnj";
    p1.age = 58;
    p1.gender = KGenderFemale;

    struct Person p2;
    p2.name = "周芷若";
    p2.age = 88;
    p2.gender = KGenderFemale;

• 枚举的作用域(和结构体类型的作用域一样, 和变量的作用域一样)
• 枚举的定义方式(和结构体相同)

   2.1先定义枚举类型, 再定义枚举变量
     enum Gender{
        KGenderMale,
       KGenderFemale,
     };
    enum Gender g1;

    2.2定义枚举类型的同时, 定义枚举变量
   enum Gender{
        KGenderMale,
        KGenderFemale,
     } g2;

    2.3定义枚举类型的同时,定义枚举变量 ,并且省略枚举类型名称
    enum{
        KGenderMale,
        KGenderFemale,
    } g3;

---

回顾局部变量和全局变量
* 局部变量:
* 概念: 定义在{}中,函数中,形参都是局部变量
* 作用域: 从定义的那一行开始, 直到遇到}结束或者遇到return为止
* 存储的位置: 局部变量会存储在内存的栈区中, 会随着定义变量的代码执行分配存储空间, 会随着作用域的结束自动释放
* 特点:
* 相同作用域类, 不能出现同名的局部变量
* 如果不同作用域内有相同名称的变量, 那么在访问时, 内部的会覆盖外部的(就近原则)
*
* 全局变量:
* 概念: 定义在{}外或者函数外的变量, 都是全局变量
* 作用域: 从定义的那一行开始, 直到文件末尾
* 存储的位置: 全局变量会存储在内存的静态区中, 会随着程序的启动分配存储空间, 随着程序的结束释放存储空间
* 特点:
* 如果有多个同名的全局变量, 那么也只会分配一次存储空间, 多个同名的全局变量共用同一块存储空间

• 变量修饰符(auto ,register,extern,static)
  1.修饰局部变量(auto ,register)

• auto和register都是用于修饰局部变量的
  auto int num = 9;
  register int num = 9;
  * 它们年的作用是修饰编程的存储特性
  * auto: 特点就是告诉编译器, 局部变量离开作用域自动释放
  * 默认情况下所有局部变量都是auto的, 所以这一句废话, 所以了解--> 忘记 / 即可
  *
  * register: 特点就是告诉编译器, 将局部变量存储到CPU寄存器中
  * 好处就是访问的速度会更快, 但是在不同平台,不同编译器下, 会做不同的优化,寄存器存储空间非常有限,不一定能够存储进去, 所以还是一句废话, 所以了解 -->

2.static

2.1static对局部变量的作用
如果利用static修饰局部变量, 那么会将局部变量的存储区域从栈区移动到静态区
* 静态区只有程序结束才会释放
void calculate(int r){
// PI使用的概率非常大, 如果是一个局部变量的话, 每次调用都会重新开辟存储空间, 这样性能不好
// 如果PI是static的变量, 那么只会开辟一次, 那么性能就会好很多
static double pi = 3.1415926;
return r * r * pi;
}
2.2 static对全局变量的作用
* 定义一个内部的全局变量,
* 1.该变量只能在定义的文件中使用, 不能在其它文件中使用,例:在dashen.c文件中
* 2.并且该变量会独占一块内存空间
*
* 全局变量的特性:
* 可以定义多个同名的全局变量, 多个同名的全局变量共享一块内存空间
* 哪怕不是同一个文件中的同名全局变量, 也会共享同一块内存空间
* 问题:
* 这样是不是会导致数据混乱,因此引入static,在其他文件中无法使用
*
* 注意点:
* 局部变量如果没有初始化, 里面存储的是垃圾数据
* 全局变量如果没有初始会, 系统会自动初始化为0
2.3 static修饰函数
*代表这事一个内部函数, 只能在当前文件中使用
* 如果一些内部函数不想提供给外界使用, 那么就可以给函数添加一个static
*static必须写到函数的实现中才有效, 不能写到函数的声明中
* 并且如果一个函数已经被声明为static的了, 那么在.h文件中就不要编写该函数的声明了

3.extern

• extern对局部变量的作用
  * extern用于声明一个变量, 声明变量并不会开辟存储空间
  * extern一般用于全局变量, 至今没见过有人用extern来修饰局部变量
  *
  *
  * extern对全局变量的作用
  * extern用于声明一个变量, 声明变量并不会开辟存储空间
  * exter只能用于全局变量, 不能用于局部变量
  *
  * 原因:
  * 局部变量, 只有执行到那一行代码才会分配存储空间, 所以哪怕声明了 ,但是在使用时还是没有分配, 所以还是不能存储数据
  * 全局变量, 会随着程序的启动分配存储空间, 所以只要声明了, 使用时已经分配好了存储空间, 一定能够使用, 一定能够存储数据
  *
  *
  如果利用extern修饰函数, 代表这是一个外部函数, 其它文件中也可以使用
  * 注意点: 默认情况下所有函数都是外部函数, 所有的函数都可以在其它文件中访问, 所以extern是一个废物
  extern必须写到函数的实现中才有效, 不能写到函数的声明中

{extern int num;
    num = 998;
printf("num = %i\n", num);
    return 0;
}  int num;

• 企业开发中大部分都是多人开发, 多人开发就是多个人一起写一个项目,所以在企业开发中, 都是多人同时操作多个不同的文件

例如: 现在有两个员工
* 一个是菜鸟, 一个是大神
* 调用大神写好的代码
* 编写主要的业务逻辑代码
*
在企业开发中如何进行多人开发
* 一般情况下会将(函数的实现), 编写到.c文件中, 同时会将.c文件中需要暴露给外界使用的方式名称的声明写到.h文件中
* 为什么编写了.c文件还需要编写一个.h文件, 原因很简单, (函数的实现)是你编写的, 那么函数的作用,形参你最了解, 所以应该由你来编写

注意:
* 在企业开发中, 其它人不需要关系函数具体是如何实现的, 只需要关心如何使用这个函数即可
* 所以(函数的实现)和声明都应该让同一个人来完成
*
* main函数中一般为主要业务逻辑,不能有太多冗余代码
* #include的作用:
* 将后面指定文件中的内容拷贝到当前文件中
* <>从系统的环境变量中去拷贝, 一般情况下只有用到系统函数才使用<>
* " "从指定的路径中去拷贝, 一般情况下使用同事/自己编写的.h文件都用""

    #include "ds.h" // 导入大神编写的.h文件,例:#include "D:\WWW\ds.h"
    本质就是将大神编写的.h文件中的代码拷贝过来