1.全局变量和局部变量
局部变量：
    概念：定义函数内部变量
    定义格式：变量类型 变量名称;
    作用域：从定义那一行開始到所在代码块结束
    生命周期：从代码运行到定义的哪一行開始，到其所在的代码的结束为止
    特点：同样的代码块中不能够有同名的变量
         不同的代码块中能够有同名的变量。内部的变量会覆盖外部定义的变量
全局变量：
    概念：定义在函数外部变量
    定义：变量类型 变量名称 = 值;
    声明：变量类型 变量名称;
    特点：1、不能够反复定义，但能够反复声明
         2、局部变量能够与全局变量同名。在局部变量的作用域范围内。那么局部变量会覆盖全局变量
         3、假设未定义仅有声明，系统自己主动给它定义并将其初始化为0
    作用域：从定义的那一行開始。直到文件结束

    生命周期：从程序启动開始。直到程序退出才消亡

#include <stdio.h> 
 int num;//声明
int main(int argc, const char * argv[]) {    
    printf("num = %d\n",num);    
    int num = 20;
    printf("num = %d\n",num);
    {
        num = 40;
        int num = 10;
        printf("num = %d\n",num);
        num = 30;
    }
    printf("num = %d\n",num);         
    return 0;
}

2.结构体
  构造类型：由已有的数据类型构成类型
  1、数组：多个同种类型的数据构成的那么一种类型
     特点：仅仅能存放一种数类型
  2、结构体：从来存放表示某种特定含义的一组数据
           它是对数据封装
           函数对功能封装
     优点：提高代码的可读性
          提高数据易用性
          提高代码可维护性
 
     定义结构体：
         1、定义结构类型
             struct 结构类型名称{
             成员类型 成员名称;
             ...
             };//必须加分号
         2、通过结构体类型定义结构变量
            struct 结构类型名称 结构体变量名称;

#include <stdio.h>
int main(int argc, const char * argv[]) {

    //    int scores[] = {59,60};    
    //     int  年龄  姓名 char *  性别 char  身高 double  体重 double        
    //    int age;
    //    char sex;
    //    double height;
    //    double weight;
    //    char *name;
    //
    //    int ages[50];
    //    char sex[50];
    //    ....
    //  定义一个人结构体类型
    struct Person{
        int age;
        char sex;
        double height;
        double weight;
        char *name;
    };    
    //  int num;
    //  int * pointer;
    //  定义结构体变量
    struct Person person;    
    //  訪问结构体成员
    person.age = 10;    
    person.sex = ‘M‘; 
    person.weight = 20.2;    
    person.height = 1.2;    
    person.name = "小明";    
    printf("age = %d,sex = %c,weight = %.2lf,height = %.2lf,name = %s\n",person.age,person.sex,person.weight,person.height,person.name);
   
    return 0;
}

3.定义结构体的多种类型

#include <stdio.h>
/*
 第一种方式
  1、先定义结构体类型
  2、定义结构变量
 */
void test()
{
    
    struct Person{
        int age;
        double height;
    };
    
    struct Person p1;
}

/*
另外一种方式
   定义结构体类型的同一时候定义结构变量
 */
void test1()
{
    struct Person{
        int age;
        double height;
    } p1,p2 = {20,1.75};
    
    p1 =(struct Person){10,1.2};
    
    printf("age = %d,height = %.2lf\n",p1.age,p1.height);
    
    printf("age = %d,height = %.2lf\n",p2.age,p2.height);
    //  结构体类型定义是不能够重名的
    //    struct Person{
    //        int age;
    //        double height;
    //    } p3,p4 = {20,1.75};
}
/*
第三种方式
   定义匿名的结构类型的同一时候定义结构体变量
 */
