++p->x在C语言中表达什么意思

这两者作为函数参数，还是有很大的区别的，我说说自己的理解。如:typedefstructA{inta;...}A;//定义结构体AvoidFunc(Aa);//通过结构体变量传参voidFunc(A*pA);//通过结构体指针传参调用函数时，因为函数参数要临时存放到栈中，若结构体变量作为参数，则需要生成一个结构体A的副本，将其存放到栈中;而结构体指针作为变量，只需将指针pA存放到栈中即可，提高了程序的空间效率。其次，结构体指针作为函数参数:可以在函数中通过该指针引用结构体，当在函数中修改了结构体的成员变量后(如:pA->a=0)，指针pA所指向的结构体本身也被改变了。不同的是，当结构体变量作为函数参数:在函数中可通过变量直接使用结构体，但要注意的是，如果在函数中修改了结构体的成员变量后(如:a.a=0)，结构体本身并未发生变化，只是副本被改变。

一个结构体变量的指针就是该变量所占据的内存段的起始地址。可以设一个指针变量，用来指向一个结构体变量，此时该指针变量的值是结构体变量的起始地址。指针变量也可以用来指向结构体数组中的元素。 指向结构体变量的指针引用结构体变量中的成员下面通过一个简单例子来说明指向结构体变量的指针变量的应用。例 指向结构体变量的指针的应用。#include <iostream>#include <string>using namespace std;int main( ){struct Student//声明结构体类型student{ int num;char sex;float score;}; Student stu;//定义Student类型的变量stuStudent *p=&stu;//定义p为指向Student类型数据的指针变量并指向stustu.num=10301;//对string变量可以直接赋值stu.sex=′f′;stu.score=89.5;cout<<stu. num<<″ ″<<″ ″<<stu.sex<<″ ″<<stu.score<<endl;cout<<p -> num<<″ ″<<(*p).name<<″ ″<<(*p).sex<<″ ″<<(*p).score<<endl;return 0;} 程序运行结果如下：10301 Wang Fun f 89.5 (通过结构体变量名引用成员)10301 Wang Fun f 89.5 (通过指针引用结构体变量中的成员)两个cout语句输出的结果是相同的。为了使用方便和使之直观，C++提供了指向结构体变量的运算符->，例如p->num表示指针p当前指向的结构体变量中的成员num。p->num 和(*p).num等价。同样，p->name等价于(*p).name。也就是说，以下3种形式等价：① 结构体变量.成员名。如stu.num。② (*p).成员名。如(*p).num。③ p->成员名。如p->num。“->”称为指向运算符。请分析以下几种运算：p->n 得到p指向的结构体变量中的成员n的值。p->n++ 得到p指向的结构体变量中的成员n的值，用完该值后使它加1。++p->n 得到p指向的结构体变量中的成员n的值，并使之加1，然后再使用它。 用结构体变量和指向结构体变量的指针构成链表链表是一种常见的重要的数据结构。链表有一个“头指针”变量，以head表示，它存放一个地址。该地址指向一个元素。链表中的每一个元素称为“结点”，每个结点都应包括两个部分：一是用户需要用的实际数据，二是下一个结点的地址。可以看到链表中各元素在内存中的存储单元可以是不连续的。要找某一元素，可以先找到上一个元素，根据它提供的下一元素地址找到下一个元素。可以看到，这种链表的数据结构，必须利用结构体变量和指针才能实现。可以声明一个结构体类型，包含两种成员，一种是用户需要用的实际数据，另一种是用来存放下一结点地址的指针变量。 例如，可以设计这样一个结构体类型：struct Student{int num;float score;Student *next;//next指向Student结构体变量};其中成员num和score是用户需要用到的数据，相当于图7.8结点中的A,B,C,D。next是指针类型的成员，它指向Student类型数据（就是next所在的结构体类型）。用这种方法就可以建立链表。每一个结点都属于Student类型，在它的成员next中存放下一个结点的地址，程序设计者不必知道各结点的具体地址，只要保证能将下一个结点的地址放到前一结点的成员next中即可。下面通过一个例子来说明如何建立和输出一个简单链表。例 建立一个简单链表，它由3个学生数据的结点组成。输出各结点中的数据。 #define NULL 0#include <iostream>struct Student{long num;float score;struct Student *next;};int main( ){Student a,b,c,*head,*p;a. num=31001;a.score=89.5;//对结点a的num和score成员赋值b. num=31003;b.score=90;//对结点b的num和score成员赋值c. num=31007;c.score=85;//对结点c的num和score成员赋值head=&a;//将结点a的起始地址赋给头指针heada.next=&b; //将结点b的起始地址赋给a结点的next成员b.next=&c; //将结点c的起始地址赋给b结点的next成员c.next=NULL; //结点的next成员不存放其他结点地址p=head; //使p指针指向a结点do{cout<<p->num<<″ ″<<p->score<<endl; //输出p指向的结点的数据p=p->next; //使p指向下一个结点} while (p!=NULL); //输出完c结点后p的值为NULLreturn 0;} 请读者考虑：①各个结点是怎样构成链表的。②p起什么作用？本例是比较简单的，所有结点(结构体变量)都是在程序中定义的，不是临时开辟的，也不能用完后释放，这种链表称为静态链表。对各结点既可以通过上一个结点的next指针去访问，也可以直接通过结构体变量名a,b,c去访问。动态链表则是指各结点是可以随时插入和删除的，这些结点并没有变量名，只能先找到上一个结点，才能根据它提供的下一结点的地址找到下一个结点。只有提供第一个结点的地址，即头指针head，才能访问整个链表。如同一条铁链一样，一环扣一环，中间是不能断开的。

