大家好，我是鸟哥

此方法试用的前提：结构体成员的数据类型相同 。话不多说，直接上手。

“结构体成员遍历”进阶版：当结构体里的成员数据类型不一样，可以计算出每个结构体成员的偏移量，并将偏移量放到一个数组中，遍历数组获取偏移量后再根据偏移去获取成员变量。这样取出了不同类型的结构体，直接进行赋值取值即可。进阶版的详细实现方法会在后期的另一篇文章中说明。

问题：
假设现在有一个结构体，成员都是int类型，现在需要对结构体的成员进行赋值或者取值。
将数值1-10分别赋给结构体成员Member_0到Member_9。

typedef struct
{
	int Member_0;
	int Member_1;
	int Member_2;
	int Member_3;
	int Member_4;
	int Member_5;
	int Member_6;
	int Member_7;
	int Member_8;
	int Member_9;
}Member_t;

问题解决思路：
给结构体的成员赋值，最基本的方法就是结构体直接赋值，具体的几种实现方法如下。

• 结构体初始化赋值

    Member_t Member = { 1,2,3,4,5,6,7,8,9,10 };	//结构体初始化赋值

• 单一成员赋值

	Member.Member_0 = 1;	//结构体成员分别赋值
	Member.Member_1 = 2;
	Member.Member_2 = 3;
	Member.Member_3 = 4;
	Member.Member_4 = 5;
	Member.Member_5 = 6;
	Member.Member_6 = 7;
	Member.Member_7 = 8;
	Member.Member_8 = 9;
	Member.Member_9 = 10;

上述两种方法适用于成员较少的结构体，当成员数量很多，并且需要统一赋值操作的时候，这两种方法就显得十分繁琐，低效。

为了让编写程序更加高效，让代码篇幅更少，可扩展性强，笔者总结了几种利用指针对结构体成员统一赋值的方法。具体实现如下：

	Member_t Member;		//结构体命名
	Member_t* P_Member = &Member;		//指向结构体的指针
	int* P = (int*)P_Member;		//结构体指针强制转换为int类型
	int i;
	for (i = 0; i < sizeof(Member) / sizeof(int); i++)
	{
		(*P++) = i + 1;
	}

我们可以定义一个int类型的指针，指针类型与结构体的成员类型保持一致，再通过强制类型转换，将结构体指针类型强制转换为int类型的指针，把指针P指向结构体指针。

注：不能直接把int类型的指针指向结构体或者结构体指针。这样的话，程序就会报错。因为结构体名字是经过typedef后的类型，而P指针是int类型，两者类型不一样，无法通过编译器的类型检查，程序会直接报错，所以不能直接将P指向结构体或者结构体指针。

	int* P = &Member;		//这是错误的指针访问

上述强制转化结构体指针类型的方法可以实现结构体成员的统一赋值，但是这种方法很危险，因为它避开了编译器的类型检查。

利用指针遍历结构体成员最正确安全的方法就是使用&操作符取得一个指向结构体内部int类型成员的指针P_Member->Member_0。具体实现如下：

	Member_t Member;		//结构体命名
	Member_t* P_Member = &Member;		//指向结构体的指针
	int i, * P;
	P = &P_Member->Member_0;		//int类型的指针P指向结构体的第一个成员
	for (i = 0; i < sizeof(Member) / sizeof(int); i++)
	{
		(*P++) = i + 1;
	}

结构体成员遍历输出结果：

我的微信公众号（ID：00后开发者）从00后的角度出发，专注但不局限于分享电气、嵌入式、机器视觉以及芯片行业的算法、技术文章和最新资讯。如果想查看更多内容，可以关注我的微信公众号。

1. 结构体成员变量介绍

在C语言中经常出现结构体作为结构体的成员变量的情况，如链表

1.1 结构体成员变量的形式

结构体作为成员变量有时可能是在其他文件中进行了声明，这里简单的以在同一个文件中表示进行介绍。

  3 struct score
  4 {
  5     float math;
  6     float chinese;
  7     float englise;
  8     float physical;
  9 };
 10 
 11 typedef struct score SCORE;
 12 
 13 struct node
 14 {
 15     SCORE data;
 16     int id;
 17     char* name;
 18 };
 19 
 20 typedef struct node lnode;

如上面的代码所示，在结构体node中score结构体作为成员变量，这种形式有比较清晰的层次关系。

1.2 结构体中含结构体变量的优缺点