int main(int argc, const char * argv[]) { 
    struct{
        int age;
        char sex;
    } p1,p2 = {20,‘M‘};
    p1.age = 10;
    p1.sex = ‘W‘;
    printf("age = %d,sex = %c\n",p1.age,p1.sex);
    p1 = p2;
    printf("age = %d,sex = %c\n",p1.age,p1.sex);
    //
    //    p1 = (struct) {10,‘w‘};
    //   1、不支持总体赋值
    //   2、结构体类型不能反复使用
    struct{
        int age;
        char sex;
    } p3,p4 = {20,‘M‘};   
    return 0;
}

4.结构体作用域
   在函数内部，结构类型作用域就如同局部变量一样
   在外边定义的结构体类型像全局变量的作用域
   作用域：从定义的那一行開始直到文件的结束
   注意点：结构类型不能声明
   结构体类型的作用，除了不能声明以外。其它与普通变量一样

#include <stdio.h>
struct Person{
    int age;
    char sex;
};
int main(int argc, const char * argv[]) {  
    struct Person p2;    
    p2.sex = ‘s‘;
    p2.age = 10;    
    struct Person{
        int age;
    };  
    struct Person p = {10};
    printf("age = %d\n",p.age);  
    {
        struct Person p = {20};
        struct Monkey{
            char *name;
        };    
    }    
    return 0;
}

5.结构体数组
   结构体数组：数组元素为结构体数组
   定义结构体数组
   结构类型 数组名称[元素个数];
   数组元素的类型 数组名称[元素个数];

#include <stdio.h>
//普通情况下结构体类型都是定义在函数的外部
struct Dog{
    char *name;
    int age;
};
void test()
{
    //    int nums[] = {1,2,3,4};
    //    结构体假设没有初始化。它里面都是垃圾值
    //  第一种方式：向定义结构体数组然后初始化
    struct Dog dogs[5];
    dogs[0] = (struct Dog){"旺財",1};
    dogs[1].age = 1;
    dogs[1].name = "大黄";   
    //  遍历结构体数组    
    for(int i = 0;i < 5;i++)
    {
        printf("age = %d,name = %s\n",dogs[i].age,dogs[i].name);
    }
}
void test2()
{
    //  定义结构体数组的同一时候进行初始化
    //  假设没有显式初始化的结构体。那么这个结构体中全部成员都会被初始化为0
    struct Dog dogs[10] = {{"旺財",1},{"大黄",2},{"来福",3},{"小黑",4},{"小白",5}};
    //  计算数组的元素个数
    int len = sizeof(dogs) / sizeof(struct Dog);    
    for(int i = 0;i < len ;i++)
    {
        printf("age = %d,name = %s\n",dogs[i].age,dogs[i].name);
    }
    
}
int main(int argc, const char * argv[]) {  
//    test();
    tset2();
    return 0;
}

6.结构体与指针
   结构体指针：指向结构体的指针
   指针所指向的数据类型 * 指针变量名称;
   结构类型 * 指针变量名称;

#include <stdio.h>
struct Student{
    char *name;//姓名
    int no;//学号
    double score;//成绩
};
int main(int argc, const char * argv[]) {   
    struct Student stu = {"大木",60,59};    
//   定义结构体指针
    struct Student *sp1;
    sp1 = &stu;
//  定义的同一时候进行初始化
    struct Student *sp = &stu;
//  通过指针訪问结构体的成员的第一种方式
    (*sp).score = 60;    
//  另外一种方式(重点)
    sp->name = "小木";
    sp->no = 59;
    printf("name = %s,no = %d,score = %.2lf\n",stu.name,stu.no,stu.score);
      
    return 0;
}

7.结构体嵌套
       一个结构体内部能够有其它类型的结构体成员
 结构体嵌套的注意点：
   1、结构体不能够嵌套自己,不能有字节这样的类型的成员
   2、结构体能够嵌套自己类型的指针