第一个问题： 1、 首先要知道字节序，一般来说，windows系统是小端字节序，即对于多字节数据，低位数据存放在低地址，如整数0x1234，在内存中顺序从低到高低址为0x34 0x12。%d是以长整形的形式输出，将从低址开始截取结构体前4个字节，即1785225581是结构体变量B在内存中开始内容（我在测试时输出和你不一样，是短整形，可能是编译器的关系吧）。 2、C是结构体的指针，而不是字符指针，在进行C+1这样的指针运算时，是按结构体的大小为单位移动指针。还有就是，你的几次输出都是以不同的格式，因此三者并不矛盾。第二个问题： A=B确实执行将B复制到A的内存空间，从第二A的输出可以看出，地址还是A的地址，内容变成了B的内容。

你的理解是对的。形参是结构体变量的，你对该结构体的所有修改都不会影响到实参，因为形参是实参的一个完整拷贝。形参是结构体指针的，你对该结构体的修改直接影响实参的结构体数据。因为形参和实参都指向同一个内存区块。注意：形参是一个指针，如果只改变指针本身，则不影响实参。

这里的b成员是指float类型变量的指针，next成员是指struct B类型变量的指针。float、struct B都只是一种数据类型，是不占用内存的，故没有指针；只有float或struct B定义的变量才会有指针（如：float a；a为变量就占内存，就有地址即指针）

structa{inta;intb;}*a;//之前这段代码只是定义一个结构体指针，并没有初始化，有可能指向NULL，也有可能指向其它未知地址，这时直接操作指针就是操作指针所指向的内存，这块内存有只能是系统区的，有可能在常量区的，反正就是本程序不应该访问的内存，所以内存错误。要给指针分配空间后，才可以用指针进行操作分配空间一种是定义这样一个结构体变量，再把指针指向其地址二种是手动malloc一个区域分配了空间再执行指针操作，就不会出这样的内存错误了

图1就是定义了3个结构体类型的指针变量，是正确的。 图2错误，因为先是将3个变量定义成结构体变量，后又定义成结构体指针变量。如果删掉图2}后的3个变量的定义，则两个图是一个意思。

本来C＃就不方便用指针，你为什么要用指针？？（用指针要用不安全代码，如果真要用，请百度下 C# 不安全代码 。。。）下面是用引用，而建的结构体： public struct AAA { public string A; public string B; public string C; public List<BBB> BB; //C#语法初始化不能在结构体里面，所以在解析里面初始化 }; public struct BBB { public string a; public string b; public string c; public dd d; };用引用的函数: 如下请参考。。。。 public bool ParserXmlConfig(string xml_file, ref AAA AA)//启动解析函数要使用引用 { XmlDocument doc = new XmlDocument(); XmlReaderSettings settings = new XmlReaderSettings(); settings.IgnoreComments = true;//忽略注释,后面有判断是否为元素节点，可不用 doc.Load(@xml_file);//读XML文件 XmlNode rootElement = doc.SelectSingleNode("BBB");//解析根节点 return ParseBBB(rootElement,ref BB); }

