Linux C 深入分析结构体指针的定义与引用

     关于结构体的基础知识，网上书上都一大堆，这里就不赘述了，下面我们要学习的是结构体指针。

介绍结构体指针之前，先给大家看一个小程序：

[cpp] view plain copy

print?

1. #include <stdio.h>  
2. #include <string.h>  
3. #include <malloc.h>  
4.   
5. struct Man  
6. {  
7.     char name[10];  
8. };  
9.   
10. int main()  
11. {  
12.     struct Man N;  
13.     N.name = "qiang";  
14.     printf("%s\n",N.name);  
15. }  

#include <stdio.h>#include <string.h>#include <malloc.h>struct Man{char name[10];};int main(){struct Man N;N.name = "qiang";printf("%s\n",N.name);}

这段程序很简单，就是给结构体成员赋值，这里结构体成员是个数组，大家看看这种赋值方式有没有错，我们编译一下：

[cpp] view plain copy

print?

1. fs@ubuntu:~/qiang/struct$ gcc -o struct4 struct4.c  
2. struct4.c: In function ‘main’:  
3. struct4.c:13:9: error: incompatible types when assigning to type ‘char[10]’ from type ‘char *’  
4. fs@ubuntu:~/qiang/struct$   

fs@ubuntu:~/qiang/struct$ gcc -o struct4 struct4.cstruct4.c: In function ‘main’:struct4.c:13:9: error: incompatible types when assigning to type ‘char[10]’ from type ‘char *’fs@ubuntu:~/qiang/struct$ 

13行报错，就是赋值那行，报错原因是“字符分配的类型是不兼容的类型”
我们看看这句N.name = "qiang",右边是字符串常量，这里其实是字符串的首地址，就是一个地址，我们以前 char a[] = "qiang"没错啊，为什么这里报错了，我们看看左值，N.name， name 是数组名，是代表数组的首地址啊，但是我们要记住，这里name是个地址常量，是不能给常量赋值的，所以会报错，那我们如何给一个结构体中的字符数组赋值呢？我们这里用strcpy(N.name,"qiang") ! 当然我们N.name[1] = 'q'，这样是可以的。

下面开始讲结构体指针：

一、指向结构体类型变量的使用

首先让我们定义结构体：

[cpp] view plain copy

print?

1. <span style="color:#000000;">struct stu  
2. {  
3.     char name[20];  
4.     long number;  
5.     float score[4];  
6. };  
7. </span>  

<span style="color:#000000;">struct stu{char name[20];long number;float score[4];};</span>

再定义指向结构体类型变量的指针变量：
struct stu *p1, *p2 ;
定义指针变量p1、p2，分别指向结构体类型变量。引用形式为：指针变量→成员；这里我们要注意，非结构体指针引用类型是  结构体类型变量 . 成员；

下面我们看一个例子：

对指向结构体类型变量的正确使用。

 输入一个结构体类型变量的成员，并输出：

[cpp] view plain copy

print?

1. #include <stdlib.h>   
2. #include <stdio.h>  
3.   
4. struct data   
5. {  
6.     int day,month,year;  
7. };  
8.   
9. struct stu   
10. {  
11.     char name[20];  
12.     long num;  
13.     struct data birthday; /*嵌套的结构体类型成员*/  
14. };  
15.   
16. int main()   
17. {  
18.     struct stu *student; /*定义结构体类型指针*/  
19.     student = malloc(sizeof(struct stu)); /*为指针变量分配安全的地址*/  
20.     printf("Input name,number,year,month,day:\n");  
21.     scanf("%s",student->name); /*输入学生姓名、学号、出生年月日*/  
22.     scanf("%ld",&student->num);  
23.     scanf("%d%d%d",&student->birthday.year,&student->birthday.month,  
24.             &student->birthday.day);  
25.       
26.     printf("\nOutputname,number,year,month,day\n");  
27. /*打印输出各成员项的值*/  
28.     printf("%8s    %5ld  %d//%d//%d\n",student->name,student->num,  
29.         student->birthday.year,student->birthday.month,  
30.         student->birthday.day);  
31. }  

#include <stdlib.h> #include <stdio.h>struct data {int day,month,year;};struct stu {char name[20];long num;struct data birthday; /*嵌套的结构体类型成员*/};int main() {struct stu *student; /*定义结构体类型指针*/student = malloc(sizeof(struct stu)); /*为指针变量分配安全的地址*/printf("Input name,number,year,month,day:\n");scanf("%s",student->name); /*输入学生姓名、学号、出生年月日*/scanf("%ld",&student->num);scanf("%d%d%d",&student->birthday.year,&student->birthday.month,&student->birthday.day);printf("\nOutputname,number,year,month,day\n");/*打印输出各成员项的值*/printf("%8s    %5ld  %d//%d//%d\n",student->name,student->num,student->birthday.year,student->birthday.month,student->birthday.day);}

