小白学开发（iOS）基础C_结构体（2015-07-18）

 //
//  main.c
//  结构体
//
//  Created by admin on 15/7/18.
//  Copyright (c) 2015年 admin. All rights reserved.
//

#include <stdio.h>

int main(int argc, const char * argv[]) {
/*
     1. 结构体
        注：  结构体和数组都是构造类型，两者的区别如下：
             结构体： 可以保存不同类型的数据
             数  组： 只能保存同一种数据类型

     2. 结构体类型定义
        struct 结构体变量名
       ｛
            成员类型 成员名称；
            成员类型 成员名称；
            ...
        ｝;
 */
    struct person           // 定义结构体类型时，不会分配存储空间
    {
        char *name;         // 也可以是指针类型
        int age;
        double height;
    };    // 注意最后加分号

//   3. 根据结构体类型定义结构体变量
    struct person p;       // 根据结构体类型定义结构体变量时，才会分配存储空间


/*
     4. 结构体变量初始化的三种方法
*/
//      4.1 方法一： 先定义，后取出成员分别赋值
        p.name = "lixiang";
        p.age = 10;
        p.height = 175.2;
    
//      4.1 方法二： 定义的同时，按照结构体类型顺序赋值
        struct person p1 = { "lixiang", 10, 157.2 };
    
//      4.1 方法三： 定义的同时，指定赋值顺序赋值
        struct person P2 = {.age = 10, .name = "liuxiang", .height = 175.2};
    
    return 0;
}

//
//  main.c
//  结构体_内存分析
//
//  Created by admin on 15/7/18.
//  Copyright (c) 2015年 admin. All rights reserved.
//

#include <stdio.h>

void test();
int main(int argc, const char * argv[]) {

//      1.结构体变量分配内存，是按照补齐算法，即最大成员占用字节的整数倍
    struct person
    {
        char *name;     //  char类型的指针，指针占8个字节
        int age;        //  int类型占用4个自己
        char sex;       //  char类型的变量，占1个字节
        float score;    //  浮点型，占4个字节
//      这里最大成员占用是8  而8+4+1+4 ＝ 17， 则8的最大整数倍就是24，那么这个结构体所分配的存储空间为24
    };
    
    struct person p;
    
    unsigned long size = sizeof(p);
    printf("size = %lu\n", size);
    test();
    
    return 0;
}
//      2. 结构体体的作用范围： 结构的作用范围与变量的作用范围相同

void test()
{
    struct person      //   结构体的第一个成员的地址就是这个结构体的地址
    {
        char *name;
        int age;
        char sex;
    };

    struct person p1 = {"xiaobai", 10, '0'};
    struct person p2;
    
    p2 = p1;        //  把d1中的所有成员对应的赋值给d2中的成员
    p2.age = 50;    //  取出某个成员再次赋值
    printf("name = %s, age = %d, sex = %c\n", p1.name, p1.age, p1.sex);
    printf("name = %s, age = %d, sex = %c\n", p2.name, p2.age, p2.sex);
}

//
//  main.c
//  结构体_定义结构体的多种方式
//
//  Created by admin on 15/7/19.
//  Copyright (c) 2015年 admin. All rights reserved.
//

#include <stdio.h>

int main(int argc, const char * argv[]) {

/*  
    1.第一种定义方式：  先定义结构体类型，再根据类型定义结构体变量
*/
    struct Person
    {
        char *name;
        int age;
        int no;
    };
    
    struct Person p;
/*
    2. 第二种定义方式：  定义结构体类型的 同时 定义结构体变量，即跟在大括号之后
*/
    struct Person1
    {
        char *name;
        int age;
        int no;
    } p1;
/*
    3. 第三种定义方式：  定义匿名机构体，定义类型的 同时 定义变量， 且类型名称为空，
                注意： 匿名结构体不能复用（因为没有结构体名），只能使用一次
*/
    struct
    {
        char *name;
        int age;
        int no;
    } p2;
  
    return 0;
}

//
//  main.c
//  结构体_结构体数组
//
//  Created by admin on 15/7/19.
//  Copyright (c) 2015年 admin. All rights reserved.
//

//  注：  结构体是用来存储不同数据类型的，那么当存储多条同一个结构体类型的数据的时候，
//        不用定义多个结构体变量来存储每一条数据，可以定义一个结构体类型的数组统一存储，
//        数组中的每个元素存储一条结构体类型的数据

#include <stdio.h>

int main(int argc, const char * argv[]) {

/*
    1. 定义结构体类型的数组的格式
        结构体类型 数组名 [元素个数]；
 
    注意： 要想给结构体一次性赋值，只能在定义结构体变量的同时赋值
          要想给数组一次性赋值，只能在定义数组的同时赋值
 
    例如： char age[3];
          age  = {'a', 'b', 'c'};       // 这种方法是错误的，因为age是数组名，此句的意思为：
                                        // 将数组元素赋值给了数组的地址，结构体类似
*/

//  首先定义一个结构体类型
    struct Person
    {
        char *name;
        char *bumen;
        int no;
    };
//  定义结构体数组
    
    struct Person array[3] =
    {
        {"xjx", "ios", 0001},
        {"cao", "net", 0002},
        {"liu", "php", 0003}
    };
    
    return 0;
}