voidRegList(LB*L)//初始化线性表(建立头结点,指针域置为空){L=(LB*)malloc(sizeof(LB));L->next=NULL;}改成指针的指针调用的时候RegList(&k);就行了。voidRegList(LB**L){*L=(LB*)malloc(sizeof(LB));(*L)->next=NULL;}

对于标题中的问题答案是肯定的。如果第一个成员是数组的话，指向的也是数组第一个元素的地址。对于第三个问题，你说的“该指针”不太清楚，我就按我的理解来说：如果指针是指向结构体，那么指针加1的话，指针就会向后移动结构体大小个字节的距离；如果你说的是指向数组第一个元素的指针，那么加1的话，指针会向后移动数组元素大小个字节的距离。下面是我的测试代码，希望能帮到你:#include#includetypedefstructmystruct{charc[10];inti;}s;intmain(){ss;strcpy(s.c,"hello");s.i=10;s*p=&s;printf("%p %p ",p,&(p->c[0]));printf("%p %p ",&(p->i),++p);return0;}

因为int是一个值类型的，所以不能直接赋值给p（p是int指针类型）。因此二楼加括号是对的。通过取p的地址转化成对应的指针，然后直接把b赋值给它。另外一种方法：a->p=&b; //把b的地址赋值给a中的p指针。

struct ST{ int a; char *p; },你要给p赋值，则你要给他的变量必须是全局的或者new出来的。如：ST s; s.p = &m; 这个m必须要有自己的空间,不能是局部变量。或者char *m=new char[1]; s.p=m;这个时候m是new出来的。 p是不需要开辟空间的.“fdslaf”是常量，就像m=3；3你还用分配个空间。。。最好不要这么用

c语言 取结构体地址c语言 取结构体地址,结构体赋值，对用不用取地址符有些困惑？芝士的草原转载关注10点赞·2025人阅读满意答案vhjkjkol2014.11.15采纳率：56% 等级：7已帮助：510人从本质上来说，stu.num、stu.name、stu.score都是变量，变量有两部分构成，即变量地址和变量的内容，直接写变量就是取它的内容。scanf语句是将输入的数据存入地址中，所以scanf()里的后半段里应该写地址，因而要在stu.num前加取地址运算符“&”。stu.name是数组名，数组的数组名里的内容就是该数组的首地址，简而言之，stu.name就是地址，所以不用加“&”。而之所以stu.name可以直接写而float数组stu.score[]要一个一个赋值，是因为stu.name是字符数组，字符只占一个字节，即stu.name[0]和stu.name[1]之间无空隙，输入字符串，程序会将一个个字符填入字符数组。而float型占4个字节(32位机)，这样stu.score[0]和stu.score[1]间就会有空隙，比如说你输入两个数字，一个占1个字节，可能第二个数字就写在了stu.score[0]里面，在输出时只能输出stu.score[0]而无法输出后面的数。此外，还有可能就是一个数字一半在score[0],一半在score[1],系统就会报错并关闭程序。所以float、int等超过一个字节的不能像char型数组那样直接读取，只能一个一个取地址进行赋值你可以用sizeof来看各种数据所占字节数。用法：inti;i=sizeof(char);printf("%d",i);输出的就是char型所占的字节数了，char可以改成int、float或是你所定义的结构体。

结构体指针就是指向一个结构体的指针，就跟变量指针一个意思，变量名就是给某个结构体类型定义的一个名字。比如Inta；a就好比一个结构变量名；int*p；p=a；p就好比结构体指针。如果还不懂的话，你可以先看看书上的结构体那章，仔细看，很简单的

选B原因是，B的写法就是错的，指针类型应该用->,就像C一样用

用typedef用来对结构体再定义一个类型名这种定义方法定义的结构体，应该这样使用：①structsstr;②tstr;这两种效果是一摸一样的，你可以试试看，希望能帮到你。

struct a{ int age;} a1;不能指向结构体a，但是可以是指向a1结构体变量及age。结构体变量和成员分配了内存所以才可以指向

一般情况下，“指向”是指指针的目标，如有int a=4,*p=&a;，那么常说变量a是指针p的指向；不过这要看看前后文，有时核心意思可能有些许差别。当一个指针指向结构体变量时，这个指针中就存放了这个结构体变量中的第一个成员的第一个元素的地址，并承载这个结构体的结构信息，诸如这个结构体变量在内存中占有多少个字节、都有些什么类型的成员以及它们的存储发生等……

