在结构体中定义函数指针
结构体中定义函数指针
分类：C/C++ 2013-08-12 12:51 2581人阅读评论(1) 收藏举报转自：https://www.360docs.net/doc/e313161958.html,/unix21/article/details/9293877
结构体指针变量的定义，定义结构体变量的一般形式如下：
形式１：先定义结构体类型，再定义变量
struct结构体标识符
{
成员变量列表;…
};
struct结构体标识符*指针变量名;
变量初始化一：struct结构体标识符变量名={初始化值1，初始化值2，…, 初始化值n };
形式２：在定义类型的同时定义变量
struct结构体标识符
{
成员变量列表;…
} *指针变量名;
变量初始化二：
形式３：直接定义变量，用无名结构体直接定义变量只能一次
struct
{
成员变量列表;…
}*指针变量名;
其中“指针变量名”为结构体指针变量的名称。形式1是先定义结构体，然后再定义此类型的结构体指针变量；形式２和形式3是在定义结构体的同时定义此类型的结构体指针变量。
函数指针的定义
一般的函数指针可以这么定义:
int(*func)(int,int);
表示一个指向含有两个int参数并且返回值是int形式的任何一个函数指针. 假如存在这样的一个函数:
int add2(intx,int y)
{
return x+y;
}
那么在实际使用指针func时可以这样实现:
func=&add2; //指针赋值,或者func=add2; add2与&add2意义相同
printf("func(3,4)=%d\n",func(3,4));
事实上,为了代码的移植考虑,一般使用typedef定义函数指针类型.
typedefint(*FUN)(int,int);
FUN func=&add2;
func();
结构体中包含函数指针
其实在结构体中,也可以像一般变量一样,包含函数指针变量.下面是一种简单的实现. [cpp]view plaincopyprint?
1.#include
2.struct DEMO
3.{
4.int x,y;
5.int (*func)(int,int); //函数指针
6.};
7.
8.int add1(int x,int y)
9.{
10.return x*y;
11.}
12.
13.int add2(int x,int y)
14.{
15.return x+y;
16.}
17.
18.void main()
19.{
20.struct DEMO demo;
21.demo.func=add2; //结构体函数指针赋值
22.//demo.func=&add2; //结构体函数指针赋值
23.printf("func(3,4)=%d\n",demo.func(3,4));
24.demo.func=add1;
25.printf("func(3,4)=%d\n",demo.func(3,4));
26.}
27.
28./*
29.输出：
30.func(3,4)=7
31.func(3,4)=12
32.*/
结构体中指向函数的指针
C语言中的struct是最接近类的概念，但是在C语言的struct中只有成员，不能有函数，但是可以有指向函数的指针，这也就方便了我们使用函数了。举个例子，如下：
[cpp]view plaincopyprint?
1.#include
2.#include
3.#include
4.
5.typedef struct student
6.{
7.int id;
8.char name[50];
9. void (*initial)();
10. void (*process)(int id, char *name);
11. void (*destroy)();
12.}stu;
13.
14.void initial()
15.{
16. printf("initialization...\n");
17.}
18.
19.void process(int id, char *name)
20.{
21. printf("process...\n%d\t%s\n",id, name);
22.}
23.
24.void destroy()
25.{
26. printf("destroy...\n");
27.}
28.
29.int main()
30.{
31. stu *stu1;
32. //在VC和TC下都需要malloc也可以正常运行，但是linux gcc下就会出错，为段错
误，必须malloc
33. stu1=(stu *)malloc(sizeof(stu));
34. //使用的时候必须要先初始化
35. stu1->id=1000;
36. strcpy(stu1->name,"C++");
37. stu1->initial=initial;
38. stu1->process=process;
39. stu1->destroy=destroy;
40. printf("%d\t%s\n",stu1->id,stu1->name);
41. stu1->initial();
42. stu1->process(stu1->id, stu1->name);
43. stu1->destroy();
44. free(stu1);
45. return 0;
46.}
输出：
/*
1000 C++
initialization...
process...
1000 C++
destroy...
*/
c语言中，如何在结构体中实现函数的功能？把结构体做成和类相似，让他的内部有属性，也有方法
这样的结构体一般称为协议类，提供参考：
struct {
intfuncid;
char *funcname;
int (*funcint)(); /* 函数指针int类型*/
void (*funcvoid)(); /* 函数指针void类型*/
};
每次都需要初始化，比较麻烦
[cpp]view plaincopyprint?
1.#include
2.
3.typedef struct
4.{
5.int a;
6.void (*pshow)(int);
7.}TMP;
8.
9.void func(TMP *tmp)
10.{
11. if(tmp->a >10)//如果a>10,则执行回调函数。
12. {
13. (tmp->pshow)(tmp->a);
14. }
15.}
16.
17.void show(int a)
18.{
19. printf("a的值是%d\n",a);
20.}
21.
22.void main()
23.{
24. TMP test;
25. test.a = 11;
26. test.pshow = show;
27. func(&test);
28.}
29.
30./*
31.一般回调函数的用法为：
32.甲方进行结构体的定义（成员中包括回调函数的指针）
33.
34.乙方定义结构体变量，并向甲方注册，
35.甲方收集N个乙方的注册形成结构体链表，在某个特定时刻遍历链表，进行回调。
36.当函数指针做为函数的参数，传递给一个被调用函数，
37.被调用函数就可以通过这个指针调用外部的函数，这就形成了回调
一般的程序中回调函数
作用不是非常明显，可以不使用这种形式
最主要的用途就是当函数不处在同一个文件
当中，比如动态库，要调用其他程序中的函数就只有采用回调的形式
38.通过函数指针参数将外部函数地址传入来实现调用
函数的代码作了修改，也不必改动
库的代码，就可以正常实现调用便于程序的维护和升级
*/参考：
C结构体中的函数指针与函数
结构体定义区
/******************** * 结构体定义区 * ********************/ typedef struct PID { int16_t pConst; // 比例常数 Proportional Const int16_t iConst; // 积分常数 Integral Const int16_t dConst; // 微分常数 Derivative Const int16_t position; int16_t hisPosition; int16_t lastPosition[10]; }PID; /*********************************************************** * 函数名称：PID参数初始化 * 功能描述：初始化PID参数，并实现P、I、D三个参数的整定 * 参数列表： * 返回结果：无 ***********************************************************/ void PIDInit(PID *iPID) { memset(iPID, 0, sizeof(iPID)); //将所有值清零 iPID->pConst = 2; // 比例常数 Proportional Const iPID->iConst = 0; // 积分常数 Integral Const iPID->dConst = 8; // 微分常数 Derivative Const } /*********************************************************** * 函数名称：PID控制程序 * 功能描述： * 参数列表： * 返回结果：无 ***********************************************************/ void PIDCalc( PID *cPID) { int16_t pGain; //P增益
结构体指针
C++语言结构体和指针 指针也可以指向一个结构体，定义的形式一般为： struct结构体名*变量名; 下面是一个定义结构体指针的实例： 上述代码已经测试。 注意：定义已经命名的结构体指针的时候必须用已命名结构体类型定义的结构体变量的地址进行初始化。 也可以在定义结构体的同时定义结构体指针： 上述代码已经测试 注意，结构体变量名和数组名不同，数组名在表达式中会被转换为数组指针，而结构体变量名不会，无论在任何表达式中它表示的都是整个集合本身，要想取得结构体变量的地址，必 pstu赋值只能写作： struct stu *pstu = &stu1; 而不能写作： struct stu *pstu = stu1; 还应该注意，结构体和结构体变量是两个不同的概念：结构体是一种数据类型，是一种创建变量的模板，编译器不会为它分配内存空间，就像int、float、char 这些关键字本身不占用内存一样；结构体变量才包含实实在在的数据，才需要内存来存储。下面的写法是错误的，不可能去取一个结构体名的地址，也不能将它赋值给其他变量： struct stu *pstu = &stu; struct stu *pstu = stu;
获取结构体成员 通过结构体指针可以获取结构体成员，一般形式为： (*pointer).memberName 或者： pointer->memberName 对了。 ，有了它，可以通过结构体指针 直接取得结构体成员；这C语言中的唯一用途。 上面的两种写法是等效的，我们通常采用后面的写法，这样更加直观。
运行结果： Name Num Age Group Score Zhou ping 5 18 C 145.0 Zhang ping 4 19 A 130.5 Liu fang 1 18 A 148.5 Cheng ling 2 17 F 139.0 Wang ming 3 17 B 144.5 结构体指针作为函数参数 结构体变量名代表的是整个集合本身，作为函数参数时传递的整个集合，也就是所有成员，而不是像数组一样被编译器转换成一个指针。如果结构体成员较多，尤其是成员为数组时，传送的时间和空间开销会很大，影响程序的运行效率。所以最好的办法就是使用结构体指针，这时由实参传向形参的只是一个地址，非常快速。 要铭记的一点就是：数组名称始终代表数组的指针指向第一个元素，数组名称加一始终指向下一个数组元素。
C语言自定义数据类型
自定义数据类型 结构体 结构体是程序员在程序中自定义的一种数据类型，在说明和使用之前必须先定义它，也就是构造它。定义一个结构体的语法格式如下： Struct 结构体类型名 { 成员1的数据类型名成员1名称； 成员2的数据类型名成员2名称； . . 成员n的数据类型名成员n名称； }结构体变量表={成员初始化}； 注意成员可以由若干个不同的数据类型组成，每个成员也可以是结构体，即可以嵌套定义。 例如： Struct student { Long num; Char name; Char sex; Float score; }; 已经定义的某种结构体类型可以视为一种标准的数据类型，它的使用方法与标准数据类型使用方法相同，可以用来定义变量、数组、指针。 结构体变量说明 结构体变量的说明在程序的变量说明部分给出，一般在结构定义之后，它的语法格式如下： Struct 结构类型名结构变量名表； 例如： Struct student stu； 指出了结构变量stu是student类型的变量，它由四个成员组成，每个成员的数据类型和名字都与student结构定义中给出的相同。系统完全按照结构定义时制定的内存模式为结构变量分配内存空间。 可以在定义结构体类型的同时给出结构体变量。 Struct student { Long num; Cha name[20]; Cha sex; Float score; }stu1,stu2; 这种形式与前面给出的结构定义和结构说明分开处理效果相同。
结构体成员访问 结构体成员是通过结构体变量名和成员名进行访问的，不能把他作为一个整体进行访问。其访问格式如下： 结构体变量名.成员名 其中运算符.是成员访问运算符，其运算级别是最高的，和圆括号运算符()、下标运算符[]是同一级别的。如果结构体成员是指针变量，则访问格式为： *https://www.360docs.net/doc/e313161958.html, 如果某个结构体变量的成员数据类型又是一个结构体，则访问方式为： 外层结构体变量名.外层成员名.内层成员名 可以在定义结构体变量的同时对结构体变量初始化。 {结构体成员}结构体变量={初始数据}； struct student { long num; char name[20]; char sex; float score; } stu1={200401L,"ZhangHong",'f',92.5f}; 对于嵌套的结构体类型数据，访问格式为： 结构体变量名1.结构体变量名2.成员名 结构体变量初始化的格式如下： struct 结构体名 {结构体成员}结构体变量={初始数据}； 初始数据类型必须与结构成员的数据类型相匹配，并且先后顺序一一对应赋值。 要对结构体变量的成员地址进行访问，其语法格式为： &结构体变量.成员名 当一个指针变量用来指向一个结构变量时，称为结构体指针变量。结构体指针变量中的值是所指向的结构体变量的首地址。 结构体指针变量： Struct 结构名*结构体指针变量名 Struct student *pstu; 必须先赋值后使用，把结构体变量的首地址赋给指针变量，不能把结构名或结构体变量名赋给指针变量。 pstu=&stu1; 结构体名和结构体变量是两个不同的概念，结构体名只能表示一个结构形式，编译系统并不对它分配内存空间，只有当某变量被说明为这种类型的结构时，才对该变量分配存储空间。这是因为结构体变量被定义后相当于标准数据类型被使用。 利用结构体指针变量访问成员如下： （*结构体指针变量）.成员名 或者： 结构体指针变量->成员名 后一种形式较为方便，容易区分。
C语言中指针和数组名的用法,结构体与共用体的总结
C语言中指针和数组名的用法,结构体与共用体的总结 2010-01-11 19:38 在C语言中，指针和数组名通常都可以混用。 例如 char *p; 访问时，*p跟p[0]是一样的，*(p+1)跟p[1]是一样的。 对于数组 char b[5]; 访问时，b[0]跟*b是一样的，b[2]跟*(b+2)是一样的。 在一般的通信中（例如串口），通常都使用字节传输。而像float，long int 之类的， 有4字节。我的方法就是取它的地址，强制转换为char型指针，然后当作数组来用。 float x; SBUF=((char*)&x)[0]; SBUF=((char*)&x)[1]; SBUF=((char*)&x)[2]; SBUF=((char*)&x)[3]; 接收时，刚好倒过来。 更有趣的是，对于数组形式，数组名和后面的偏移量可以随便换。 char buff[10]; //或者用 char *buff=&buffer; buff[3]=0xaa; 3[buff]=0xaa; //两者是一样的 因此，我认为编译器是这么做的：对于形如xxx[yyy]这样的表达式，会转化为*(xxx+yyy)， 因此写成xxx[yyy]或者写成yyy[xxx]都无所谓了... c语言结构体与共用体学习笔记1 Author:yuexingtian Date:Thursday, June 12, 2008 1结构变量的赋值 测试结果：
{ struct stu { int num; char *name; char sex; float score; }boy1,boy2; boy1.num=15; https://www.360docs.net/doc/e313161958.html,="yuexingtian"; printf("input sex and score\n"); scanf("%c %f",&boy1.sex,&boy1.score); boy2=boy1; printf("Number=%d\nName=%s\n",boy2.num,https://www.360docs.net/doc/e313161958.html,); printf("Sex=%c\nScore=%f\n",boy2.sex,boy2.score); getch(); } 说明： 本程序中用赋值语句给num和name两个成员赋值，name是一个字符串指针变量。用scanf函数动态地输入sex和score成员值，然后把boy1的所有成员的值整体赋予boy2。最后分别输出boy2的各个成员值。本例表示了结构变量的赋值、输入和输出的方法。 2结构变量的初始化 对结构变量的初始化（还拿上例举例）
结构体的使用方法
下面介绍了结构体的创建和使用方法： 创建过程： 定义一个名字为addr_t的结构体，其内容为名位addr的数组，数组大小为NET_ADDR_SIZE。 typedef struct { addr_t *addr;//地址 u8 *msg;//信息 u8 len;//信息长度 u8 port;//端口 } ioctlRawSend_t;//发送信息结构体 定义一个名字为ioctlRawSend_t的结构体，其内容为一个结构体，一个无符号类型指针和两个无符号数。将内容中的结构体代入这个结构体类型中，其内容可以写成（这样写只是为了看得更清晰） typedef struct { u8 addr[NET_ADDR_SIZE];//地址 u8 *msg;//信息 u8 len;//信息长度 u8 port;//端口 } ioctlRawSend_t;//发送信息结构体 这是一个联合体（共用体），很好理解，就是把两个结构体成员（ioctlRawSend_t，ioctlRawReceive_t）放在了一起用同一个名字（ioctl_info）表示，成员占用相同的内存单元，其中内容同步变化。 从变量观察窗口我们可以看到变量是如何组织在一起的。
到现在就从最基础的数组组成了一个联合体，下面我们使用它。 下面的语句中显示了如何向刚才建立的联合体中写要求的数据。 下面进行逐句分析 第一行中写广播地址（具体数字可以认为变动，一般为{0xFF,0xFF,0xFF,0xFF}）到联合体中的 发送地址中。下面是变量窗口中发生的变化（红色表示变化）。
接下来的一句为向信息中填充内容，下面是变量观察窗口的变化。其中msg只显示0号元素，是因为它是一个指针，指向的是首地址，其实其他的内容也已经变化。
c语言结构体用法(转载)
C语言，结构体(struct) 用法 结构(struct) 结构是由基本数据类型构成的、并用一个标识符来命名的各种变量的组合。 结构中可以使用不同的数据类型。 1. 结构说明和结构变量定义 在T urbo C中, 结构也是一种数据类型, 可以使用结构变量, 因此, 象其它 类型的变量一样, 在使用结构变量时要先对其定义。 定义结构变量的一般格式为: struct 结构名 { 类型变量名; 类型变量名; ... } 结构变量; 结构名是结构的标识符不是变量名。 类型为第二节中所讲述的五种数据类型(整型、浮点型、字符型、指针型和 无值型)。 构成结构的每一个类型变量称为结构成员, 它象数组的元素一样, 但数组中 元素是以下标来访问的, 而结构是按变量名字来访问成员的。
下面举一个例子来说明怎样定义结构变量。 struct string { char name[8]; int age; char sex[2]; char depart[20]; float wage1, wage2, wage3, wage4, wage5; } person; 这个例子定义了一个结构名为string的结构变量person, 如果省略变量名 person, 则变成对结构的说明。用已说明的结构名也可定义结构变量。这样定义 时上例变成: struct string { char name[8]; int age; char sex[2]; char depart[20]; float wage1, wage2, wage3, wage4, wage5; }; struct string person; 如果需要定义多个具有相同形式的结构变量时用这种方法比较方便, 它先作 结构说明, 再用结构名来定义变量。 例如: struct string T ianyr, Liuqi, ...; 如果省略结构名, 则称之为无名结构, 这种情况常常出现在函数内部, 用这 种结构时前面的例子变成:
结构体的定义及初始化
?结构体类型定义 struct [结构体名] { 类型标识符成员名； 类型标识符成员名； ……………. }；成员类型可以是基本型或构造型 struct是关键字,不能省略合法标识符 可省:无名结构体 结构体的说明及结构体变量的定义
例struct student { int num; char name[20]; char sex; int age; float score; char addr[30]; }; name num sex age score addr 2字节 2字节 20字节 1字节 4字节 30字节 … ….. 结构体类型定义描述结构 的组织形式,不分配内存 例子图解
?结构体类型定义 struct [结构体名] { 类型标识符成员名； 类型标识符成员名； ……………. }；成员类型可以是基本型或构造型 struct是关键字,不能省略合法标识符 可省:无名结构体 结构体的说明及结构体变量的定义
(1) 在结构体说明的同时定义结构体变量,例如：struct example { char *name； int age; }guo,zhang；(2)直接定义结构体变量,例如： struct {char *name； int age; }guo,zhang 未给 出结 构体 名 (3) 把定义和说明分开,例如：struct example { char *name； int age; }； struct example guo,zhang；结构体变量占用内存的大小可用sizeof()运算来求出 ?结构体变量的定义
结构体的说明及结构体变量的定义?变量说明形式 struct 结构体名结构体变量名； ?注意： 结构变量的存储类型概念、它的寿命、可见 性及使用范围与普通变量、数组等完全一致。 结构体变量说明必须在结构类型定义之后， 二者也可同时进行。
C语言中不同的结构体类型的指针间的强制转换详解
C语言中不同类型的结构体的指针间可以强制转换，很自由，也很危险。只要理解了其内部机制，你会发现C是非常灵活的。 一. 结构体声明如何内存的分布， 结构体指针声明结构体的首地址， 结构体成员声明该成员在结构体中的偏移地址。 变量的值是以二进制形式存储在内存中的，每个内存字节对应一个内存地址，而内存存储的值本身是没有整型，指针，字符等的区别的，区别的存在是因为我们对它们有不同的解读，param的值就是一个32位值，并且存储在某个内存单元中，通过这个32位值就能找到param所指向的结构的起始地址，通过这个起始地址和各个结构所包含变量离起始地址的偏移对这些变量进行引用， param->bIsDisable只是这种引用更易读的写法，只要param是指向 PAINT_PARAM的指针，那么param的值就肯定存在，param存在，偏移量已知，那么param->bIsDisable就肯定存在，只是要记住，param->bIsDisable只是代表了对param一定偏移地址的值。 不是说某个地址有那个结构体你才能引用，即使没有，你也能引用，因为你已经告诉了编译器param变量就是指向一个PAINT_PARAM结构体的变量并且指明了param的值，机器码的眼中是没有数据结构一说的，它只是机械的按照 指令的要求从内存地址取值，那刚才的例子来说，peg->x,peg->y的引用无论 0x30000000是否存在一个eg结构体都是合法的，如果0x30000000开始的8 个字节存在eg结构体，那么引用的就是这个结构体的值，如果这个位置是未定义的值，那么引用的结果就是这8个字节中的未定义值，内存位置总是存在的，而对内存中值的引用就是从这些内存位置对应的内存单元取值。 举个例子: typedefstruct_eg { int x； int y； }eg;
结构体的指针应用
什么是结构体？ 简单的来说，结构体就是一个可以包含不同数据类型的一个结构，它是一种可以自己定义的数据类型，它的特点和数组主要有两点不同，首先结构体可以在一个结构中声明不同的数据类型，第二相同结构的结构体变量是可以相互赋值的，而数组是做不到的，因为数组是单一数据类型的数据集合，它本身不是数据类型(而结构体是)，数组名称是常量指针，所以不可以作为左值进行运算，所以数组之间就不能通过数组名称相互复制了，即使数据类型和数组大小完全相同。 定义结构体使用struct修饰符，例如： struct test { float a; int b; }; 上面的代码就定义了一个名为test的结构体，它的数据类型就是test，它包含两个成员a和b，成员a的数据类型为浮点型，成员b的数据类型为整型。由于结构体本身就是自定义的数据类型，定义结构体变量的方法和定义普通变量的方法一样。 test pn1; 这样就定义了一个test结构体数据类型的结构体变量pn1，结构体成员的访问通过点操作符进行，pn1.a=10 就对结构体变量pn1的成员a进行了赋值操作。注意:结构体生命的时候本身不占用任何内存空间，只有当你用你定义的结构体类型定义结构体变量的时候计算机才会分配内存。 结构体，同样是可以定义指针的，那么结构体指针就叫做结构指针。 结构指针通过->符号来访问成员，下面我们就以上所说的看一个完整的例子： #include
C语言结构体习题及答案
第9章结构体 1．定义以下结构体类型 struct s { int a; char b; float f; }; 则语句printf("%d",sizeof(struct s))的输出结果为【】。 A) 3 B) 7 C) 6 D) 4 2．当定义一个结构体变量时，系统为它分配的内存空间是【】 A）结构中一个成员所需的内存容量 B）结构中第一个成员所需的内存容量 C）结构体中占内存容量最大者所需的容量 D）结构中各成员所需内存容量之和 3．定义以下结构体类型 struct s { int x; float f; }a[3]; 语句printf("%d",sizeof(a))的输出结果为【】 A) 4 B) 12 C) 18 D) 6 4．定义以下结构体数组 struct c { int x; int y; }s[2]={1,3,2,7}; 语句printf("%d",s[0].x*s[1].x)的输出结果为【】 A) 14 B) 6 C) 2 D) 21 5．运行下列程序段，输出结果是【】 struct country { int num; char name[10]; }x[5]={1,"China",2,"USA",3,"France",4, "England",5, "Spanish"}; struct country *p; p=x+2; printf("%d,%c",p->num,(*p).name[2]); A) 3,a B) 4,g C) 2,U D) 5,S
6．下面程序的运行结果是【】。 struct KeyWord { char Key[20]; int ID; }kw[]={"void",1,"char",2,"int",3,"float",4,"double",5}; main() { printf("%c,%d\n",kw[3].Key[0], kw[3].ID); } A) i,3 B) n,3 C) f,4 D) l,4 7．定义以下结构体类型 struct student { char name[10]; int score[50]; float average; }stud1; 则stud1占用内存的字节数是【】。 A) 64 B) 114 C) 228 D) 7 8．如果有下面的定义和赋值，则使用【】不可以输出n中data的值。struct SNode { unsigned id; int data; }n,*p; p=&n; A) p.data B) n.data C) p->data D) (*p).data 9.根据下面的定义，能输出Mary的语句是【】。 struct person { char name[9]; int age; }; struct person class[5]={"John",17,"Paul",19,"Mary",18,"Adam",16}; A) printf("%s\n",class[1].name); B) printf("%s\n",class[2].name); C) printf("%s\n",class[3].name);
指针和结构体练习题.
第十章指针 一．选择题 1.变量的指针，其含义是指该变量的。 A）值 B）地址 C）名 D）一个标志 2.已有定义int k=2;int *ptr1,*ptr2;且ptr1和ptr2均已指向变量k，下面不能正确执行的赋值语句是。 A）k=*ptr1+*ptr2 B）ptr2=k C）ptr1=ptr2 D）k=*ptr1*(*ptr2 3.若有说明：int *p,m=5,n;以下程序段正确的是。 A）p=&n ; B）p = &n ; scanf(“%d”,&p; scanf(“%d”,*p; C）scanf(“%d”,&n; D）p = &n ; *p=n ; *p = m ; 4.已有变量定义和函数调用语句：int a=25;print_value(&a;下面函数的输出结果是。 void print_value(int *x { printf(“%d\n”,++*x; } A）23 B）24 C）25 D）26 5.若有说明：int *p1, *p2,m=5,n;以下均是正确赋值语句的选项是。 A）p1=&m; p2=&p1 ; B）p1=&m; p2=&n; *p1=*p2 ; C）p1=&m; p2=p1 ; D）p1=&m; *p1=*p2 ; 6.若有语句：int *p,a=4;和p=&a；下面均代表地址的一组选项是。 A）a,p,*&a B）&*a,&a,*p C）*&p,*p,&a D）&a,&*p,p 7.下面判断正确的是。 A）char *a=”china”; 等价于char *a; *a=”china” ; B）char str[10]={“china”}; 等价于char str[10]; str[ ]={“china”;}
C语言入门教程-指向结构体的指针
C语言入门教程-指向结构体的指针 2009年07月29日12:04 [导读] 指向结构体的指针 在C语言中几乎可以创建指向任何类型的指针，包括用户自定义的类型。创建结构体指针是极常见的。下面是一个例子： typedef struct{
关键词：c语言入门 指向结构体的指针 在C语言中几乎可以创建指向任何类型的指针，包括用户自定义的类型。创建结构体指针是极常见的。下面是一个例子： typedef struct
{char name[21];char city[21];char state[3];} Rec; typedef Rec *RecPointer; RecPointer r; r=(RecPointer)malloc(sizeof(Rec)); r是一个指向结构体的指针。请注意，因为r是一个指针，所以像其他指针一样占用4个字节的内存。而malloc语句会从堆上分配45字节的内存。*r是一个结构体，像任何其他Rec类型的结构体一样。下面的代码显示了这个指针变量的典型用法：
strcpy((*r).city, "Raleigh"); strcpy((*r).state, "NC"); printf("%sn", (*r).city); free(r); 您可以像对待一个普通结构体变量那样对待*r，但在遇到C的操作符优先级问题时要小心。如果去掉*r两边的括号则代码将无法编译，因为“.”操作符的优先级高于“*”操作符。使用结构体指针时不断地输入括号是令人厌烦的，为此C语言引入了一种简记法达到相同的目的：
r->这种写法和(*r).是完全等效的，但是省去了两个字符。 指向数组的指针 还可以创建指向数组的指针，如下所示：
(1)定义结构体的关键字是
(1) 定义结构体的关键字是，定义共用体的关键字是。 (2) 结构体和共用体的相同点是，不同点是。 (3) 若有以下定义和语句，则sizeof(a)的值是__ ___，而sizeof(b)的值是__ _。struct tu { int m; char n; int y;}a; struct { float p, char q; struct tu r} b; (4) 设有下面结构类型说明和变量定义，则变量a在内存所占字节数是。如果将该结构改成共用体，结果为。 struct stud { char num[6]; int s[4]; double ave; } a; (5) 下面程序用来输出结构体变量ex所占存储单元的字节数，请填空。 struct st { char name[20]; double score; }; main() { struct st ex ; printf("ex size: %d\n",sizeof( )); } (6) 下面定义的结构体类型拟包含两个成员,其中成员变量info用来存入整形数据;成员变量link是指向自身结构体的指针,请将定义补充完整。 struct node { int info; link; } (7) 以下程序执行后输出结果是。 main() { union { unsigned int n; unsigned char c; } u1; u1.c='A'; printf("%c\n",u1.n); } (8) 变量root如图所示的存储结构，其中sp是指向字符串的指针域，next是指向该结构的指针域，data用以存放整型数。请填空，完成此结构的类型说明和变量root的定义。 root struct { char *sp ; __ __; _ _; } root; 2. 阅读下面的程序，写出程序结果 (1) struct info { char a,b,c;}; main() { struct info s[2]={{‘a’,‘b’,‘c’},{‘d’,‘e’,‘f’}};int t; t=(s[0].b-s[1].a)+(s[1].c-s[0].b); printf("%d\n",t); } (2)
C语言复习题指针结构体
C语言复习题_指针&结构体 一、选择 1、若有以下定义：char s[20]="programming",*ps=s; 则不能代表字符'o'的表达式是A。 A) ps+2 B) s[2] C) ps[2] D) ps+=2,*ps 2、若有以下定义和语句: int a[10]={1,2,3,4,5,6,7,8,9,10},*p=a;则不能表示a数组元素的表达式是B。 A) *p B) a[10] C) *a D) a[p-a] 3、已知int *p,a; p=&a; 这里的运算符& 的含义D。 A) 位与运算B) 逻辑与运算C) 取指针内容D) 取变量地址 4、定义结构体如下： struct student { int num; char name[4]; int age; }; 则printf(“%d”,sizeof(struct student))的结果为: 12。 5、若有定义如下:int i=3,*p=&i; 显示i的值的正确语句是B。 A) printf(“%d”,p); B) printf(“%d”,*p); C) printf(“%p”,*p); D) printf(“%p”,p); 6、在定义结构体时，下列叙述正确的是A。 A) 系统不会分配空间 B) 系统会按成员大小分配空间 C) 系统会按最大成员大小分配空间 D) 以上说法均不正确 7、指针是一种D。 A) 标识符B) 变量C) 运算符D) 内存地址 8、定义struct s {int x; char y[6];} s1;,请问正确的赋值是C。 A) s1.y=”abc”; B) s1->y=”abc”; C) strcpy(s1.y,”abc”); D) s1.strcpy(y,”abc”); 9、已知定义“int x ＝1, *p”，则合法的赋值表达式是A。 A) p ＝&x B) p = x C) *p ＝&x D) *p ＝*x
C语言-基础教程-结构体类型变量的定义和引用
C语言-基础教程-结构体类型变量的定义和引用 前面的课程我们学习了一些简单数据类型（整型、实型、字符型）的定义和应用，还学习了数组（一维、二维）的定义和应用，这些数据类型的特点是：当定义某一特定数据类型，就限定该类型变量的存储特性和取值范围。对简单数据类型来说，既可以定义单个的变量，也可以定义数组。而数组的全部元素都具有相同的数据类型，或者说是相同数据类型的一个集合。 在日常生活中，我们常会遇到一些需要填写的登记表，如住宿表、成绩表、通讯地址等。 在这些表中，填写的数据是不能用同一种数据类型描述的，在住宿表中我们通常会登记上姓名、性别、身份证号码等项目；在通讯地址表中我们会写下姓名、邮编、邮箱地址、电话号码、E - m a i l等项目。这些表中集合了各种数据，无法用前面学过的任一种数据类型完全描述，因此C引入一种能集中不同数据类型于一体的数据类型-结构体类型。结构体类型的变量可以拥有不同数据类型的成员，是不同数据类型成员的集合。 在上面描述的各种登记表中，让我们仔细观察一下住宿表、成绩表、通讯地址等。 住宿表由下面的项目构成： 这些登记表用C提供的结构体类型描述如下： 住宿表: suct accommod { char name[20]; / *姓名* / char sex; / *性别* / char job[40]; / *职业* / int age; / *年龄* / long number; / *身份证号码* / } ; 成绩表: suct score
{ char grade[20]; / * 班级* / long number; / * 学号* / char name[20]; / *姓名* / float os; / *操作系统* / float datasu; / * 数据结构* / float compnet; / * 计算机网络* / } ; 通讯地址表: suct addr { char name[20]; char department[30];/ * 部门* / char address[30]; / *住址* / long box; / * 邮编* / long phone; / * 电话号码* / char email[30]; / * E m a i l * / }；
c语言结构体定义结构体
c语言结构体定义结构体 代码1 定义结构体_m_usmart_devstruct _m_usmart_dev{struct _m_usmart_nametab *funs;//函数名指针 void (*init)(u8);//初始化u8 (*cmd_rec)(u8*str);//识别函数名及参数void (*exe) (void); //执行void (*scan)(void); //扫描u8 fnum; //函数数量u8 pnum; //参数数 量u8 id;//函数idu8 sptype;//参数显示类型(非字符串参数):0,10 进制;1,16 进制; u16 parmtype;//参数的类型u8 plentbl[MAX_PARM]; //每个参数的长度暂存表u8 parm[PARM_LEN]; //函数的参数}; 代码2 定义_m_usmart_dev 类型的结构体并对其赋初始值 struct _m_usmart_dev usmart_dev={usmart_nametab,usmart_init,usmart_cmd_rec,usmart_exe,usmart_scan, sizeof(usmart_nametab)/sizeof(struct _m_usmart_nametab),//函数数量0, //参数数 量0, //函数ID1,//参数显示类型,0,10 进制;1,16 进制0,//参数类型.bitx:,0,数字;1, 字符串0, //每个参数的长度暂存表,需要MAX_PARM 个0 初始化0,//函数的参 数,需要PARM_LEN 个0 初始化}; 上边代码可理解为 struct _m_usmart_dev{struct _m_usmart_nametab *funs;//函数名指针 void (*init)(u8);//初始化u8 (*cmd_rec)(u8*str);//识别函数名及参数void (*exe) (void); //执行void (*scan)(void); //扫描u8 fnum; //函数数量u8 pnum; //参数数 量u8 id;//函数idu8 sptype;//参数显示类型(非字符串参数):0,10 进制;1,16 进制; u16 parmtype;//参数的类型u8 plentbl[MAX_PARM]; //每个参数的长度暂存表u8 parm[PARM_LEN]; //函数的参数} usmart_dev={usmart_nametab,usmart_init,usmart_cmd_rec,usmart_exe,usmart_scan,
c语言结构体指针初始化===
c语言结构体指针初始化 今天来讨论一下C中的内存管理。 记得上周在饭桌上和同事讨论C语言的崛起时，讲到了内存管理方面 我说所有指针使用前都必须初始化，结构体中的成员指针也是一样 有人反驳说，不是吧，以前做二叉树算法时，他的左右孩子指针使用时难道有初始化吗 那时我不知怎么的想不出理由，虽然我还是坚信要初始化的 过了几天这位同事说他试了一下，结构体中的成员指针不经过初始化是可以用（左子树和右子树指针） 那时在忙着整理文档，没在意 今天抽空调了一下，结论是，还是需要初始化的。 而且，不写代码你是不知道原因的（也许是对着电脑久了IQ和记性严重下跌吧） 测试代码如下 1.#include 2.#include 3.#include 4. 5.struct student{ 6.char *name; 7.int score; 8.struct student* next; 9.}stu,*stu1; 10. 11.int main(){ 12. https://www.360docs.net/doc/e313161958.html, = (char*)malloc(sizeof(char)); /*1.结构体成员指针需要初始化*/ 13. strcpy(https://www.360docs.net/doc/e313161958.html,,"Jimy"); 14. stu.score = 99; 15. 16. stu1 = (struct student*)malloc(sizeof(struct student));/*2.结构体指针需要初始化*/ 17. stu1->name = (char*)malloc(sizeof(char));/*3.结构体指针的成员指针同样需要初始化*/ 18. stu.next = stu1; 19. strcpy(stu1->name,"Lucy"); 20. stu1->score = 98; 21. stu1->next = NULL; 22. printf("name %s, score %d \n ",https://www.360docs.net/doc/e313161958.html,, stu.score); 23. printf("name %s, score %d \n ",stu1->name, stu1->score); 24. free(stu1); 25.return 0; 26.} #include #include #include struct student{ char *name; int score; struct student* next; }stu,*stu1; int main(){ https://www.360docs.net/doc/e313161958.html, = (char*)malloc(sizeof(char)); /*1.结构体成员指针需要初始化*/ strcpy(https://www.360docs.net/doc/e313161958.html,,"Jimy"); stu.score = 99; stu1 = (struct student*)malloc(sizeof(struct student));/*2.结构体指针需要初始化*/ stu1->name = (char*)malloc(sizeof(char));/*3.结构体指针的成员指针同样需要初始化*/ stu.next = stu1; strcpy(stu1->name,"Lucy"); stu1->score = 98; stu1->next = NULL; printf("name %s, score %d \n ",https://www.360docs.net/doc/e313161958.html,, stu.score);
C语言结构体(struct)常见使用方法
C语言结构体（struct）常见使用方法 基本定义：结构体，通俗讲就像是打包封装，把一些有共同特征（比如同属于某一类事物的属性，往往是某种业务相关属性的聚合）的变量封装在内部，通过一定方法访问修改内部变量。 结构体定义： 第一种：只有结构体定义 [cpp]view plain copy 1.struct stuff{ 2.char job[20]; 3.int age; 4.float height; 5.}; 第二种：附加该结构体类型的“结构体变量”的初始化的结构体定义 [cpp]view plain copy 1.//直接带变量名Huqinwei 2.struct stuff{ 3.char job[20]; 4.int age; 5.float height; 6.}Huqinwei; 也许初期看不习惯容易困惑，其实这就相当于： [cpp]view plain copy 1.struct stuff{ 2.char job[20]; 3.int age;
4.float height; 5.}; 6.struct stuff Huqinwei; 第三种：如果该结构体你只用一个变量Huqinwei，而不再需要用 [cpp]view plain copy 1.struct stuff yourname; 去定义第二个变量。 那么，附加变量初始化的结构体定义还可进一步简化出第三种： [cpp]view plain copy 1.struct{ 2.char job[20]; 3.int age; 4.float height; 5.}Huqinwei; 把结构体名称去掉，这样更简洁，不过也不能定义其他同结构体变量了——至少我现在没掌握这种方法。 结构体变量及其内部成员变量的定义及访问： 绕口吧？要分清结构体变量和结构体内部成员变量的概念。 就像刚才的第二种提到的，结构体变量的声明可以用： [cpp]view plain copy 1.struct stuff yourname; 其成员变量的定义可以随声明进行： [cpp]view plain copy 1.struct stuff Huqinwei = {"manager",30,185}; 也可以考虑结构体之间的赋值： [cpp]view plain copy
C语言结构指针
C语言结构指针 这篇文章是九九年写的，这篇文章适合中级程序员。有不明白之处不要紧，多看几遍，然后花些时间上机操作及认真思考每个问题。遇到难题要研究、解决，难题出现于哪里？该用什么方式来解决？为什么要选择这个方式解决？有其它的解决方法吗？这样的解决方案完美吗？其实做个程序员这些基本的思考心得是要掌握的。记住；遇问题不要逃避，要面对现实、勇于挑战，仔细研究难题的所在，这样相信你会成功的！ 指针结构与指针的关系亦有两重：其一是在定义结构时，将指针作为结构中的一个成员；其二是指向结构的指针（称为结构指针）。前者同一般的结构成员一样可直接进行访问，后者是本节讨论的重点。 结构指针说明的一般形式是： struct 结构类型名称* 结构指针变量名； 例如：struct date * pdate, today; 说明了两个变量，一个是指向结构date的结构指针pdate，today是一个date结构变量。语句： pdate = &today; pdate today (struct date) year month day 通过结构变量today访问其成员的操作，也可以用等价的指针形式表示： today.year = 2001;等价于(*pdate).year = 2001;
由于运算符"*"的优先级比运算符"."的优先级低，所以必须有"( )"将*pdate括起来。若省去括号，则含义就变成了"*(pdate.year)"。 在Ｃ语言中，通过结构指针访问成员可以采用运算符"->"进行操作，对于指向结 构的指针，为了访问其成员可以采用下列语句形式： 结构指针->成员名; 这样，上面通过结构指针pdate访问成员year的操作就可以写成： pdate->year = 2001; 如果结构指针p指向一个结构数组，那么对指针p的操作就等价于对数组下标的操作。 结构指针是指向一种结构类型的指针变量，它是结构在内存中的首地址，结构指针具有一般指针的特性，如在一定条件下两个指针可以进行比较，也可以与整数进行加减。但在指针操作时应注意：进行地址运算时的放大因子由所指向的结构的实际大小决定。 例11-7：用结构指针改写加密程序。 #include "stdio.h" struct table { char input, output; } ; struct table translate[ ]= { 'a', 'd', 'b', 'w', 'c', 'k', 'd', ';' , 'e', 'i', 'i', 'a', 'k', 'b', ';', 'c', 'w', 'e' }; /* 建立加密对照表*/ main( ) { char ch; struct table *p, *pend; /* p和pend为指向结构table的指针*/ pend = & translate[ sizeof(translate)/sizeof(struct table)-1 ]; /* pend指向结构数组translate的最后一个元素*/ while ( (ch=getchar( )) != '\n')