#include <stdio.h>
//定义了一个日期的结构体
struct Time{
    int hour; // HH
    int minute;//mm
    int second;//ss
};
struct Date{
    int year;
    int month;
    int day;
    struct Time time;
};
struct Employee{    
    int no;
    char name[20];
//  入职日期
//    int year;
//    int month;
//    int day;
    struct Date inDate;
//  生日
//    int birthyear;
//    int birthmonth;
//    int birthday;
    struct Date birthday;
//  离职日期
//    int goyear;
//    int gomonth;
//    int goday;
    struct Date outDate;
};
void test()
{
    struct Employee emp = {1,"大幕",{2014,10,14,{12,12,12}},{1990,10,14},{2014,11,14}};
    
    printf("no = %d,name = %s,入职日期 = %d-%d-%d %d:%d:%d\n"
           ,emp.no,emp.name,emp.inDate.year,emp.inDate.month,emp.inDate.day,
           emp.inDate.time.hour,emp.inDate.time.minute,emp.inDate.time.second);
    }
struct Person{
    char *name;
//    struct Person son;
    struct Person *son;
};
/*
 1.某班有5个学生，三门课。分别编写3个函数实现下面要求：
 （1） 求各门课的平均分；
 （2） 找出有两门以上不及格的学生，并输出其学号和不及格课程的成绩。
 （3） 找出三门课平均成绩在85-90分的学生，并输出其学号和姓名
 */
int main(int argc, const char * argv[]) {   
    struct Person father = {"father"};   
    struct Person son = {"son"};    
    father.son = &son;    
    printf("son name = %s\n",father.son->name);

    return 0;
}

8.枚举
  枚举：一个一个列举出来
  枚举作用：消除魔法数字
  使用场景：当某个东西仅仅有那么几个取值时候就是用枚举
  定义枚举格式
     enum 枚举类型的名称{
     元素,//逗号
     ...
     };
   注意点：
   1、枚举类型定义中。全部元素都是整形常量
   2、枚举类型的本质就是整形

#include <stdio.h>
//定义性别枚举类型
enum Sex{
     Man,
     Woman,
     Other
};

//int Man = 10;//枚举定义之后，后面不可定义与成员同样变量
void test()
{
    //  在代码中出现的这样的表示特殊含义数字，我们魔法数字
    //    int sex = 0;  
    enum Sex sex;
    printf("%d\n",Man);
    int Man = 10;
    printf("%d\n",Man);  
    //    sex = 1;// 这里不能把要给数字赋值给一个枚举类型的变量，这样枚举存在的意义就没有了
    //    Man = 1;
    
}
// 能够指定枚举中每个元素值
enum Season{
   Spring = 2,
   Summer,
   Autumn,
   Winter,
   SOther = 9
};
void PrintSeason(enum Season season)
{
    switch (season) {
        case Spring: //Case后面的值务必与枚举中成员一致，不要出现魔法数字
            printf("春季\n");
            break;
        case Summer:
            printf("夏季\n");
            break;
        case Autumn:
            printf("秋季\n");
            break;
        case Winter:
            printf("冬季\n");
            break;
        case SOther:
            printf("不是地球上季节\n");
            break;
        default:            
            break;
    }
}
int main(int argc, const char * argv[]) {
    printf("%d,%d,%d\n",Man,Woman,Other);
    printf("%d,%d,%d,%d\n",Spring,Summer,Autumn,Winter);       
    enum Season season = Summer;    
    PrintSeason(season);
    
    return 0;
}

9. typedef:
    给已有数据类型起别名   
   基本数据类型
   int char float double
   结构体
   枚举
   指针
      1、普通变量的指针
      2、结构体指针
      3、函数指针
   基本数据类型
  定义格式：typedef 已有数据类型 别名;

#include <stdio.h>
void testBaseType()
{   
    typedef int  Int;   
    Int num = 10;   
    typedef Int Integer;    
    Integer a = 20;    
    printf("%d\n",a);   
}
/*
    给结构体类型起别名 
 */