结构体变量的指针是不能做函数形式参数的，因为如果结构体变量的指针，作为函数形式参数，那么有些事情可能就不成立了，如果这些事情不成立的话，也就是结构体变量的指针，做了函数形式参数，是没有任何意义的。

结构体是一个数据类型，结构体指针是一个指向这个数据类型的指针变量，它的本质是存放着指向一个该种结构体数据的地址，它的类型就是该结构体指针。

所谓结构体数组，是指数组中的每个元素都是一个结构体。在实际应用中，C语言结构体数组常被用来表示一个拥有相同数据结构的群体，比如一个班的学生、一个车间的职工等。结构体可以存储不同的数据类型，将他们互相联系起来。结构体数组可以连续存储多个结构体，和数组作用相似。比如想定义同一个最小外接矩形的四个坐标值，并给予这个矩形一个特征编号。当需要存储多个最小外接矩形的信息时，就需要动态申请一个结构体数组。struct 结构体类型名｛类型名 成员名；类型名 成员名；……｝，先声明结构体类型，再定义结构体变量名。声明结构体类型，不分配空间，定义结构体类型变量，就要分配内存空间。扩展资料：结构体数组指针类型：一个结构体变量的指针就是该变量所占据的内存段的起始地址。可以设一个指针变量，用来指向一个结构体变量，此时该指针变量的值是结构体变量的起始地址，指针变量也可以用来指向结构体数组中的元素。1、类型一：指向结构体变量的指针引用结构体变量中的成员。2、类型二：用结构体变量和指向结构体变量的指针构成链表，链表是一种常见的重要的数据结构。链表有一个“头指针”变量，以head表示，它存放一个地址。该地址指向一个元素。链表中的每一个元素称为“结点”，每个结点都应包括两个部分：一是用户需要用的实际数据，二是下一个结点的地址。链表中各元素在内存中的存储单元可以是不连续的。要找某一元素，可以先找到上一个元素，根据它提供的下一元素地址找到下一个元素。这种链表的数据结构，必须利用结构体变量和指针才能实现。可以声明一个结构体类型，包含两种成员，一种是用户需要用的实际数据，另一种是用来存放下一结点地址的指针变量。参考资料来源：百度百科—结构体类型—数组

++pt->x=20;(++pt)->x=20;pt++->x=10;(pt++)->x=10;

从内存使用的特点上来说结构体占用的内存等于各个结构体成员所占内存的总和，共用体类型等于其中占用最大内存那个成员所占用的内存，枚举类型事实上就是定义的特殊整数，而这个整数类型有固定的取值范围，但是他仍然会占用一个整形变量的内存。从对变量的使用上来说对应于以三个类型内存的使用策略，对每一个结构体成员的读写操作，都是可以而有意义的，而对于共用体而言，则只有其中的一个成员具备这样的意义。枚举类型你可认为就是一个特殊的整数类型。

