超详细的结构体声明、定义及初始化

结构体概念

结构体是由一系列具有相同类型或不同类型的数据构成的数据集合，叫做结构。
在C语言中，结构体指的是一种数据结构，是C语言中聚合数据类型的一类。结构体可以被声明为变量、指针或数组等，用以实现较复杂的数据结构。结构体同时也是一些元素的集合，这些元素称为结构体的成员，且这些成员可以为不同的类型，成员一般用名字访问。

比如存储一个班级学生的信息，肯定包括姓名、学号、性别、年龄、成绩、家庭地址等项。这些项都是具有内在联系的，它们是一个整体，都表示同一个学生的信息。但如果将它们定义成相互独立的变量的话，就无法反映它们的内在联系：

char name[20];   //姓名
int num;         //学号
char sex;        //性别
int age;         //年龄
float score;     //成绩
char addr[30];   //家庭住址

而且问题是这样写的话，只是定义了一个学生，如果要定义第二个学生就要再写一遍。这样不仅麻烦，而且很容易混淆。要是能定义一个变量，而且这个变量正好包含这六个项，即将它们合并成一个整体的话就好了。

结构体就是为了解决这个问题而产生的。结构体是将不同类型的数据按照一定的功能需求进行整体封装，封装的数据类型与大小均可以由用户指定。

基本数据类型只能满足一些基本的要求，只能表示具有单一特性的简单事物。但是对于一些有很多特性的复杂事物，每一个特性就是一个基本类型。这个复杂的事物是由很多基本类型组合在一起而生成的一个比较复杂的类型，这时就需要运用结构体：

声明结构体类型

声明一个结构体类型的一般形式为：

struct结构体名
{
    成员列表
}；

比如将学生的信息定义成结构体：

struct STUDENT
{
char name[20];
int num;
char sex;
int age;
float score;
char addr[30];
};  //最后的分号千万不能省略

说明：

1. 最后的分号千万不能省略。为了防止最后忘记分号，最好先将框架写出来，写的时候直接把分号加上：
   struct STUDENT
   {};

2. 结构体类型是由一些基本数据类型组合而成的新的数据类型。因为结构体类型中的成员是由程序员人为定义的，所以结构体类型是由我们人为定义的数据类型。

3. struct 是声明结构体类型时必须使用的关键字，不能省略。“结构体”这个词是根据英文单词 structure 译出的。

4. struct STUDENT 是定义的数据类型的名字，它向编译系统声明这是一个“结构体类型”，包括 name、num、sex、age、score、addr 等不同类型的项。

5. struct STUDENT 与系统提供的 int、char、float、double 等标准类型名一样，都是数据类型，具有同样的作用，都是用来定义变量的。

但结构体类型和系统提供的标准类型又有所不同：“结构体类型”不仅要求指定该类型为“结构体类型”，即 struct，而且要求指定该类型为某一“特定的”结构体类型，即“结构体名”。因为只有 struct 才是关键字，而“结构体名”是由编程人员自己命名的。所以说，“结构体类型”不是由系统提供的，而是由编程人员自己指定的。

这也就意味着，根据“结构体名”的不同，可以定义无数种“具体的”、“特定的”结构体类型。所以结构体类型并非是固定的一种类型。而 int 型、char 型、float 型、double 型都是固定的类型。

6. “结构体名”的命名规范是全部使用大写字母。

7. “结构体名”是结构体类型的标志。花括号内是该结构体的各个成员，它们共同组成一个整体。对各个成员都要进行类型声明，如：
   char name[20];
   int num;
   char sex;
   int age;
   float score;
   char addr[30];
   成员名的命名规则与变量名相同。

8. 声明结构体类型仅仅是声明了一个类型，系统并不为之分配内存，就如同系统不会为类型 int 分配内存一样。只有当使用这个类型定义了变量时，系统才会为变量分配内存。所以在声明结构体类型的时候，不可以对里面的变量进行初始化。
   定义结构体变量
   以上只是声明了一个数据类型——“结构体类型”。它只是一个类型，与 int、char、float、double 一样，并没有具体的数据，系统也不会给它分配实际的内存单元。要想在程序中使用“结构体类型”数据，必须要定义“结构体类型变量”，并在其中存放具体的数据。就比如：
   int a;
   其中 int 是类型，而 a 是用这个类型定义的变量。结构体也是一样的，上一节只是声明了一个类型，而本小节要使用这个类型来定义变量，就这么简单。一个是类型，一个是用这个类型定义的变量。

定义结构体类型变量有两种方法：

一、先声明“结构体类型”，再定义“结构体类型变量”。这种方式比较自由！

结构体类型的声明和函数声明一样，如果在所有函数，包括main函数的前面进行声明，那么就可以在所有函数中直接用它来定义变量；但如果是在某个函数中进行声明，那么只能在该函数中用它来定义变量。