void testStruct()
{    
//  第一种方式：先定义结构体类型再给结构体类型起别名
    struct _Person{
        int age;
        char *name;
    };    
    typedef struct _Person Person;    
    Person p1 = {10,"小红"};
    printf("age = %d,name = %s\n",p1.age,p1.name);   
// 另外一种方式，定义结构体类型的同一时候给结构体类型起别名       
    typedef struct _Dog{
        int age;
        char *name;
    } Dog;    
    Dog dog = {1,"大黄"};    
//  第三种方式：定义匿名结构体类型的同一时候给结构体起一个别名   
    typedef struct{
        int age;
        char * name;
    } Cat;    
    Cat cat = {1,"tom"};   
}
//给枚举起别名
void testEnum()
{
//  1、先定义枚举类型然后给枚举起别名   
    enum _Sex{
      Man,
      Woman,
      Other
    };   
    typedef enum _Sex Sex;    
    Sex sex = Man;
//  2、定义枚举类型的同一时候给枚举类型起一个别名   
   typedef enum _Season{
        Spring,
        Summer
    } Season;        
    Season season = Spring;    
//  3、定义匿名枚举类型同一时候给枚举起一个别名   
    typedef enum {
         Cong,
         Suan,
         Jiang
    } TiaoWei;    
    TiaoWei zuoLiao = Cong; 
}
//4、指针类型
//4.1 基本数据类型的指针
void testTypedefBasicPointer()
{
    typedef  int * IntPointerType;
    int a = 10;    
    IntPointerType p = &a;   
    *p = 20;   
    printf("%d\n",a);    
}
//4.2 给结构体类型的指针起别名
void testTypedefStructPointer()
{
    typedef struct {
        char *name;
        int age;
    } Person;    
    typedef Person * PersonPointerType;    
    Person p = {"张三",10};    
    PersonPointerType pp = &p;        
    typedef struct _Cat{
        char *name;
        int age;    
    } Cat, * CatPointerType;    
    Cat cat = {"小猫",1};    
    CatPointerType catPointer = &cat;    
    printf("name = %s,age = %d\n",catPointer->name,catPointer->age);    
}
//4.3 给枚举类型的指针起别名
void testTypedefEnumPointer()
{
//  先定义枚举类型
    enum _Sex{
         Man,
        Woman,
        Other
    };    
    typedef enum _Sex * SexPointer;   
    enum _Sex sex = Man;        
    SexPointer sexPointer = &sex;    
    *sexPointer = Woman;    
    printf("%d\n",sex);    
}
//4.4 给函数指针起别名
int sum(int num1,int num2){    
    return num1 + num2;
}
int minus(int num1,int num2){    
    return num1 + num2;
}
//给函数指针起别名
//typedef 指针所指向的函数的返回值类型 (*函数指针类型别名)(所指向的函数的形參列表);
void testTypedefMethodPointer()
{   
//    int (*sumPointer)(int num1,int num2) = sum;
//    
//    int (*minusPointer)(int num1,int num2) = minus;   
    typedef  int (*MethodPointerType)(int num1,int num2);    
    MethodPointerType sumPointer = sum;    
    MethodPointerType minusPointer = minus;    
    int rs =  sumPointer(10,20);
    printf("rs = %d\n",rs);    
}
//了解
void testTypedefArrayPointer()
{
    char names[][10] = {"xtf","zbz","wf"};   
    char (*arrayPoiner)[10];   
    arrayPoiner = names;    
    typedef char (*ArrayPointerType)[10];    
    ArrayPointerType pointer = names;   
    printf("%s\n",pointer[0]);   
}
int main(int argc, const char * argv[]) {        
//
//    testBaseType();
//    testStruct();
    testTypedefBasicPointer();    
    testTypedefStructPointer();    
    testTypedefEnumPointer();    
    testTypedefMethodPointer();    
    testTypedefArrayPointer();
    return 0;
}