执行结果如下：

[cpp] view plain copy

print?

1. fs@ubuntu:~/qiang/struct/tmp$ ./struct1  
2. Input name,number,year,month,day:  
3. xiao  
4. 10086  
5. 2012  
6. 12  
7. 22  
8.   
9. Outputname,number,year,month,day  
10.     xiao    10086  2012//12//22  
11. fs@ubuntu:~/qiang/struct/tmp$   

fs@ubuntu:~/qiang/struct/tmp$ ./struct1Input name,number,year,month,day:xiao1008620121222Outputname,number,year,month,day    xiao    10086  2012//12//22fs@ubuntu:~/qiang/struct/tmp$ 

程序中使用结构体类型指针引用结构体变量的成员，需要通过C提供的函数malloc()来为指针分配安全的地址。函数sizeof()返回值是计算给定数据类型所占内存的字节数。指针所指各成员形式为：

[cpp] view plain copy

print?

1. student->name  
2. student->num  
3. student->birthday.year  
4. student->birthday.month  
5. student->birthday.day  

student->namestudent->numstudent->birthday.yearstudent->birthday.monthstudent->birthday.day

 

二、指向结构体类型数组的指针的使用
        定义一个结构体类型数组，其数组名是数组的首地址，这一点前面的课程介绍得很清楚。
        定义结构体类型的指针，既可以指向数组的元素，也可以指向数组，在使用时要加以区分。

上个例子中定义了结构体类型，根据此类型再定义结构体数组及指向结构体类型的指针

[cpp] view plain copy

print?

1. struct data  
2. {  
3. intday,month,year;  
4. };  
5. struct stu/*定义结构体*/  
6. {  
7. char name[20];  
8. long num;  
9. struct data birthday;/*嵌套的结构体类型成员*/  
10. };  

struct data{intday,month,year;};struct stu/*定义结构体*/{char name[20];long num;struct data birthday;/*嵌套的结构体类型成员*/};

[cpp] view plain copy

print?

1. struct stustudent[4],*p;   /*定义结构体数组及指向结构体类型的指针*/  

struct stustudent[4],*p;   /*定义结构体数组及指向结构体类型的指针*/

使p=student，此时指针p就指向了结构体数组student。
p是指向一维结构体数组的指针，对数组元素的引用可采用三种方法。
1)地址法
  student+i和p+i均表示数组第i个元素的地址，数组元素各成员的引用形式为：
（student+i）->name、(student+i)->num和(p+i)->name、（p+i）->num等。student+i和p+i与&student[i]意义相同。
2)指针法
若p指向数组的某一个元素，则p++就指向其后续元素。
3)指针的数组表示法
若p=student，我们说指针p指向数组student，p[i]表示数组的第i个元素，其效果与student[i]等同。对数组成员的引用描述为:p[i].name、p[i].num等
指向结构体数组的指针变量的使用：

[cpp] view plain copy

print?

1. #include <stdio.h>  
2. #include <malloc.h>  
3.   
4. struct data/*定义结构体类型*/  
5. {  
6.     int year,month,day;  
7. };  
8.   
9. struct stu/*定义结构体类型*/  
10. {  
11.     char name[20];  
12.     long num;  
13.     struct data birthday;  
14. };  
15.   
16. int main()  
17. {  
18.     int i;  
19.     struct stu *p,student[4]={{"liying",1,1978,5,23},{"wangping",2,1979,3,14},  
20.         {"libo",3,1980,5,6},{"xuyan",4,1980,4,21}};  
21.     /*定义结构体数组并初始化*/  
22.     p = student;/*将数组的首地址赋值给指针p,p指向了一维数组student*/  
23.     printf("Outputname,number,year,month,day\n");  
24.     for(i = 0;i < 4;i++)/*采用指针法输出数组元素的各成员*/  
25.         printf("%8s %6ld   %d//%d//%d\n",(p+i)->name,(p+i)->num,  
26.                 (p+i)->birthday.year,(p+i)->birthday.month,  
27.                 (p+i)->birthday.day);  
28.   
29.     return 0;  
30. }  

