ios学习之旅------玩转结构体

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;
}

watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center" alt="">

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;
}

watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center" alt="">

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;
}

watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center" alt="">

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;
}