一般我们都是在所有函数前面声明结构体类型，就同我们希望在所有函数中都可以使用int来定义变量一样。但是正如前面所讲，不建议使用全局变量，所以同样我们也不建议使用结构体类型定义的全局变量。我们都是在所有函数前对结构体类型进行声明，然后在某个函数中再定义局部的结构体类型变量。

比如在所有函数前定义了一个结构体类型 struct STUDENT，那么就可以在所有函数中使用它来定义局部的结构体类型变量。如：
struct STUDENT stud1, stud2;
stud1 和 stud2 就是我们定义的结构体变量名。定义了结构体变量之后，系统就会为之分配内存单元。与前面讲的局部变量一样，如果 stud1 和 stud2 是在某个函数中定义的局部变量，那么就只能在该函数中使用。在其他函数中可以定义重名的结构体变量而不会相互产生影响。

二、在声明结构体类型的同时定义结构体变量
这就意味着，如果你在所有函数前声明结构体类型，那么定义的变量就是全局变量；而如果要定义局部变量，那么就只能在某个函数中对结构体类型进行声明，从而导致只能在这个函数中使用这个类型。

那么声明的时候是如何定义变量的呢？我们知道，声明的时候最后有个一分号，就在那个分号前写上你想定义的变量名就行了，如：

struct STUDENT
{
char name[20];
int num;
char sex;
int age;
float score;
char addr[30];
}stud;

这样就声明了一个结构体类型，并用这个类型定义了一个结构体变量 stud。这个变量是一个全局变量。

“结构体类型”的声明和使用与函数的定义和使用有所不同，函数的定义可以放在调用处的后面，只需在前面声明一下即可。但是“结构体类型”的声明必须放在“使用结构体类型定义结构体变量”的前面。

如果程序规模比较大，往往会将结构体类型的声明集中放到一个以 .h 为后缀的头文件中。哪个源文件需要用到此结构体类型，只要用 #include 命令将该头文件包含到该文件中即可，这样做便于修改和使用。

结构体变量可以进行的运算

结构体变量不能相加、不能相减，也不能相互乘除，但结构体变量可以相互赋值。也就是说，可以将一个结构体变量赋给另一个结构体变量。但前提是这两个结构体变量的结构体类型必须相同。

结构体变量的引用

定义了结构体变量之后就可以在程序中对它进行引用，但是结构体变量的引用同一般变量的引用不一样。因为结构体变量中有多个不同类型的成员，所以结构体变量不能整体引用，只能一个成员一个成员地进行引用。

1. 不能将一个结构体变量作为一个整体进行引用，只能分别单独引用它内部的成员，引用方式为：
   结构体变量名.成员名

如果成员名是一个变量名，那么引用的就是这个变量的内容；如果成员名是一个数组名，那么引用的就是这个数组的首地址。

“.”是“成员运算符”，它在所有运算符中优先级最高，因此可以将 student1.num 作为一个整体来看待。我们可以直接对变量的成员进行操作，例如：

student1.num = 1207041;

2. 如果结构体类型中的成员也是一个结构体类型，则要用若干个“.”，一级一级地找到最低一级的成员。因为只能对最低级的成员进行操作。

这种“结构体成员也是结构体变量”的形式就有一些 C++ 中“封装”的味道了。其实结构体本身就是一种封装，即将不同的数据类型封装在同一个类型中。当结构体成员也是结构体变量的时候，完全可以将结构体成员释放出来，比如：

struct AGE
{
    int year;
    int month;
    int day;
};
struct STUDENT
{
    char name[20];
    int num;
    struct AGE birthday;
    float score;
};

完全可以写成：

struct STUDENT
{
    char name[20];
    int num;
    int year;
    int month;
    int day;
    float score;
};

但这样看起来很长、很乱。而使用结构体将 year、month、day 封装起来，代码看起来就会好很多。因为 year、month、day 都是生日的组成部分，所以将它们进行进一步的封装可以使代码看起来很整齐，很有层次感，便于操作。

3. 可以引用“结构体变量成员”的地址，也可以引用“结构体变量”的地址。如“&student1.num”和“&student1”，前者表示 student1.num 这个成员在内存中的首地址，后者表示结构体变量 student1 在内存中的首地址。

在 C 语言中，结构体变量的首地址就是结构体第一个成员的首地址。所以 &student1 就等价于第一个成员 name 的首地址，而 name 是一个数组，数组名表示的就是数组的首地址。所以 &student1 和 student1.name 是等价的。但是要注意的是，它们的等价指的仅仅是“它们表示的是同一个内存空间的地址”，但它们的类型是不同的。&student1 是结构体变量的地址 ，是 struct STUDENT* 型的；而 student1.name 是数组名，所以是 char* 型的。类型的不同导致它们在程序中不能相互替换。

4. 结构体变量的引用方式决定了：
   “结构体变量名”可以与“结构体成员名”同名。
   “结构体变量名”可以与“结构体名”同名。
   “两个结构体类型定义的结构体变量中的成员可以同名”。就比如定义了一个结构体类型用于存放学生的信息，里面有成员“char name[20]；”，那么如果又定义了一个结构体类型用于存放老师的信息，那么里面也可以有成员“char name[20]；”。