比如一个结构体structNode{intx;int*y;};在main函数中intmain{Nodenode1;node1.x=5;node->y=5;//用箭头访问指针变量return0;}

定义该结构的一个变量，给这个变量的成员c赋值就行了，e.g:#include struct a{int b;char *c;};void main(){ char *pTest = "Hello World!"; struct a tA ; tA.c=pTest; printf("%s ", tA.c);}运行截图:

我也有疑问，这种类型的指针怎么初始化呢？DriverExtension = new *PDRIVER_EXTENSION; //这样对吗？

(1)、scanf的用法，格式后的参数都必须是地址，name是数组名，本身就是数据，age和sex都是整型数据，必须使用取地址符&；(2)、p是struct student*类型，stu是stu[3]这个数组的第一个元素的地址，p指向第一个元素，因此ABC都是对的，D错在把(int*)变量值赋值给(struct student*)变量，如果有个强制转换则不会错，因为age是结构体第一个变量，其地址就是结构体变量的地址。(3)、与（2）类似，是指针间的赋值，必须保证左右操作数的指针类型是一致的。由于n是结构体sk的第一个变量，因此其地址与结构体变量地址相同，可以强制转换得到正确的地址。(4)、c是一个二维数组，p是一个指向数组的指针，因此p的*运算都是得到一个数组，**运算才能取到数组中的值。只有D是**运算。

所谓结构体数组，是指数组中的每个元素都是一个结构体。在实际应用中，C语言结构体数组常被用来表示一个拥有相同数据结构的群体，比如一个班的学生、一个车间的职工等。结构体可以存储不同的数据类型，将他们互相联系起来。结构体数组可以连续存储多个结构体，和数组作用相似。结构体数组指针类型：一个结构体变量的指针就是该变量所占据的内存段的起始地址。可以设一个指针变量，用来指向一个结构体变量，此时该指针变量的值是结构体变量的起始地址，指针变量也可以用来指向结构体数组中的元素。

第二个程序，空间都没有分配就初始化赋值，这根本就是在给系统添乱嘛。

这个是因为go语言进行了自动转换，当你Zi类型的a.show()时，go会自动将a Zi装换为a *Zi,你现在的操作均为对a本身的操作，b.show(）不用解释了吧，这个就是自然的调用，同样的如果你要是定义一个func (zi Zi) show2() {}方法，使用b.show2()调用时，go语言会自动的将b *Zi转换为b Zi类型，这个时候会拷贝一份进行操作，不会影响原来Zi结构体中的值。

typestructStu{intstu}stu;typedefstructMyStu{stu*t;intmystu;}mystustudent;intmain(){mystudent*p=malloc(sizeof(structMystu));//这里面你只是为mystudent这个结构体开辟了一个空间，由p来指向这个空间，但是我们要确定一点，就是这个空间里面存放了一个指针（它仅仅开辟了一个指针的空间和一个int大小的空间），至于这个指针指向的地址呢？？？？？你还没有分配呢！！，下面必须要进行分配了stu*t=malooc(sizeof(structStu));其实这是很没必要的！因为我们完全可以用普通类型来实现typedefMystu{stut;intmystu;}这样的话p指针开放的空间就是由stul类型的t结构体空间和一个int类型的空间组成，何必再去动态开配一个空间呢！}

结构体成员运算符。->指针运算符。1、如果结构体中的成员均为一般变量（包括结构体变量），则使用“.”，如果成员变量为指针（不管指向什么，包括结构体），则使用“->”。2、如果定义了结构体数组指针，则可分别使用“.”和“->”，区别在于指针带下标时，以是数组形式访问，此时用“.”，如果不带下标（或使用偏移），此时用“->”。如：struct myT{ int i;

你只是声明了一个结构体指针，并没有分配一个结构体的内存阿，这个指针指向的值是未确定的。改成下面这样就可以了。struct as{ int a; int b;}a;void main(){ struct as *pa = &a; pa->a=1; printf("%d ",pa->a);}

第一种写法：(*a).p=&b;.的优先级高于*，(*pointer)两边的括号不能少。如果去掉括号写作*pointer.memberName，那么就等效于*(pointer.memberName)，这样意义就完全不对了。第二种写法：a->p=&b;->是一个新的运算符，习惯称它为“箭头”，有了它，可以通过结构体指针直接取得结构体成员；这也是->在C语言中的唯一用途。结构体是一种数据类型，是一种创建变量的模板，编译器不会为它分配内存空间，就像 int、float、char 这些关键字本身不占用内存一样；结构体变量才包含实实在在的数据，才需要内存来存储。下面的写法是错误的，不可能去取一个结构体名的地址，也不能将它赋值给其他变量。扩展资料：用指针引用结构体变量成员方式总结与技巧：一、(*指针变量名).成员名注意，*p 两边的括号不可省略，因为成员运算符“.”的优先级高于指针运算符“*”，所以如果 *p 两边的括号省略的话，那么 *p.num 就等价于 *(p.num) 了。因为指针变量 p 指向的是结构体变量第一个成员的地址，即字符数组 name 的首地址，所以 p 和 (*p).name 是等价的。“等价”仅仅是说它们表示的是同一个内存单元的地址，但它们的类型是不同的。指针变量 p 是 struct 型的，而 (*p).name 是 char* 型的。所以在 strcpy 中不能将 (*p).name 改成 p。用 %s 进行输入或输出时，输入参数或输出参数也只能写成 (*p).name 而不能写成 p。二、直接用：指针变量名->成员名来代替，它们是等价的。“->”是“指向结构体成员运算符”，它的优先级同结构体成员运算符“.”一样高。p->num 的含义是：指针变量 p 所指向的结构体变量中的 num 成员。p->num 最终代表的就是 num 这个成员中的内容。参考资料来源：百度百科-结构体

struct stu{char name[20];long number;float score[4];} ;再定义指向结构体类型变量的指针变量：struct stu *p1, *p2 ;定义指针变量p 1、p 2，分别指向结构体类型变量。引用形式为：指针变量→成员；

因为指针要指向所声明的类型的地址.(指针本身也有地址,)

#include "stdio.h"#include "string.h"#define N 50struct infoma{ char fname[N]; char lname[N]; int allwd;};struct infoma funname(struct infoma namet){ printf("please putin you first name: "); gets(namet.fname); printf("please putin you last name: "); gets(namet.lname); return namet;}struct infoma allname(struct infoma namet){ namet.allwd=strlen(namet.fname)+strlen(namet.lname); return namet;}void putout(struct infoma namet){ printf("%s %s,your name have %d words ",namet.lname,namet.fname,namet.allwd);}main(){ struct infoma guy; guy=funname(guy); guy=allname(guy); putout(guy);}

#include <stdio.h>int main() { struct my { int a; int b; int c; }; struct my ss= {1,2,3}; struct my *ptr=&ss; //此处 printf("%d ",ptr->a); return 0;}

本来懂了，被你搞懵逼了

通过结构体指针变量获得其结构体变量的成员变量的一般形式如下：(*结构体指针变量). 成员变量其中“结构体指针变量”为结构体指针变量，“成员变量”为结构体成员变量名称，“.”为取结构体成员变量的运算符。另外C语言中引入了新的运算符“->”，通过结构体指针变量直接获得结构体变量的成员变量，一般形式如下：结构体指针变量-> 成员变量其中“结构体指针变量”为结构体指针变量，“成员变量”为结构体成员变量名称，“->”为运算符。

结构名来表示结构成员的话用.结构指针来表示结构成员的话用->俩个都是用来指向结构成员

是的可以这样分析：首先 指针存放的是内容所在的地址，至于是什么类型的指针决定的是内容的结构是什么样，对存放的地址没有影响。因此typedef struct _A{ int i; int j;} A;void main(){A a;//假设变量a的首地址是0x03406666A *p = &a;//那么p的值就是0x03406666*p就是a本身}

struct a{int *d;int b;};a *m=new a;a.d = new int;

1、结构体数组也是数组，只不过数组元素是结构体而已。所以，指向结构体数组的指针和一般数组指针没有区别，指向什么位置那就由你决定了。若你已经定义了一个结构体类型Yourstruct，再执行下面语句：struct Yourstruct structArray[10],*p;p = structArray; //p指向数组中的第1个结构体变量。++p; // p指向数组中的第2个结构体变量。2、如果是在结构体中定义了指针，每个结构体变量都有自己的存储空间，结构体成员指针指向何处也是由你来决定的。

当然可以。char *s;数据溢出。

给结构体Birds的指针变量Bird分配动态内存

结构体指针成员所指向变量，这个说法理解起来有点困难。从字面意思上看断句，有如下几种可能：首先定义一个包含所有可能情况的结构体：struct test{ int a; int *p;};struct test t1, *t2;1 结构体/指针成员/所指向的变量。结构体中有指针成员，然后要访问这个结构体成员指向的变量值。那么可以*(t1.p)这种方式对p取值。2 结构体指针/成员/所指向变量。这种情况有两种方法可以访问：*(t2->p)或者*(*(t2).p)效果是一样的。3 描述有误，实际为：结构体指针所指向/成员变量。同样有两种方法可以使用：t2->p或者(*t2).p

一般情况下，“指向”是指指针的目标，如有inta=4,*p=&a;，那么常说变量a是指针p的指向；不过这要看看前后文，有时核心意思可能有些许差别。当一个指针指向结构体变量时，这个指针中就存放了这个结构体变量中的第一个成员的第一个元素的地址，并承载这个结构体的结构信息，诸如这个结构体变量在内存中占有多少个字节、都有些什么类型的成员以及它们的存储发生等……

1、结构体中的指针和结构体中的其他变量没有什么不同，结构体中的一个成员变量而已。只是这个变量是指针类型，和其他普通指针一样使用。2、看变量名和结构体名称，你发的这种应该一般用在链表的实现中，这个Node结构体就是链表中的一个节点，然后结构体中定义一个指针变量next，用于指向下一个节点。

M->m是非法的，M.m才是正确的！M.m只是一个整形的指针，那就要看你指向哪一个整形的数了。