#include <stdio.h>#include <malloc.h>struct data/*定义结构体类型*/{int year,month,day;};struct stu/*定义结构体类型*/{char name[20];long num;struct data birthday;};int main(){int i;struct stu *p,student[4]={{"liying",1,1978,5,23},{"wangping",2,1979,3,14},{"libo",3,1980,5,6},{"xuyan",4,1980,4,21}};/*定义结构体数组并初始化*/p = student;/*将数组的首地址赋值给指针p,p指向了一维数组student*/printf("Outputname,number,year,month,day\n");for(i = 0;i < 4;i++)/*采用指针法输出数组元素的各成员*/printf("%8s %6ld   %d//%d//%d\n",(p+i)->name,(p+i)->num,(p+i)->birthday.year,(p+i)->birthday.month,(p+i)->birthday.day);return 0;}

执行结果如下：

[cpp] view plain copy

print?

1. fs@ubuntu:~/qiang/struct/tmp$ ./struct2  
2. Outputname,number,year,month,day  
3.   liying      1   1978//5//23  
4. wangping      2   1979//3//14  
5.     libo      3   1980//5//6  
6.    xuyan      4   1980//4//21  
7. fs@ubuntu:~/qiang/struct/tmp$   

fs@ubuntu:~/qiang/struct/tmp$ ./struct2Outputname,number,year,month,day  liying      1   1978//5//23wangping      2   1979//3//14    libo      3   1980//5//6   xuyan      4   1980//4//21fs@ubuntu:~/qiang/struct/tmp$ 

 

附：给大家看一个有意思的程序：

写出一个模拟时钟程序

分析：我们知道时间有时 分 秒 组成，这里用结构体表示

代码如下：

[cpp] view plain copy

print?

1. #include <stdio.h>  
2. #include <unistd.h>  
3. #include <malloc.h>  
4. #include <string.h>  
5.   
6. typedef struct Clock  
7. {  
8.     int hour;  
9.     int minute;  
10.     int second;  
11. }Clock;  
12.   
13. update(Clock *p)  
14. {  
15.     p->second++;  
16.   
17.     if(p->second == 60)  
18.     {  
19.         p->second = 0;  
20.         p->minute++;  
21.     }  
22.   
23.     if(p->minute == 60)  
24.     {  
25.         p->minute = 0;  
26.         p->hour++;  
27.     }  
28.     if(p->hour == 24)  
29.         p->hour = 0;  
30. }  
31.   
32. Display(Clock *p)  
33. {  
34.     printf("\r%02d:%02d:%02d",p->hour,p->minute,p->second);//%02d中0 输出数值时指定左面不使用的空位置自动填0，达到00:00:00效果  
35.     fflush(stdout);//前面曾经讲过，printf属于行缓冲，遇到\n或程序结束才会输出，这里没有\n，所以用fflush刷新；  
36. }  
37.   
38. int main()  
39. {  
40.     Clock *clock;  
41.     clock = (Clock *)malloc(sizeof(Clock));  
42.     memset(clock,'\0',sizeof(Clock));//时钟初始化  
43.   
44.     while(1)  
45.     {  
46.         sleep(1);  
47.         update(clock);  
48.         Display(clock);  
49.     }  
50.     free(clock);  
51.     return 0;  
52. }  

#include <stdio.h>#include <unistd.h>#include <malloc.h>#include <string.h>typedef struct Clock{int hour;int minute;int second;}Clock;update(Clock *p){p->second++;if(p->second == 60){p->second = 0;p->minute++;}if(p->minute == 60){p->minute = 0;p->hour++;}if(p->hour == 24)p->hour = 0;}Display(Clock *p){printf("\r%02d:%02d:%02d",p->hour,p->minute,p->second);//%02d中0 输出数值时指定左面不使用的空位置自动填0，达到00:00:00效果fflush(stdout);//前面曾经讲过，printf属于行缓冲，遇到\n或程序结束才会输出，这里没有\n，所以用fflush刷新；}int main(){Clock *clock;clock = (Clock *)malloc(sizeof(Clock));memset(clock,'\0',sizeof(Clock));//时钟初始化while(1){sleep(1);update(clock);Display(clock);}free(clock);return 0;}

执行结果如下：

[cpp] view plain copy

print?

1. fs@ubuntu:~/qiang/struct$ ./clock  
2. 00:00:01  

fs@ubuntu:~/qiang/struct$ ./clock00:00:01

[cpp] view plain copy

print?

1. fs@ubuntu:~/qiang/struct$ ./clock  
2. 00:00:55  

fs@ubuntu:~/qiang/struct$ ./clock00:00:55

这里是个动态效果，大家可以打印出来看一下

转载自：http://blog.csdn.net/zqixiao_09/article/details/50379241