因为结构体成员在引用时，必须要使用“结构体变量名.成员名”的方式来引用，通过引用就可以区分它们，所以不会产生冲突，因此可以同名！只要不冲突，都可以重名！但是两个结构体变量名就不可以重名了，因为无法区分它们，就会产生冲突。当然这里说的是在同一个作用域内，如果在一个函数中定义一个局部变量a，那么在另一个函数中当然也可以定义一个局部变量a。它们互不影响。

下面写一个程序：

# include 
struct AGE
{
    int year;
    int month;
    int day;
};
struct STUDENT
{
    char name[20];
    int num;
    struct AGE birthday;  //就有点类似于C++中的封装了
    float score;
};
int main(void)
{
    struct STUDENT student1 = {"小明", 1207041, {1989, 3, 29}, 100};
    printf("name : %s\n", student1.name);
    printf("birthday : %d-%d-%d\n", student1.birthday.year, student1.birthday.month, student1.birthday.day);
    printf("num : %d\n", student1.num);
    printf("score : %.1f\n", student1.score);
    return 0;
}

输出结果是：
name : 小明
birthday : 1989-3-29
num : 1207041
score : 100.0

程序中，虽然我们前面说“&student1 和 student1.name是等价的”，但第 18 行不能像下面这样写。

printf("name : %s\n", &student1);

原因是 %s 要求输出参数要么是字符数组名，要么是字符指针变量名，总之是 char* 型的。而 &student1 和 student1.name 在前面讲过，虽然它们是等价的，但它们的等价指的仅仅是“它们表示的是同一个内存空间的地址”，但它们的类型是不同的。&student1 是 struct STUDENT* 型的，而 student1.name 是 char* 型的，所以只能写 student1.name。

但是有的编译器写 &student1 就可以通过，而有的编译器则只会产生警告。这种“可错可不错”的写法大家不要使用，按规范书写可移植性才强。

结构体变量的初始化

结构体变量的初始化方式有两种，可以在定义的时候初始化或定义之后对结构体变量进行初始化。

一般情况下我们都是在定义的时候对它进行初始化，因为那样比较方便。如果定义之后再进行初始化，那就只能一个一个成员进行赋值，就同数组一样。

下面先介绍如何在定义的时候进行初始化。在定义结构体变量时对其进行初始化，只要用大括号“{}”括起来，然后按结构体类型声明时各项的顺序进行初始化即可。各项之间用逗号分隔。如果结构体类型中的成员也是一个结构体类型，则要使用若干个“{}”一级一级地找到成员，然后对其进行初始化。

# include 
struct AGE
{
    int year;
    int month;
    int day;
};
struct STUDENT
{
    char name[20];
    int num;
    struct AGE birthday;
    float score;
};
int main(void)
{
    struct STUDENT student1 = {"小明", 1207041, {1989, 3, 29}, 100};
    return 0;
}

注意，同字符、字符数组的初始化一样，如果是字符那么就用单引号括起来，如果是字符串就用双引号括起来。

第二种方式是定义后再初始化，我们将上面的程序改一下即可：

# include 
# include 
struct AGE
{
    int year;
    int month;
    int day;
};
struct STUDENT
{
    char name[20];  //姓名
    int num;  //学号
    struct AGE birthday;  /*用struct AGE结构体类型定义结构体变量birthday, 即生日*/
    float score;  //分数
};
int main(void)
{
    struct STUDENT student1;  /*用struct STUDENT结构体类型定义结构体变量student1*/
    strcpy(student1.name, "小明");  //不能写成&student1
    student1.num = 1207041;
    student1.birthday.year = 1989;
    student1.birthday.month = 3;
    student1.birthday.day = 29;
    student1.score = 100;
    printf("name : %s\n", student1.name);  //不能写成&student1
    printf("num : %d\n", student1.num);
    printf("birthday : %d-%d-%d\n", student1.birthday.year, student1.birthday.month, student1.birthday.day);
    printf("score : %.1f\n", student1.score);
    return 0;
}

输出结果是：
name : 小明
num : 1207041
birthday : 1989-3-29
score : 100.0

假如有一个数组，数组名是 a。我们知道 a 表示的就是这个数组的首地址，但是有些编译器会对数组名 a 取地址，即 &a 也等同于数组的首地址。虽然这么写从语法的角度是没有意义的，但程序却是正确的。
虽然在编译器中，&student1.name 代表的也是 name 的首地址，但是不建议这么写，原因如下：

• 这么写没有语法意义。
• 它只是编译器自己规定的，并不是所有的编译器都会这样定义，所以这么写不具备通用性。
• 这么写可读性很差，让人感到困惑且郁闷。

本文参考链接：http://c.biancheng.net/view/241.html