//
//  main.c
//  结构体_结构体指针
//
//  Created by admin on 15/7/19.
//  Copyright (c) 2015年 admin. All rights reserved.
//

#include <stdio.h>

int main(int argc, const char * argv[]) {

/*
    1. 定义指向结构体的指针
       定义格式：   struct 结构体类型名 *指针变量名；
                  指针变量名 ＝ &结构体变量名；  //让这个指针指向某个结构体变量
*/
//      首先定义一个结构体
    struct Person
    {
        char *name;
        int  age;
    };
//      定义一个结构体变量
    struct Person p;
    
//      定义结构体指针
    struct Person *point;
    
//      让结构体指针指向某个定义的结构体变量
    point = &p;

//      使用指针访问结构体变量中的内容, 指针point访问的是整个结构体的那块存储空间
    (*point).age = 20;
    (*point).name = "xjx";
    printf("age = %d\nname = %s\n", p.age, p.name);
    
//      指针访问结构体变量内容的 常用方式 (重点掌握)
//      格式： 指针名->结构体成员名；
    point->age = 10;
    point->name = "baobao";
    printf("age = %d\nname = %s\n", point->age, point->name);
    
    return 0;
    
}

//
//  main.c
//  结构体_结构体和函数
//
//  Created by admin on 15/7/19.
//  Copyright (c) 2015年 admin. All rights reserved.
//

#include <stdio.h>

//  定义一个结构体（这个结构体没有定义在任何一个函数中，所以作用范围为全局）
    struct Person
    {
        char *name;
        int age;
    };
//  定义结构体变量
    struct Person temp = {"baobao", 100};

//  定义一个函数，将 结构体变量 作为参数传入
void test(struct Person temp)           //  结构体变量temp
{
    temp.name = "xjx";
    temp.age = 20;
}

//  定义一个函数，将 指向结构体的指针 作为函数参数传入
void test1(struct Person *pointer)
{
    pointer->age = 30;
    pointer->name = "zhang";        //  通过指针可以给结构体中变量赋值，但是这里没有涉及结构体变量
}

//  定义一个函数，将 指向结构体的指针 作为函数参数传入
void test2(struct Person *pointer1)
{
    struct Person p = {"yang", 80};     //  定义一个结构体变量
    pointer1 = &p;                      //  传入的指针指向结构体变量
    pointer1->age = 60;                 //  通过指针改变结构体变量p的值
    pointer1->name = "jiang";
}


int main(int argc, const char * argv[]) {

//  当结构体作为函数参数传递的之后是值传递
    
    struct Person p = {"zhou", 50};
    printf("name = %s\nage = %d\n", p.name, p.age);
    test(p);
    printf("name = %s\nage = %d\n", p.name, p.age); // 注意：这里是值传递，两次打印均为name ＝ zhou，age ＝ 50
    return 0;
    
}

//
//  main.c
//  结构体_结构体的嵌套定义
//
//  Created by admin on 15/7/19.
//  Copyright (c) 2015年 admin. All rights reserved.
//

#include <stdio.h>

int main(int argc, const char * argv[]) {

/*
    结构体的嵌套定义：即在结构体中定义结构体
                   结构体是可以嵌套定义的,可以把其它结构体当作自己的成员的一部分
*/
    
//  首先定义一个结构体
    struct Time
    {
        int hh;
        int ss;
        int mm;
    };
//  再定义第二个结构体，其中将第一个结构体作为成员嵌入
    struct Date
    {
        int year;
        int month;
        int day;
        struct Time time;
    };
//  定义一个结构体
    struct Person
    {
        int age;                //  这个人的年龄
        struct Date birthday;   //  这个人的生日
        struct Date ruzhu;      //  这个人的入职日期
        struct Date lizhi;      //  这个人的离职日期
    };
    
//  下面定义一个Person结构体类型变量 并 初始化
    
    struct Person no1 =
    {
        20,
        {1995, 10, 23, {12, 20, 63}},
        {2014, 05, 16, {16, 23, 26}},
        {2015, 12, 26, {18, 56, 30}}
    };
    
    printf("age = %d, year = %d, m onth = %d, day = %d\n, hh = %d, ss = %d, mm = %d\n", no1.age, no1.birthday.year, no1.birthday.month, no1.birthday.day, no1.birthday.time.hh, no1.birthday.time.ss, no1.birthday.time.mm);
    
//  注意：结构体中不能嵌套自己，否则会造成死循环
    
    struct Person1
    {
        int age;
        struct Person1 p;       //  这个是错误的  不能嵌套自己
    };
    
    return 0;
}