结构体的初始化
 
     成员初始化的顺序必须和结构体定义的顺序一致
  
     1）定义的同时进行初始化
       
        形式一：
        struct Car{
            int lunzi;
            int speed;
            int zuweishu;
            char *pp;
        }bc={4,50,20,"奔驰"};
 
        形式二：
        struct Car bmw={3,200,200,"宝马X9"};
 
     2）先定义结构变量，在初始化
 
        struct Car ad;  //定义结构体变量
 
        ad.lunzi = 2;
        ad.speed = 10;
        ad.zuweishu = 1;
        ad.pp = "奥拓自行车";
 
 
     3）用结构体变量去初始化另外一个结构体变量
 
        struct Car byd;
        byd = bmw;  //用一个已知的结构体变量初始化另外一个结构体 
　　　　　// 这里是值的传递,不是地址的传递
 
 
     4）部分初始化
 
       struct Car jac={.pp="江淮"};
 
     5）容易犯的错误

 //指定对齐的模数
    #pragma pack(2)
    
    struct A{
        int a;
        char c;
        char c1;
        int b;
    };
    
   printf("%ld\n",sizeof(struct A));
    //模数  4
    struct B{
    
        char c1[13];  //4        16  --->3
        char c2[21];  //5        20
        int b;        //1        4

    };

//1、第一种初始化方法
    struct Student{
        
        char *name;
        char sex;
        float score;
        
    }s[2]={{"sb",'F',59.9f},{"cgx",'M',60.0f}};
    
    for (int i=0; i<2; i++) {
        printf("姓名：%s,性别：%c,成绩：%f\n",s[i].name,s[i].sex,s[i].score);
    }
    printf("\n\n");
    //2、第二种初始化方法
    struct Student s1[2]={{"sb",'F',59.9f},{"cgx",'M',60.0f}};
    for (int i=0; i<2; i++) {
        printf("姓名：%s,性别：%c,成绩：%f\n",s1[i].name,s1[i].sex,s1[i].score);
    }
    printf("\n\n");
    //3、第三种初始化
    struct Student s2[2];
    s2[0]=(struct Student){"sb",'F',59.9f};
    s2[1]=(struct Student){"fengjie",'M',60.0f};
    for (int i=0; i<2; i++) {
        printf("姓名：%s,性别：%c,成绩：%f\n",s2[i].name,s2[i].sex,s2[i].score);
    }
    
    //4、指定成员的初始化
    struct Student s3[2];
    s3[0].name = "zbz";
    s3[1].name = "zxt";

//局部的结构体
    struct Student{
        
        char *name;
        float score;
        
    };
    
    //定义一个指向结构体（Student）变量的值真
    struct  Student *p;
    
    //定义结构体变量
    struct  Student stu1;
    //stu1结构体变量，初始化
    stu1.name = "sb";
    stu1.score = 59.9;
    //stu 访问属性--->直接访问
    printf("%s,%f\n",stu1.name,stu1.score);
    
    //给结构体指针初始化
    p = &stu1;  // &取地址

    //使用指针变量p间接的访问stu1
    (*p).name = "zbz";
    (*p).score = 58;
    
    printf("%s,%f\n",(*p).name,(*p).score);
    
    struct Student *p1;
    p1 = p;   //地址的赋值,p1和p都指向同一块内存区域
    (*p1).name = "cgx";
    (*p1).score = 57;
    printf("%s,%f\n",(*p1).name,(*p1).score);
    printf("%s,%f\n",p1->name,p1->score);

/*
 嵌套结构体
 
   在定义结构体的时候，它的成员又是一个结构体变量（不是自己的结构体变量）
 
 嵌套结构体的初始化：
 
 
 
 
 
 
 */


#include <stdio.h>

//定义时间的结构体
struct Time{

    int hour;
    int min;
    int second;

};

//定义日期的结构体
struct Date{

    int year;
    int month;
    int day;
    struct Time time;


};


struct Employer{

    char *name;
    int age;
    char sex;
    //结构体的嵌套定义
    struct Date inDate;//是一个构造类型变量
    struct Date goDate;
    //结构体定义的时候，不能嵌套自己的结构体变量
    //struct Employer xiashu;

};

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

    //对嵌套的结构体进行赋值
    struct Employer zbz={"zbz",28,'F',{2014,10,23,{12,12,12}},{2014,10,25,{11,11,11}}};
    char *fm="姓名：%s,年龄：%d,性别:%c，入职时间：%d-%02d-%02d %02d:%02d:%02d,离职时间：%d-%02d-%02d %02d:%02d:%02d\n";
    //对嵌套的结构体进行访问
//    printf(fm,zbz.name,zbz.age,zbz.sex,zbz.inDate.year,zbz.inDate.month,zbz.inDate.day,zbz.goDate.year,zbz.goDate.month,zbz.goDate.day);
    
    struct Employer *p;
    //定义结构体的指针
    p = &zbz;
    printf(fm,p->name,p->age,p->sex,p->inDate.year,p->inDate.month,p->inDate.day,p->inDate.time.hour,p->inDate.time.min,p->inDate.time.second,p->goDate.year,p->goDate.month,p->goDate.day,p->goDate.time.hour,p->goDate.time.min,p->goDate.time.second);
    
    return 0;
}

#include <stdio.h>
struct Car{

    int lunzi;
    int speed;
    char *pp;

};

int  sum(int x,int y){
    return  x+y;
}

void changeCar(struct Car c1){
    c1.lunzi = 80;
    c1.pp="火车";
}
void changCar2(struct Car *pCar){

//    (*pCar).lunzi = 100;
//    (*pCar).pp = "火车";
    
    pCar->lunzi = 100;
    pCar->pp = "火车";
}
int main(int argc, const char * argv[])
{

    
    struct Car car={3,15,"时风"};
    struct Car car1={4,250,"永久"};
    
    //1、用结构体的成员作为函数的参数，是值传递
    int s = sum(car.lunzi,car1.lunzi);
    printf("两个车一共：%d轮子\n",s);
    
    //2、结构体变量作为函数的参数
    //  用结构体变量名作为函数的参数，还是值传递
    changeCar(car1);
    printf("%s,%d\n",car1.pp,car1.lunzi);  //永久 4
    
    //定义一个结构体的指针
    struct Car *p;
    p = &car1;
    
    changCar2(p);
    printf("%s,%d\n",car1.pp,car1.lunzi);  //火车 100
    
    return 0;
}