c20-指向结构体类型数据的指针
指向结构体变量的指针
变量的指针就是变量的地址
一个结构体变量的指针就是该变量所占据内存空间的起始地址。
可以把一个结构体变量的起始地址赋予一个指针变量，使该指针变量指向该结构体变量。
一个指针变量当用来指向一个结构体变量时，称之为结构体指针变量。通过结构体指针变量即可访问相应的结构体变量。
假如已经定义了如下结构体类型：
struct stu
{
int num;
char name[20];
char sex;
float score;
};
如要声明一个指向struct stu类型变量的指针变量pstu，可写为：
struct stu *pstu;
当然也可在定义结构体类型struct stu的同时定义pstu。
如果boy1是struct stu类型的变量,那么可以把boy1的地址赋给pstu
pstu=&boy1；
通过结构体指针变量，能更方便地访问结构体变量的各个成员。
其访问的一般形式为：
(*结构体指针变量).成员名
或为：
结构体指针变量->成员名
例如：
(*pstu).num //boy1.num
或者：
pstu->num
应该注意(*pstu)两侧的括号不可少，因为成员符“.”的优先级高于“*”。如去掉括号写作*pstu.num则等效于*(pstu.num)，这样，意义就完全不对了。
下面通过例子来说明结构体指针变量的应用。
例题1
struct stu
{
int num;
char name[20];
char sex;
float score;
} boy1={102,"Zhang ping",'M',78.5},*pstu;
main()
{
pstu=&boy1;
printf("Number=%d\nName=%s\n",boy1.num,https://www.360docs.net/doc/c73099986.html,);
printf("Sex=%c\nScore=%f\n\n",boy1.sex,boy1.score);
printf("Number=%d\nName=%s\n",(*pstu).num,(*pstu).name);
printf("Sex=%c\nScore=%f\n\n",(*pstu).sex,(*pstu).score);
printf("Number=%d\nName=%s\n",pstu->num,pstu->name);
printf("Sex=%c\nScore=%f\n\n",pstu->sex,pstu->score);
}
本例程序定义了一个结构体类型struct stu，定义了struct stu类型变量boy1并作了初始化赋值，还定义了一个指向struct stu类型结构体变量的指针变量pstu。在main函数中，pstu被赋予boy1的地址，因此pstu指向boy1。然后用三种形式输出boy1的各个成员值。从运行结果可以看出：
结构体变量.成员名
(*结构体指针变量).成员名
结构体指针变量->成员名
这三种表示结构体变量成员的形式是完全等价的。
指向结构体数组的指针
如果结构体指针变量的值是某个结构体数组的首地址，这时结构体指针变量指向该结构体数组。
如果结构体指针变量的值是某结构体数组元素的地址，这时结构体指针变量指向该元素。
例题2指向结构体数组的指针的应用
struct stu
{
int num;
char name[20];
char sex;
float score;
}boy[5]={
{101,"Zhou ping",'M',45},
{102,"Zhang ping",'M',62.5},
{103,"Liou fang",'F',92.5},
{104,"Cheng ling",'F',87},
{105,"Wang ming",'M',58},
};
main()
{
struct stu *ps;
printf("No\tName\t\t\tSex\tScore\t\n");
for(ps=boy;ps printf("%d\t%s\t\t%c\t%f\t\n",ps->num,ps->name,ps->sex,ps->score); } 在程序中，定义了struct stu类型的外部数组boy并作了初始化赋值。在main函数内定义ps为指向struct stu 类型变量的指针变量。在循环语句for的表达式1中，ps被赋予boy的首地址，循环5次，输出boy数组中各元素的各成员值。 应该注意的是，一个结构体指针变量虽然可以用来访问结构体变量或结构体数组元素的成员，但是，不能使它指向一个成员。也就是说不允许取一个成员的地址来赋予它。因此，下面的赋值是错误的。 ps=&boy[1].sex; 错误赋值 类型定义符typedef 除了可以直接使用c提供的标准类型名和自己声明的结构体,共用体,指针,枚举类型外。 还可以用typedef声明新的类型名来代替已有的类型名。 例如，有整型变量a,b,其声明如下： int a,b; int的英文全称为integer，为了增加程序的可读性,可以进行如下定义 typedef int INTEGER 以后就可用INTEGER来代替int作整型变量的类型说明了。 例如： INTEGER a,b; 它等效于： int a,b; 用typedef定义数组、指针、结构体等类型将带来很大的方便，不仅使程序书写简单而且使意义更为明确，因而增强了可读性。 例如： typedef int NAME[5]; 声明NAME是整型数组类型，数组长度为5。然后可用NAME 声明变量，如： NAME a1,a2,s1,s2; 完全等效于： int a1[5],a2[5],s1[5],s2[5]; 又例如: typedef int * PS; //声明ps是基类型为整型的指针类型 PS p1,p2,p3; int * p1,p2,p3; 又如： typedef struct { char name[20]; int age; char sex; } STU; 声明STU为结构体类型，然后可用STU来声明结构体变量： STU boy1,boy2; struct{ char name[20]; int age; char sex; } boy1,boy2; 习惯上用typedef声明的类型名一般用大写字母表示，以便于区别。 有时也可用宏定义来代替typedef的功能，但是宏定义是由预处理完成的，而typedef则是在编译时完成的，后者更为灵活方便。 考试真题 有以下程序 #include struct st { int x, y;} data[2]={{l,10},{2,20}}; main() { struct st *p=data; p--------->data[0] p-------->data[1] printf("%d,", p->y); printf("%d\n",(++p)->x); } 程序的运行结果是（）。 A）10,1 B）20,1 C）10,2 D）20,2 有以下定义和语句 struct workers {int num; char name[20];char c; struct {int day;int month;int year;} s; }; struct workers w,*pw; pw=&w; 能给w中year成员赋1980的语句是 A）*pw.year=1980; B）w.year=1980; C）pw->year=1980; D）w.s.year=1980; (45)有以下程序 #include struct tt {int x;struct tt *y;} *p; struct tt a[4]={20,a+1,15,a+2,30,a+3,17,a}; //a[0].x=20 a[0].y------------→a[1] main() //a[1].x=15 a[1].y-----------→a[2] { int i; //a[2].x=30 a[2].y--------→a[3] p=a; //a[3].x=17 a[3].y----------→a[0] for(i=1;i<=2;i++) {printf("%d,",p->x); p=p->y;} } 20 15 程序的运行结果是 A)20,30, B)30,17 C)15,30, D)20,15, (14)有以下程序 #include typedef struct {int num;double s;}REC; void fun1(REC*x){(*x).num=23;x->s=88.5;} main() {REC a={16,90.0}; fun1(&a); printf("%d\n",a.num); } 输入答案，中间不含空格: 23 有以下程序 #include #include typedef struct{ char name[9];char sex; float score[2]; } STU; STU f(STU a) { STU b={"Zhao",'m',85.0,90.0}; int i; strcpy(https://www.360docs.net/doc/c73099986.html,,https://www.360docs.net/doc/c73099986.html,); a. sex= b.sex; for(i=0;i<2;i++) a.score[i]=b.score[i]; //把b的score成员中的2个元素赋值给a的score成员中的两个元素 return a; } main() {STU c={"Qian",'f',95.0,92.0},d; d=f(c); printf("%s,%c,%2.0f,%2.0f\n",https://www.360docs.net/doc/c73099986.html,,d.sex,d.score[0],d.score[1]); } 最后输出什么：Zhao m 85 90 参数类型ANY的格式 STEP 7以10个字节存储参数类型ANY。当构造类型为ANY的参数时，必须确保所有10个字节都被占用，因为调用块估计参数整个内容的值。例如，如果以字节4指定DB编号，也必须以字节6明确地指定存储器区。 STEP 7管理基本和复杂数据类型的数据与参数类型的数据不同。 数据类型的ANY格式 对于基本和复杂数据类型，STEP 7存储下列数据： ?数据类型 ?重复因子 ?DB编号 ?信息存储的存储区域 ?数据的起始地址 重复因子识别由参数类型ANY传送的指示数据类型的数量。这意味着可以指定数据区，也可以和参数类型ANY结合使用数组和结构。STEP 7将数组和结构识别为数据类型的编号(借助重复因数)。例如，如果要传送10个字，必须为重复因子输入数值10，并且必须为数据类型输入数值04。 地址以格式Byte.Bit存储，此处字节寻址存储在字节7的位0 - 2，节字8的位0 - 7，节字9的位3 - 7。位地址存储在字节9的位0 - 2。 对于类型NIL的空指针，所有来自字节1的字节设置为0。 下表给出参数类型ANY的数据类型或存储区域的编码。 参数类型的ANY格式 对于参数类型，STEP 7存储数据类型和参数的地址。重复因子始终是1。字节4、5和7始终是0。字节8和9指示定时器、计数器或块的编号。 下表为参数类型显示参数类型ANY的数据类型编码。 使用参数类型ANY 可以为适合于任何数据类型的实际参数的块定义形式参数。当调用块是未知或可以改变时(和当允许任何数据类型时)，已提供了实际参数的数据类型时，这尤其有用。在块的变量声明中，可以声明参数为数据类型ANY。然后可以在STEP 7中分配任何数据类型的实际参数。 STEP 7为ANY数据类型的变量分配存储器的80个位。如果分配实际参数给此形式参数，STEP 7在80个位中编码起始地址、数据类型和实际参数的长度。调用块为ANY参数分析保存数据的80个位，并获取进一步处理所需的信息。 分配实际参数给ANY参数 如果为参数声明数据类型ANY，可以分配任何数据类型的实际参数给形式参数。在STEP 7中，可以指定下列数据类型为实际参数： ?基本数据类型：指定实际参数的绝对地址或符号名称。 ?复杂数据类型：指定复杂数据类型的数据符号名称(例如，数组和结构)。 ?定时器、计数器和块：指定编号(例如，T1、C20或FB6)。 ?下图说明数据如何传送到具有ANY数据类型参数的FC。 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语言中指针的概念 强大的指针功能是C语言区别于众多高级语言的一个重要特征。C语言指针的功能强大，使用灵活多变，可以有效地表示复杂的数据结构、动态分配内存、高效地使用数组和字符串、使得调用函数时得到多个返回值。而它的应用远不限于此。初学者对于指针的概念总是感到无所适从，有时觉得“自己懂了，为什么编译器就是不懂呢”，常有茫然和无助的感觉。 学好指针的关键在于深入了解内存地址的空间可以理解为一个一维线性空间，内存的编址和寻址方法，以及指针在使用上的一些规定。事实上，指针就是方便我们对内存地址直接进行操作的，是为程序员服务的，我们只要抓住指针想要帮助我们解决什么问题这个核心，就可以轻松地理解它的工作原理。 什么是指针，指针有什么作用 指针就是指向一个特定内存地址的一个变量。简化了的内存空间模型是按照从0到某一个数（比如1048575=1M-1）的一维线性空间，其中的每一个数对应一个存储单元，即1个字节。指针有两个属性：指向性和偏移性。指向性指的是指针一定要有一个确定的指向，偏移性则是体现指针重要应用的方面，即指针可以按程序员的要求向前或向后偏移。 指针的应用往往与数组联系在一起，为了方便说明问题，不妨从数组开始解释指针的偏移。数组就是许多的变量，它的一个重要特征就是在内存空间中连续地存放，而且是按下标顺序存放。比如我们定义一个有100个变量的一维整型数组，它一定从内存的某一个存储单元开始按数组下标顺序存放，连续占用100*4=400字节。当我们定义一个数组时，系统就会自动为它分配一个指针，这个指针指向数组的首地址。（在本文剩余部分的论述中，不加区分地使用“指向数组的首地址”与“指向数组的第一个元素”这两种说法，事实上这两种说法也是一致的。） 为了让系统了解每一次指针偏移的单位，也为了方便程序员进行指针偏移（让程序员记住一个整形变量占用4字节，一个字符型变量占用1字节……等等是很麻烦的），不用每次去计算要偏移多少个字节，C语言引入了指针的基类型的概念。基类型的作用就是让系统了解某个指针每次偏移的字节数。比如，对于一个字符型指针，它每次偏移（比如ptr=ptr+1）所起到的作用就是让指针偏移1字节；而对于一个整型指针，它每次偏移就应该是4字节。这样操作数组时就带来了方便。比如对于一个指向某个整型数组起始存储单元（称为首地址）的指针ptr，ptr=ptr+1就表示将该指针指向这个数组的下一个元素的存储单元，即向后移动4字节，而不仅仅是移动一个存储单元（即移动1字节）。 &()、*()、和[ ]运算符的意义 在本文中，将&()、*()和[ ]都看成是运算符。这样可以方便理解这三个概念。简单地说，&()将某个标识符（比如变量）转化为其在内存空间中的地址，而*()是产生一个对应于某个地址的标识符，[ ]就更复杂一点，ptr[i]表示 什么是结构体？ 简单的来说，结构体就是一个可以包含不同数据类型的一个结构，它是一种可以自己定义的数据类型，它的特点和数组主要有两点不同，首先结构体可以在一个结构中声明不同的数据类型，第二相同结构的结构体变量是可以相互赋值的，而数组是做不到的，因为数组是单一数据类型的数据集合，它本身不是数据类型(而结构体是)，数组名称是常量指针，所以不可以作为左值进行运算，所以数组之间就不能通过数组名称相互复制了，即使数据类型和数组大小完全相同。 定义结构体使用struct修饰符，例如： struct test { float a; int b; }; 上面的代码就定义了一个名为test的结构体，它的数据类型就是test，它包含两个成员a和b，成员a的数据类型为浮点型，成员b的数据类型为整型。由于结构体本身就是自定义的数据类型，定义结构体变量的方法和定义普通变量的方法一样。 test pn1; 这样就定义了一个test结构体数据类型的结构体变量pn1，结构体成员的访问通过点操作符进行，pn1.a=10 就对结构体变量pn1的成员a进行了赋值操作。注意:结构体生命的时候本身不占用任何内存空间，只有当你用你定义的结构体类型定义结构体变量的时候计算机才会分配内存。 结构体，同样是可以定义指针的，那么结构体指针就叫做结构指针。 结构指针通过->符号来访问成员，下面我们就以上所说的看一个完整的例子： #include 第十章指针 一．选择题 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”;} 和一般的数据结构里面的链表的实现没什么大不同， 在list.h里面只修改一个地方 typedef void * ElemType; 也就是说数据域是一个无类型指针，链表本身不对这个指针有数据访问，在使用链表的时候我们给一个有类型的指针，在操作的时候编译器有规律可循了，接下来只要链表数据访问的函数了，因为数据域是一个指针，因为没有修改TraverseList函数，那么给函数指针传递的一个指向指针的指针，所以修改遍历数据域访问函数如下 int TraverseList(List*,int (*)(ElemType *));/* 遍历访问，反问某个节点元素用函数处理 */ list.htypedef void * ElemType; typedef struct node { ElemType data; struct node * next; }ChainNode; typedef struct { ChainNode *head; int size; ChainNode *tail; }List; List * CreateList(void); /* 创建链表 */ void DestoryList(List*); /* 销毁链表 */ void ClearList(List*); /* 清空链表 */ int ListAppend(List*,ElemType); /* 追加元素 */ int ListInsert(List*,int,ElemType); /* 加入元素 */ int ListDelete(List *,int); /* 删除第几个元素 */ int GetElem(List*,int,ElemType *); /* 取得第几个元素的值用第三个参数返回 */ ChainNode * GetAddr(List *, int); /* 取得编号为N的元素所在地址 */ int TraverseList(List*,int (*)(ElemType *)); /* 遍历访问，反问某个节点元素用函数处理 */ ChainNode * NewChainNode( ElemType); list.c #include "list.h" /*==================*/ /*==================*/ List *CreateList() { List * pt = 0; ElemType data; pt=(List*)malloc( sizeof(List) ); if( !pt ) return 0; pt->head = NewChainNode(data ); if( ! pt->head ) { free(pt); return 0; } pt->tail = pt->head; return pt; } /*==================*/ void DestoryList(List * plist) { ClearList(plist); free(plist->head); plist->head = 0; free(plist); plist = 0; 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; 实验14 指针在结构体中的应用 一、实验目的 1．掌握结构体类型指针的定义及使用方法。 2．掌握结构体类型指针作为函数参数，实现函数调用。 3．掌握简单链表的基本操作。 二、实验要求 1．通过阅读及编程，掌握结构体类型指针的定义及使用方法。 2．通过阅读及编程，掌握结构体类型指针作为函数参数，实现函数调用。 3．通过阅读及编程，掌握简单链表的基本操作（包括链表的建立、查找、遍历、插入、删除）。 三、实验内容 1．阅读下列程序，预测程序运行结果，然后上机验证。 main （） { struct num { int a ; int b ; float f ; } n={ 1 , 3, 5.0 }; struct num * pn =&n ; printf ( “ %d\n ” , ( pn->b/n.a )*(++pn ->b) ); printf ( “ %f \n ” , ( *pn ).a + pn ->f ); } 1．读下列程序，指出程序的功能。 struct tm { int hours ; int minutes ; int seconds ; }; main ( ) { struct tm time ; time. hours=0 ; time. minutes =0; time . seconds =0 ; for ( ; ; ) { update ( &time ); display (&time ); } } update ( struct tm * t ) { t-> seconds++; if ( t-> seconds= =60 ) { t-> seconds=0; t-> minues++; } if ( t-> minues= =60 ) { t-> minues=0; t-> hours++; } if ( t-> hours= =24 ) t-> hours=0; deday ( )； } display ( struct tm * t ) { printf ( “%d: ” , t-> hours ); printf ( “%d: ” , t-> minutes ); printf ( “%d:\n” , t-> seconds ); } delay ( ) { long int t; for ( t=1; t<12800 ; ++t ); } 3. 阅读并运行下列程序，写出运行结果。 #include “stdio.h” main ( ) { struct person { char name[20]; (pointer)——C/C++的精髓！你不得不学好它！ 指针(pointer) 指针是一种数据类型，用于存放某个变量的地址值。此时该指针被称为是指向该变量。 一个指针的类型决定于它所指向的变量的类型。 指针既可指向基本数据类型（即预定义数据类型），又可指向数组、函数、类和文件等用户自定义数据类型。 指针可以初始化为0、NULL（即0，这是标准库头文件中定义的符号化常量）或一个地址。内容为0或NULL的指针不指向任何变量，称为空指针。 例如： int a; int *ptr; 指针ptr在下式中被初始化为指向变量a。 ptr = &a; 两条语句也可组合地表示为： a = *ptr; 其中&为存地址运算符，而*则为取内容运算符。 ptr a int a, *ptr; ptr = &a; 指针与数组 数组名是一个指向该数组的常量指针（其值不能改变），也是该数组中首单元的地址值。一维数组的指针如下： int arr[5] = { 1, 3, 5, 7, 9 }; int *ptra; ptra = arr; ptra 数组指针与数组名两者的异同： （1）整型变量指针ptr与整型数组指针ptra的说明格式相同，其间空格可放可不放。 （2）arr既是数组名，又是数组地址，还是数组指针（称为常量指针），三位一体。因此arr可在一定范围内与ptra等效地使用。[ ]可在一定范围内与* 等效地使用。但arr不准重新赋值。例如： arr[0]即*arr即*ptra即ptra[0] = 1 arr[3]即*(arr+3)即*(ptra+3)即ptra[3] = 7 但arr的使用不如ptra灵活，如： 不允许*arr++，而允许*ptra++。 见以下例子：§2.2中[例1]的主程序 void main() { int arr[5] = {1, 3, 5, 7, 9}; for ( int i = 0; i < 5; i++) cout << arr[i] << endl; //数组名 指针 1.在主函数中输入一个字符串str，调用函数统计字符串中出现的字母（含大 小写）、数字、空格及其他字符出现的次数，在主函数中输出统计结果。要求写三个版本的程序：（1）用指针作参数返回统计结果。（2）用引用做参数返回统计结果(引用做参数效率更高，代码更简单。)（3）用数组做参数返回统计结果(当返回多个同类型结果时用数组做参数更简单)。 1.#include 要了解指针,多多少少会出现一些比较复杂的类型,其实要理解复杂类型其实很简单,一个类型里会出现很多运算符,他们也像普通的表达式一样,有优先级,其优先级和运算优先级一样,其原则:从变量名处起,根据运算符优先级结合,一步一步分析。 皻 int p;///这是一个普通的整型变量 int*p;///首先从P处开始,先与*结合,所以说明P是一个指针,然后再与int结合,说明指针所指向的内容的类型为int型.所以P 是一个返回整型数据的指针 int p[3];///首先从P处开始,先与[]结合,说明P是一个数组,然后与int结合,说明数组里的元素是整型的,所以P是一个由整型数 据组成的数组 int*p[3];///首先从P处开始,先与[]结合,因为其优先级比*高,所以P 是一个数组,然后再与*结合,说明数组里的元素是指针类型, 然后再与int结合,说明指针所指向的内容的类型是整型的,所 以P是一个由返回整型数据的指针所组成的数组 int(*p)[3];///首先从P处开始,先与*结合,说明P是一个指针然后再与[]结合(与"()"这步可以忽略,只是为了改变优先级),说明指针 所指向的内容是一个数组,然后再与int结合,说明数组里的元 素是整型的.所以P是一个指向由整型数据组成的数组的指针int**p;///首先从P开始,先与*结合,说是P是一个指针,然后再与*结合,说明指针所指向的元素是指针,然后再与int结合,说明该 指针所指向的元素是整型数据.由于二级指针以及更高级的指 针极少用在复杂的类型中,所以后面更复杂的类型我们就不考 虑多级指针了,最多只考虑一级指针. int p(int);///从P处起,先与()结合,说明P是一个函数,然后进入()里分析,说明该函数有一个整型变量的参数然后再与外面的int 结合,说明函数的返回值是一个整型数据 Int(*p)(int);///从P处开始,先与指针结合,说明P是一个指针,然后与()结合,说明指针指向的是一个函数,然后再与()里的int结 合,说明函数有一个int型的参数,再与最外层的int结合,说 明函数的返回类型是整型,所以P是一个指向有一个整型参数 且返回类型为整型的函数的指针 int*(*p(int))[3];///从P开始,先与()结合,说明P是一个函数,然后进入()里面,与int结合,说明函数有一个整型变量参数,然后再 与外面的*结合,说明函数返回的是一个指针,,然后到最外面 一层,先与[]结合,说明返回的指针指向的是一个数组,然后再 与*结合,说明数组里的元素是指针,然后再与int结合,说明指 针指向的内容是整型数据.所以P是一个参数为一个整数据且 返回一个指向由整型指针变量组成的数组的指针变量的函数. 1、细说指针 指针是一个特殊的变量，它里面存储的数值被解释成为内存里的一个地址。 要搞清一个指针需要搞清指针的四方面的内容：指针的类型、指针所指向的类型、指针的值或者叫指针所指向的内存区、指针本身所占据的内存区。 先声明几个指针放着做例子： 例一： VC++指针详解 指针是一个特殊的变量，它里面存储的数值被解释成为内存里的一个地址。要搞清一个指针需要搞清指针的四方面的内容：指针的类型，指针所指向的类型，指针的值或者叫指针所指向的内存区，还有指针本身所占据的内存区。让我们分别说明。 先声明几个指针放着做例子。 例一： (1)int *ptr; (2)char *ptr; (3)int **ptr; (4)int(*ptr)[3]; (5)int*(*ptr)[4]; 如果看不懂后面几个例子的话，请参阅我前段时间贴出的文章《如何理解c和c ++的复杂类型声明》。 指针的类型 从语法的角度看，你只要把指针声明语句里的指针名字去掉，剩下的部分就是这个指针的类型。这是指针本身所具有的类型。让我们看看例一中各个指针的类型： (1)int *ptr;//指针的类型是int * (2)char *ptr;//指针的类型是char * (3)int **ptr;//指针的类型是int ** (4)int(*ptr)[3];//指针的类型是int(*)[3] (5)int*(*ptr)[4];//指针的类型是int*(*)[4] 怎么样？找出指针的类型的方法是不是很简单？ 指针所指向的类型 当你通过指针来访问指针所指向的内存区时，指针所指向的类型决定了编译器将把那片内存区里的内容当做什么来看待。 从语法上看，你只须把指针声明语句中的指针名字和名字左边的指针声明符*去掉，剩下的就是指针所指向的类型。例如： (1)int *ptr;//指针所指向的类型是int (2)char *ptr;//指针所指向的的类型是char (3)int **ptr;//指针所指向的的类型是int * (4)int(*ptr)[3];//指针所指向的的类型是int()[3] (5)int*(*ptr)[4];//指针所指向的的类型是int*()[4] 9.1 指针类型的声明 指针类型在任何语言中都是比较难以理解也是比较灵活的一种数 据类型 指针常是它所指的变量的内存地址。声明指针类型的语法如下： Type 〈指针类型标志符〉=^〈基类型〉； 其中，指针类型标志符即是指针类型名，基类型可以是简单类 型，如整型，实型，字符型等，也可以是结构类型，如数组，记 录，集合等。 指针类型声明示例： Type Tr = ^Integer; PI = ^real; Word = Record Name: String[10]; Age: Integer; Scores: Real; End; BytePtr = ^Byte; WordPtr = ^Word; 上例中，声明了4个指针类型。其中，BytePtr是一个指向字节类型的数据；而WordPtr是一个指向记录类型Word的数据Object Pascal不要求基类型一定是要在前面已声明的，也可以是一个标志符，然后在同一个模块内声明基类型。 声明了指针类型后，就可以声明指针类型的变量，如： Var BP: BytePtr; WP: WordPtr; 或： Var BP: ^Bytel; 指针所指的基类型可以是简单类型，也可以是构造类型，如：Type Student = Record Name: String; Age: Integer; Sex: (Man, Woman); End; Var StuPtr: ^Student; 上例中，声明了一个指向记录类型的Student指针变量StuPtr，以后程序中就可以使用StuPtr^来表示记录类型Student的动态变量。要访问其中的Name字段，可以写成StuPtr^.Name。这里介绍动态变量的概念，动态变量的构成是用指针类型的变量标志符后加一个“^”符号，就构成指针所指向的基类型的动态变量，如上例中的StuPtr^就是Student的动态变量。 与通常的变量一样，一旦声明了指针变量，编译器将给指针分配存储单元，但存储单元中的值尚未确定。要想让指针指向确定的地址，必须通过赋值语句或New标准过程来实现。如：Label 1,2,3,4,5; Var M: Integer; X1, X2: ^Integer; Begin 1: M:= 20; 2: X1:= @M; 3: New(X2); 4: X2^:= 150; 5: Dispose(X2); End; 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') 第７章指针数据类型及其应用 指针是Ｃ语言中广泛使用的一种数据类型。运用指针编程是Ｃ语言最主要的风格之一。利用指针变量可以表示各种数据结构，能很方便地使用数组和字符串，并能象汇编语言一样处理内存地址，从而编出精练而高效的程序。学习指针是学习Ｃ语言中最重要的一环，能否正确理解和使用指针是能否掌握Ｃ语言的一个标志。指针极大地丰富了Ｃ语言的功能，同时，指针也是Ｃ语言中最为困难的一部分，在学习中除了要正确理解基本概念，还必须要多编程、上机调试。只要做到这些，指针也是不难掌握的。 ７.１指针的概念 在计算机中，所有的数据都是存放在存储器中的。一般把存储器中的一个字节称为一个内存单元，不同的数据类型所占用的内存单元数不等，如整型占2个单元，字符型占1个单元等。为了正确地访问这些内存单元，必须为每个内存单元编上号，根据一个内存单元的编号即可准确地找到该内存单元。内存单元的编号 也叫做地址。既然根据内存单元的编号或地址就可以找到所需的内存单元，所以通常也把这个地址称为指针。对于一个内存单元来说，单元的地址即为指针。在Ｃ语言中，允许用一个变量来存放指针，这种变量称为指针变量。因此，一个指针变量的值就是某个内存单元的地址或称为某内存单元的指针。 图7.1 内存单元的地址与内容 图7.1中，设有字符变量C，其内容为’K’(ASCII码为十进制数75)，C占用了011A 号单元(地址用十六进数表示)。设有指针变量P，内容为011A，这种情况称为P指向变量C，或说P是指向变量C的指针。 约定：“指针”是指地址，是常量，“指针变 量”是指取值为地址的变量。但常把指针变量简称为指针。定义指针的目的是为了通过指针去访问内存单元。 ７.２指针变量的定义和引用 ７.２.１指针变量的定义 变量的指针就是变量的地址。在Ｃ语言中，允许用一个变量来存放指针，这种变量称为指针变量。因此，一个指针变量的值就是某个变量的地址或称为某变量的指针。 为了表示指针变量和它所指向的变量之间的关系，在程序中用“*”符号表示“指向”，例如，i_pointer代表指针变量，而*i_pointer是i_pointer所指向的变量。如图7.2所示。 图7.2 指针变量 因此，下面两个语句作用相同： 让你不再害怕指针 前言:复杂类型说明 要了解指针,多多少少会出现一些比较复杂的类型,所以我先介绍 一下如何完全理解一个复杂类型,要理解复杂类型其实很简单,一 个类型里会出现很多运算符,他们也像普通的表达式一样,有优先 级,其优先级和运算优先级一样,所以我总结了一下其原则: 从变量名处起,根据运算符优先级结合,一步一步分析. 下面让我们先从简单的类型开始慢慢分析吧: int p; //这是一个普通的整型变量 int *p; //首先从P处开始,先与*结合,所以说明P是一 //个指针,然后再与int结合,说明指针所指向 //的内容的类型为int型.所以P是一个返回整 //型数据的指针 int p[3]; //首先从P处开始,先与[]结合,说明P是一个数 //组,然后与int结合,说明数组里的元素是整 //型的,所以P是一个由整型数据组成的数组 int *p[3]; //首先从P处开始,先与[]结合,因为其优先级 //比*高,所以P是一个数组,然后再与*结合,说明 //数组里的元素是指针类型,然后再与int结合, //说明指针所指向的内容的类型是整型的,所以 //P是一个由返回整型数据的指针所组成的数组 int (*p)[3]; //首先从P处开始,先与*结合,说明P是一个指针 //然后再与[]结合(与"()"这步可以忽略,只是为 //了改变优先级),说明指针所指向的内容是一个 //数组,然后再与int结合,说明数组里的元素是 //整型的.所以P是一个指向由整型数据组成的数 //组的指针 int **p; //首先从P开始,先与*结合,说是P是一个指针,然 //后再与*结合,说明指针所指向的元素是指针,然 //后再与int结合,说明该指针所指向的元素是整 //型数据.由于二级指针以及更高级的指针极少用 //在复杂的类型中,所以后面更复杂的类型我们就 //不考虑多级指针了,最多只考虑一级指针. int p(int); //从P处起,先与()结合,说明P是一个函数,然后进入 //()里分析,说明该函数有一个整型变量的参数 //然后再与外面的int结合,说明函数的返回值是 //一个整型数据 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和C++的精华所在，也是C和C++的一个十分重要的概念。 主要内容：指针的概念； 指针数据对象的定义； 指针运算； 指针数据对象的引用； 利用指针实现动态存储分配（动态数组）。 重点：指针的概念、动态存储分配。 一、指针的概念 1．什么叫指针 一个数据对象的内存地址称为该数据对象的指针。指针可以表示简单变量、数组、数组元素、结构体甚至函数。也即指针具有不同的类型，可以指向不同的数据存储体。例如： int *point1,a，b; double *point2[20]; …… point1=&a; point1 整型变量a point2[0] 双精度形数组 Point1 = &b; Point1 整型变量b 图6.1 指针示意 注意：指针中的内容是可以动态改变的，例如point1既可以指向变量a也可以指向变量b。2．指针的作用 1）能实现复杂的数据结构，例如数组、链表、队列和堆栈等； 2）能方便地表示和处理字符串； 3）能方便地实现动态存储分配； 如果一个程序或者一个函数出现使用需要大存储量的数据对象，采用动态存储分配可以提高内存的使用率，也即这些数据一般用预先定义的指针变量来表示，当实际使用时才临时申请实际的存储空间，使用完毕立即释放。指针变量所占的内存空间与所表示的数据对象的存储空间相比实在是微乎其微，因为它只是用来存放对应空间的首地址。 4）在函数之间进行数据的双向传递。 将形参定义成指针类型，对应的实参必须是某个数据对象的首地址，也即采用传地址的方式，这样就可以实现数据的双向传递。 3．指针类型 指针类型属于标准类型，其取值是所表示的数据对象的内存地址，所以其值域是内存地址集。指针类型用来定义各种类型的指针变量，其语法如下： <类型标识符> * 例如 int *表示整型指针类型，char *表示字符指针类型，等等。 二、定义指针变量 同其他变量一样，指针变量也必须“先定义后使用”，可以在函数外部定义全局的指针变量也可以在函数内部定义局部的指针变量。 1．语法 <类型标识符> *<标识符1>,*<标识符2>,……,*< 标识符n>; ;类型标识符：用来指明指针的类型，可以是基本类型，例如int,char,double等等，也可以是结构类型，例如结构体，文件等等。υ ;*：表示指针。υ ;标识符：指针数据对象的名字，可以是基本变量名、数组名、结构体变量名、函数名等。υ2．实例 （1）int *x, *y,z; 上面的语句定义了三个变量，其中z是整型变量，用来存放整数，x,y是整型指针变量，用来存放整型数据对象的内存地址，或者说用来表示整型数据对象。 z=5; x=&z; z中存放整数5，也即z的值是5；x中存放的是z的地址，我们可以用*x来表示z。x和z的关STEP7——ANY指针详解
结构体指针
如何透彻理解C语言中指针的概念
结构体的指针应用
指针和结构体练习题.
C语言通用数据类型链表的构造数据域为指针
C语言中不同的结构体类型的指针间的强制转换详解
指针在结构体中的应用.
指针(pointer)——C_C++的精髓
指针与结构体 上机
史上最牛逼的C++指针教学
VC++指针详解
第九章指针类型
C语言结构指针
第7章 指针数据类型及其应用
指针总结
C语言复习题指针结构体
指针的概念