优点：从上面的1.1节代码中可以看到，将所有分数相关的成员放入一个结构体中，然后将这个结构体又作为一个成员变量放入另一个结构体中。这中方式可以使得结构层次清晰明朗，同一类的信息放入一个结构体，在使用时比较清晰。
缺点：需要使用某个结构体中的成员变量时需要多级包含

2. 结构体成员变量赋值

2.1直接赋值

直接赋值也有两种方式，一种是直接在定义时就赋值，把结构体当做一个整体进行赋值

lnode ln2 = {{1002,"wujing",78,98},88,NULL};

另一种是先定义里面的结构体，然后将其当做一个成员进行赋值

ST s1 = {1001,"wangj",98,82};
lnode ln1;
ln1.data = s1;
ln1.english = 92;
ln1.next = NULL;

2.2通过指针赋值

通过结构体指针间接的对结构体中每个成员进行赋值，结构体变量做为一个成员变量可以整体赋值，也可以对结构体内部的变量单独赋值。

lnode ln3;
lnode* p = NULL;
p = &ln3;
p->english = 66;
p->data.id = 1003;
p->data.name = "Lihai";
p->data.math = 76;
p->data.chinese = 86;
p->next = NULL;

3. 示例代码

  1 #include <stdio.h>
  2 
  3 struct student
  4 {   
  5     int id;
  6     char* name;
  7     int math;
  8     int chinese;
  9 };
 10 
 11 typedef struct student ST;
 12 
 13 struct node
 14 {   
 15     ST data;
 16     int english; 
 17     struct node* next;
 18 };
 19 
 20 typedef struct node lnode;
 21 
 22 int main()
 23 {
 24     lnode ln2 = {{1002,"wujing",78,98},88,NULL};
 25     printf("ln2.data.id = %d, ln2.data.name = %s, ln2.data.math = %d, ln2.da    ta.chinese = %d, ln2.english = %d, ln2.next = %#lx\n", ln2.data.id, ln2.data    .name, ln2.data.math, ln2.data.chinese, ln2.english, ln2.next);
 26 
 27     ST s1 = {1001,"wangj",98,82};
 28     lnode ln1;
 29     ln1.data = s1;
 30     ln1.english = 92;
 31     ln1.next = NULL;
 32     printf("ln1.data.id = %d, ln1.data.name = %s, ln1.data.math = %d,ln1.dat    a.chinese = %d, ln1.english = %d, ln1.next = %#lx\n", ln1.data.id, ln1.data.    name, ln1.data.math, ln1.data.chinese, ln1.english, ln1.next);
 33 
 34     lnode ln3;
 35     lnode* p = NULL;
 36     p = &ln3;
 37     p->english = 66;
 38     p->data.id = 1003;
 39     p->data.name = "Lihai";
 40     p->data.math = 76;
 41     p->data.chinese = 86;
 42     p->next = NULL;
 43     printf("ln3.data.id = %d, ln3.data.name = %s, ln3.data.math = %d,ln3.dat    a.chinese = %d, ln3.english = %d, ln3.next = %#lx\n", ln3.data.id, ln3.data.    name, ln3.data.math, ln3.data.chinese, ln3.english, ln3.next);
 44 }

在工作过程中会遇到结构体，可能会忘记如何遍历结构体数组，这是一个简单的例子：

void structArrayPtr()
{
    // 定义一个结构体数组
    struct Student studentArray[2] = {
        {"William", 18},
        {"Mark", 20}
    };

    // 如何遍历结构体数组
    for( int i=0; i<2; i++ )
    {
        cout << "name: " << studentArray[i].name << ", age: " << studentArray[i].age << endl;
    }

    cout << "***********************" << endl;

    // 定义一个结构体
    struct Student student;
    student.name = "monkey";
    student.age = 22;

    // 定义一个结构体指针
    struct Student *stu_ptr = &student;

    // 利用->符去访问结构体成员
    cout << "name: " << stu_ptr->name << ", age: " << stu_ptr->age << endl;

    cout << "***********************" << endl;

    // 定义新的结构体指针指向结构体数组
    Student *stu_ptr1 = studentArray;

    // 利用结构体指针遍历结构体数组元素,依旧利用->符号去获取
    for( int var=0; var<2; var++, stu_ptr1++ )
    {
        cout << "name: " << stu_ptr1->name << ", age: " << stu_ptr1->age << endl;
    }
}