指针变量

pascal语言中指针类型和动态数据结构 整型、实型、布尔型等各种简单类型和数组、记录、集合等各种结构类型的数据都属于静态类型的数据。所谓静态类型数据是指使用前必须在程序的说明部分给出描述这种数据的类型说明（TYPE语句）或变量说明（VAR语句），以定义这类数据占用内存空间的大小规模，使系统在程序的编译阶段能对这些变量进行内存空间的分配，空间一旦分配则不能在程序的执行过程中加以改变。现在讨论另一种类型的数据，这些数据和静态类型数据不同，它们无需在程序的变量说明部分对其进行说明，也就是系统在程序编译阶段不对这些变量分配内存空间，而是在程序的运行过程中根据需要用相应的命令动态地建立、分配内存空间，以至这种类型的数据占用内存空间的大小规模可以动态地发生变化，故称之为动态类型数据结构。 一、指针变量以及动态数据的产生 讨论动态类型数据是如何在程序的运行阶段动态地建立起来的，就要讨论与之有关的一种静态类型数据 指针。 指针类型属于静态的简单类型，但和整型、实型、字符型这些简单类型不同。首先整型、实型、字符型的变量单元中存放的是相应类型的数据，而指针类型变量单元中存放的是某种类型变量单元的地址，通过该地址可以找到这种类型的数据，所以称它是一个指针，而这种数据就是动态数据；其次整型、实型、字符型等类型都有规定的标准标识符integer、real、char等与之对应，而指针类型则没有相应的标准标识符。这是因为在动态数据产生的过程中，程序员关心的是指针指向一个什么类型的数据。所以，在Pascal程序说明部分定义指针类型时必须给出该指针类型变量所指向的数据类型，即该指针类型标识何种类型的变量。 如在程序的类型说明部分有： TYPE pint=^integer； pre=^real； 表明程序定义了两种指针类型pint和pre。pint用于标识整型的变量，pre用于标识实型的变量。 若在程序的变量说明部分有指针类型变量的说明： VAR p1，p2：pint； q：pre 表明程序定义了三个指针变量，p1和p2是pint类型的变量，q是pre类型的变量。在程序的编译阶段，同其它简单变量（整型、实型、字符型等）一样，系统要给它们分配空间，这就是前面所说的指针变量是静态变量。在内存空间分配之初，p1、p2和q变量单元还未定义，此时指针变量不指向任何一个内存变量单元，因为所需指向的动态数据单元还未产生，它们是在程序运行过程中利用p1、p2和q变量以及new过程语句动态地产生的。一旦有动态数据产生，则p1、p2变量单元中将存放动态产生的整型变量单元的地址，q变量单元中将存放动态产生的实型变量单元的地址。 动态数据的产生是系统在程序运行阶段执行过程语句new(<指针变量名>)时进行，所产生的动态数据单元用：“<指针变量名>^” 来命名： new(p1)：系统动态地产生整型变量单元，即动态地给一个整型变量分配内存单元，并将该单元的地址放入p1单元中。该整型变量单元命名为p1^，表明通过p1指针可访问这个单元的整型数据。 new(q)：系统动态地产生实型变量单元，即动态地给一个实型变量分配内存单元，并将该单元地址放入q单元中。该实型变量单元命名为q ^，表明通过q指针可访问这个单元的实型数据。 二、指针类型变量的应用以及动态数据的操作 下面讨论指针类型变量的应用，即如何将整型数据或实型数据等存放到动态产生的相应的内存变量单元中，并对这些单元进行必要的操作。 首先可以用赋值语句将一个指针变量的地址值赋给另一个指针变量，如： p2：=p1，表示将p1单元的地址值赋给p2，此时p2单元的内容也是指向某整型变量单元的地址值。 但p1：=q不行，因为在定义中可见两指针类型所标识的类型变量不同。 下面通过一个简单的例子看指针类型变量的应用： PROGRAM EX00(OUTPUT)； TYPE pint=^integer； pre=^real； VAR p：pint； q：pre； BEGIN NEW（p）； p^ ：=3； NEW（q）； q^ ：=4.5； q^：=q^＊ p^； WRITELN(q^)； DISPOSE（p）；DISPOSE（q） END. 最后语句DISPOSE（p）以及DISPOSE（q）为释放由p和q指针所指向的变量单元。 指针类型变量所指向的数据类型可以是整型，实型，字符型等简单类型，也可以是数组、集合、记录等结构类型。推而广之就有了链表、树结构等的产生及其应用。 如在程序说明部分有链表定义： TYPE Lp=^Litem Litem=RECORD int：integer； next：Lp END； 在该定义中，定义了指针类型Lp，用于标识Litem记录类型的变量。但我们注意到，在定义指针类型Lp时，Litem尚未定义，它的定义是在Lp的定义之后给出的。这种先使用后定义的情况在以上的链表定义中是允许的。 若在程序变量说明部分有： VAR L：Lp 则变量L 为一指针类型变量。在程序运行中，它的值将是一动态产生的记录型变量单元的首地址，即L 是指向记录型数据的指针变量。 若在程序中有： new(L)：系统动态地产生记录型变量单元，即动态地给一个记录型变量分配内存单元，并将所分单元的首地址放入L单元中。分配的记录型变量命名为L^，该记录型变量L^有两个域，一是整型数据域L^.int，一是指向另一记录型变量的指针域L^.next。 new(L^.next)：同上，系统动态地给一个记录型变量分配内存单元，并将所分单元的首地址放入L^.next单元中。分配的记录型变量命名为L^.next^，该记录型变量L^.next^ 同样有两个域，一是整型数据域L^.next^.int，一是指向另一记录型变量的指针域L^.next^.next。 接下来还可有new(L^.next^.next)，new(L^.next^.next^.next)……，一个链表数据结构就随之产生了。但因为链表是一个动态数据结构，它的长度，即链表结点的个数是不可预测的，所以不可能用以上的语句来产生链表的各结点。在以下产生整型单链表的程序中，使用了一个跟踪指针L，用循环的方法产生一个单链表： PROGRAM EX01(INPUT，OUTPUT)； TYPE Lp=^Litem； Litem=RECORD int：integer； next：Lp END； VAR head，L：Lp； i：integer； BEGIN NEW(head)；L：=head； i：=1； WRITE("请输入第"，i，"结点值：")； READLN（L^.int）； WHILE not eof DO BEGIN i：=i＋1； NEW（L^.next）；L：=L^.next； WRITE（"请输入第"，i，"结点值： "）； READLN（L^.int） END； L^.next：=nil； (＊以上为单链表的产生，以下为单链表的输出＊) L：=head； WHILE L^.next<>nil DO BEGIN WRITELN（l^.int）； L：=L^.next END END.

百度一下

寄存器变量可以是指针型，不过由于register变量使用的是硬件CPU中的寄存器，寄存器变量无地址，所以不能使用取地址运算符"&"求寄存器变量的地址。

应该找本书看看，这是最基本的概念。

1. 怎么将一组数组赋值给指针,比如, a[][3]={2,4,5,6,7,8,9,10,11} *p(3) 指针变量可以指向一维数组中的元素，也可以指向多维数组中的元素。 但在概念和使用上，多维数组的指针比一维数组的指针要复杂。1、二维数组的地址 二维数组可以理解为一个广义的一维数组，一个以一维数组为元素的一维数组。 例如定义一个数组：int a[3][4]={1,2,3,4,5,6,7,8,9,10,11,12}； 则数组a对应的元素为：a[0][0] a[0][1] a[0][2] a[0][3] …… 第0行 a[1][0] a[1][1] a[1][2] a[1][3] …… 第1行 a[2][0] a[2][1] a[2][2] a[2][3] …… 第2行 现在将第0行数组元素a[0][0]、a[0][1]、a[0][2]、a[0][3]组成数组a[0]，第1行数组元素a[1][0]、a[1][1]、a[1][2]、a[1][3]组成数组a[1]，第2行数组元素组成数组a[2]，则a[0]、a[1]、a[2]就是一维数组名，代表一个地址常量，分别指向每行的第0列元素，如图 7 7和图 7 8所示。那么a[0]+1指向第0行的第1个元素，a[1]+1指向第1行的第1个元素，所以称a[0]、a[1]、a[2]为列指针，对它们的增减1将移动1列元素。 图 7 8 二维数组中元素地址示意图 对于二维数组a来说，还可以把它看成是由a[0]、a[1]、a[2]这些“元素”组成的一维数组，如图 7 8所示。而a[0]、a[1]、a[2]又是由4个int型元素组成的数组，所以a+0指向a[0]数组的首地址（第0行元素的首地址），a+1指向a[1]数组的首地址（第1行元素的首地址），那么a+i指向第i行的首地址，所以a被看成是一个行指针，指针a的基类型是一个由4个int型数据构成的数组。由于a指向a[0],a+1指向a[1]，所以*a等价于a[0],*(a+1)等价于a[1],*(a+i)等价于a[i]，行指针*运算得到列指针。而a[0]+1指向第0行的第1个元素，a[1]+1指向第1行的第1个元素，那么*（a[0]+1）等价于a[0][1],*(a[1]+1)等价于a[1][1],*(a[i]+j)等价于a[i][j]，列指针*运算得到二维数组的元素值。 而a[i]又等价于*（a+i），所以*（a[i]+j）与*（*（a+i）+j）等价，都表示二维数组元素a[i][j]。对于二维数组a[M][N]中的任意一个元素a[i][j]，其地址可以表示为：（1）&a[i][j],(2)&a[0][0]+i*N+j,(3)a[i]+j等价于*（a+i）+j (4)a[0]+ i*N+j 对于二维数组a[M][N]中的任意一个元素a[i][j]，还可以表示成*（a[i]+j）、*（*（a+i）+j）、（*（a+ i）)[ j]、*（a[0]+ i*N+j）、*（&a[0][0]+i*N+j）等形式。 【例7- 8】通过数组元素的地址来引用二维数组元素。#include #include int main() { int i,j; int a[3][4]={1,2,3,4,5,6,7,8,9,10,11,12}; cout<<"输出二维数组a:"< 在指向行的指针前面加一个*运算，就转换为指向列的指针；反之，在指向列的指针前面加一个&运算，就成为指向行的指针。（2） *(a+i)和a[i]是等价的，但它们在各维数组中的含义不同：对于一维数组a,*(a+i)和a[i]是一个元素；而对于二维数组a,*(a+i)和a[i]则仍然是一个地址，*（*（a+i）+j）才是元素a[i][j],*(*(a+i+j)）也是元素，但它是a[i+j][0]元素。 2、二维数组的指针 同样还可以用指针变量来访问二维数组元素。由于二维数组的地址有行地址和列地址两种，所以和地址相对应的指针也有两种，分别为行指针和列指针。 （1）二维数组的列指针 列指针是指向具体元素的指针，又称一级指针，其定义和一般变量指针的定义是一样的。在例7.8程序中增加一行列指针定义语句：int *aPtr=a[0]； 或int *aPtr=&a[0][0] 将例7.8程序中输出数组元素的语句cout< uf06c 直接移动指针：cout< 在定义时，必须明确指出这个指针指向的一维数组有多少个元素。用行指针来处理二维数组，则行指针所指数组的长度等于二维数组的列数。 行指针定义的一般形式如下： （* ）[ ] 其中 即表示该指针指向的数组的长度。【例7- 9】通过行指针来引用二维数组元素。 #include int main() { int i,j; int a[3][4]={1,2,3,4,5,6,7,8,9,10,11,12}; int (*p)[4]； 定义一个指向一维数组（有4个整型元素）的指针变量 p=a; cout<<"请给出输出元素的下标值："< >i; cout<<"列标号："； cin>>j; cout<<"a["< 列标号：2 a[1][2]=7。 2. 怎么向指针数组中赋值 不可以 原因很简单 "one","two"是存在静态存储区的，这个地址中的值不能被修改。 *(p[1]+1)=getchar(); 运行这句，程序应该崩溃 也就是说这种声明：char *p[]={"one","two"}; 是不能修改其中指针指向地址中的值的，只能读取 而 char p[][5]={"one","two"}; 这种声明，变量则是存在栈上的，这时就可以 *(p[1]+1)=getchar(); 来修改 3. 数组可以赋值给指针吗 可以。 指针作为实体，是一个用来保存一个内存地址的计算机语言中的变量。 数组，是有序的元素序列。 若将有限个类型相同的变量的 *** 命名，那么这个名称为数组名。组成数组的各个变量称为数组的分量，也称为数组的元素，有时也称为下标变量。 数组名可以代表数组的首地址，num就是num数组的首地址，pn声明为一个指针变量，它的值直接指向（points to）存在电脑存储器中另一个地方的值，也就是个地址。因此num的值是可以赋值给pn的。 扩展资料： 数组使用规则 1.数组的类型实际上是指数组元素的取值类型。对于同一个数组，其所有元素的数据类型都是相同的。 2.数组名的书写规则应符合标识符的书写规定。 3.数组名不能与其它变量名相同。 4、只能给元素逐个赋值，不能给数组整体赋值。例如给十个元素全部赋1值，只能写为：static int a[10]={1,1,1,1,1,1,1,1,1,1}；而不能写为：static int a[10]=1；（请注意：在C、C#语言中是这样，但并非在所有涉及数组的地方都这样，数据库是从1开始。） 参考资料： 百度百科-数组 百度百科-指针。 4. 数组可以赋值给指针吗 可以。 指针作为实体，是一个用来保存一个内存地址的计算机语言中的变量。 数组，是有序的元素序列。若将有限个类型相同的变量的 *** 命名，那么这个名称为数组名。组成数组的各个变量称为数组的分量，也称为数组的元素，有时也称为下标变量。 数组名可以代表数组的首地址，num就是num数组的首地址，pn声明为一个指针变量，它的值直接指向（points to）存在电脑存储器中另一个地方的值，也就是个地址。因此num的值是可以赋值给pn的。 扩展资料： 数组使用规则 1.数组的类型实际上是指数组元素的取值类型。对于同一个数组，其所有元素的数据类型都是相同的。 2.数组名的书写规则应符合标识符的书写规定。 3.数组名不能与其它变量名相同。 4、只能给元素逐个赋值，不能给数组整体赋值。例如给十个元素全部赋1值，只能写为：static int a[10]={1,1,1,1,1,1,1,1,1,1}；而不能写为：static int a[10]=1；（请注意：在C、C#语言中是这样，但并非在所有涉及数组的地方都这样，数据库是从1开始。）

int a;int *p = &a;指针p是一个变量，里面存的是一个地址，这个地址是a的地址。通过取值运算符*就可以用p访问a。指针变量使用起来灵活，一个指针变量只占四个字节，但是它可以访问类似结构体，链表，数组等多数据集合，而且在访问这些变量的时候是对内存直接访问，执行效率更高，知识需要慢慢积累，用得多了你就知道指针的好处了。让指针指向下一个很简单：比如说int a[10] = {1,2,3};int *p = a; //那么现在p指向的就是数组a的第0个元素，*p的值就是1p++;//执行完这句p就指向了数组a的下一个元素 ，也就是数组a的第一个元素，*p的值就是2.

没有区别，指针就是指针变量

指针变量就是指那个变量保存的是一个指针，这个指针是指向一个内存空间的指针数组是指的一个数组，里面的每个元素都是一个指针变量

因为 p是指向a的地址、q是指向b的地址的~

指向常量的指针 是什么意思？举个例子（写代码）

*后面跟指针变量，意思是取该指针所指内存单元的数值；*P1 = *P2；意思应该是将P2所指内存单元的数赋给P1所指的内存单元；结果是P1和P2所指向的内存单元数据相等；

指针是C语言中广泛使用的一种数据类型。 可以说没有了指针后面得数据结构根本就没法构造了， 运用指针编程是C语言最主要的风格之一。利用指针变量可以表示各种数据结构； 能很方便地使用数组和字符串； 并能象汇编语言一样处理内存地址，从而编出精练而高效的程序。指针极大地丰富了C语言的功能。 学习指针是学习C语言中最重要的一环， 能否正确理解和使用指针是我们是否掌握C语言的一个标志。同时， 指针也是C语言中最为困难的一部分，在学习中除了要正确理解基本念，还必须要多编程，上机调试。只要作到这些，指针也是不难掌握的。还要一个很大的优点是，它可以申请动态内存，使用方便等。接触多了就知道了。

.....

枚举变量中花括号里的名字是编译者自己定义的，不是变量哦~它们只是一些整形数，是不可改变的。比如enum{a,b,c}。a,b,c对应的值是0,1,2。当然，也可以对它们初始化，比如enum{a=3,b,c,d=7,e}。a,b,c,d,e对应的值为3,4,5,7,8。（注意：值不能重复！）既然不是变量，当然不能放指针变量啦~要注意的是，花括号里可以随便写，但不能用整形数！

bool型变量：if(!var) int型变量： if(0==var)float型变量： const float epsinon = 0.00001; if ((x >= - epsinon) && (x <= epsinon) 　 指针变量：if(var==null)

直接用字符串常量赋值给指针变量，例如：char * str = "http://c.biancheng.net";用字符数组初始化指针变量，例如：char str[10] = "hello"; char * p = str;用strcpy函数将字符串复制到指针变量所指向的内存空间，例如：char a[10]; strcpy(a, "hello");用gets函数从键盘输入字符串到指针变量所指向的内存空间，例如：char a[10]; gets(a);注意：直接用字符串常量赋值给指针变量时，不能修改字符串的内容，否则会出错；而其他三种方法可以修改字符串的内容。

int i, a[10], *p1, *p2；（1）p1=&i； 用整形变量的地址给基类型为整形的指针变量赋值（2）p2=a; p2=a+3; 用数组名为指针变量赋予地址；（3） p1=p2； 通过指针变量给指针变量赋值；

p，q，r都是指针，所以是4. printf("%d %d %d ",sizeof(*p), sizeof(*q), sizeof(*r)); 这才是你要的结果。

不一定。可以把变量地址强转成指针的类型。如：void*p；inta；p=（void*）&a；

结构体｝后面可以定义结构体变量、数组、指针类型。a是一个数组，可以隐式转换为指针，不是指针变量，可以作为指针来使用。

#include <iostream>#include <string>using namespace std;int main( ){ struct Student { int num; string name; char sex; float score; }; Student stu; Student *p=&stu; stu.num=10001; stu.name="KYO"; stu.sex="F"; stu.score=89.5; cout<<p -> num<<" "<<(*p).name<<" "<<(*p).sex<<" "<<(*p).score<<endl; return 0;}

基本上都不对，路还长。结构体定义只是用来编译时参考的，它本身不需要运行。所以注意区分编译时和运行时。程序运行的是从main函数，当然中间可以调用其它函数。函数之外的全局变量或者函数内的静态变量是在全局区也称静态区，但会被编译器放到main函数开头处初始化。函数内的非静态局部变量是在运行到的时候才申请内存，是在栈区。malloc是向堆区内存申请内存块。struct len* a; //a是一个指针变量，也是局部非静态变量，在栈区，，它是用来指向struct len类型量的。但是没有初始化指向谁，是一个野指针。a = (struct len*)malloc(sizeof(struct len));malloc(sizeof(struct len))向堆区申请一块内存，把该块内存的首地址赋给a。于是栈区的指针变量a的值就是堆区某块内存的首地址，也即a指向堆区某块内存。程序内存分区详情自己再百度相关专题吧，很多博客的。

如果是指向结构体成员的指针，那么指针不能是结构体类型的指针，而应该是具体的结构体成员类型的指针，否则没有什么意义。你后面的问题完全没看懂，不知道你说的if条件到底是什么条件。

借用楼上的例子，结构体也可以有构造函数:struct MyStruct{void* m_pBuffer;ULONG m_ulBufferSize; MyStruct() : m_pBuffer( NULL ), m_ulBufferSize( 0 ) { } MyStruct(void* lpBuffer, UINT ulSize) : m_pBuffer( lpBuffer ), m_ulBufferSize( ulSize ) { }}

其本质实是没有区别的。都是这种类型的指针。唯一的区别在于。p1不指向任何地址。p2指向了某段有效的内存。链表中，定义一个指针，是为了让其记录下首地址，遍历完成后，head依然是head，不然的话，你用head去遍历，到最后 你就只剩下一个节点了 。 防止内存泄漏。

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

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

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

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

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

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

本来懂了，被你搞懵逼了

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

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

这个是因为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类型的空间组成，何必再去动态开配一个空间呢！}

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

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

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

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

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

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或是你所定义的结构体。

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;}

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

本来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); }

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

1、既然是指针变量，那么将一个变量的地址值赋值给该指针变量即可！2、至于具体讲一个地址值赋值给指针有两种方法：一种就是用取地址符&来操作内嵌变量，另一种就是通过采用malloc函数动态开辟内存并将内存地址值赋值给指针变量。3、举例说明：定义int型指针变量int * p；和int型变量int a；那么将a的地址值赋值给p：p=&a；另一种方式是动态方式：p = （int*）malloc（size（int））；

你可以把指针变量当做 int 变量一样来理解

00

皆可

char *p="Turbo C";——创建一个常字符串Turbo C，并将首地址(即T的地址)赋给char *型指针(用文字说“字符型指针”也没错)p。

指针类型 11.1 指针 11.2 单链表 11.1 指针 指针是通过地址来访问变量的一种特殊的数据类型，属于动态的数据结构，它可以在需要时产生，用完后则又可以取消或回收，以减少占用的内存空间。指针变量与其他类型的变量不同，它占有的不是数据，而是地址。 由于动态数据结构的变量是在程序执行过程中动态生成的，所以不能预先予以说明，无法预先给这些变量起名字，访问时也无法通过名字直接输出或显示，而只能用指针得到其地址，然后间接访问。 1、定义指针类型 在Turbo Pascal中，指针变量用来存放某个存储单元的地址，即指针变量指向某个存储单元。一个指针变量仅能指向某一种类型的存储单元，这种数据类型是在指针类型的定义中确定的，称为指针类型的基类型。指针类型定义如下： 类型名＝^基类型名； 例如：type q=^integer; var a,b,c:q; 说明：q是一指向整型存储单元的指针类型，其中"^"为指针符。a,b,c均定义为指针变量，分别可以指向一个整型存储单元。 上例也可用变量说明为： var a,b,c:^integer; 指针也可以指向有结构的存储单元。 例如：type person=record name:string[10]; sex:(male,female); age:20..70 end; var pt:^person; pt为指向记录类型person的指针变量。 2、动态变量 应用一个指针指向的动态存储单元即动态变量的形式如下： 指针变量名^ 例如：p^、q^、r^ 指针变量p和它所指向的动态变量p^之间有如下关系： 以下语句把整数5存放到p所指向的动态变量p^中去： p^:=5; 以下语句把p所指向的p^中的值赋给整型变量i： i:=p^; 如果指针变量p并未指向任何存储单元，则可用下列赋值语句： p:=nil; 其中nil是保留字，表示“空”，相当于C语言里面的null 3、对动态变量的操作 在Turob Pascal程序中，动态变量不能由var直接定义而是通过调用标准过程new建立的。过程形式为： new(指针变量名); 如果有下列变量定义语句： var p:^integer; 仅仅说明了p是一个指向整型变量单元的指针变量，但这个整型单元并不存在，在指针变量p中还没有具体的地址值。在程序中必须通过过程调用语句：new(p);才在内存中分配了一个整型变量单元，并把这个单元的地址放在变量p中，一个指针变量只能存放一个地址。在同一时间内一个指针只能指向一个变量单元。当程序再次执行new(p)时，又在内存中新建立了一个整型变量单元，并把新单元的地址存放在p中，从而丢失了旧的变量单元的地址。 为了节省内存空间，对于一些已经不使用的现有动态变量，应该使用标准过程dispose予以释放。过程形式为：dispose(指针变量名)；为new(指针变量名)的逆过程，其作用是释放由指针变量所指向的动态变量的存储单元。例如在用了new(p)后在调用dispose(p)，则指针p所指向的动态变量被撤销，内存空间还给系统，这时p的值为 nil。 4．需要注意之处 1、P与P^的区别 P是指向该动态变量的指针变量名，P^则称为动态变量或标志变量。P的值是P^的首地址，P^的值为与基类型相同的一个值。 2、定义后及时分配存储单元 定义了一个指针变量后，并没有为该指针分配动态存储单元，此时的P的值无定义，调用P^则会产生运行错误。若想使该指针可用，可以对指针赋值，也可以通过NEW（）过程分配存储单元。 3、使用后及时收回存储单元 指针使用后，不会自动归还占用的存储空间，应及时使用DISPOSE（）过程来释放P^所占用的存储单元，以免浪费有限的存储空间． 11.2 单链表 单链表的数据类型可定义如下： type dlb=^node; node=record data:datatype; next:dlb; end; 例1 连续输入一序列整数,组成链表（并以动态的形式把它们记录下来）,当输入的数为-1时,停止输入,然后把输入的整数按相反的顺序输出. program lianbiao; type link=^data; data=record num:integer; next:link; end; var p,q:link; i:integer; begin q:=nil; readln(i); while i<>-1 do begin new(p); with p^ do begin num:=i; next:=q; end; q:=p; readln(i); end; while p<>nil do begin write(p^.num:6); p:=p^.next; end; readln; end.

给你个思路吧，写个平方出来，后面的自己模仿//求两个数的平方，成功返回0，不成为返回-1。int function(double *pNum1, double *pNum2){ if(NULL == pNum1 || NULL == pNum2) return -1;//判断指针是否为空 *pNum1 = (*pNum1) * (*pNum1); *pNum2 = (*pNum2) * (*pNum2); return 0;}

不能直接访问，但可通过公有成员进行访问，还有，当进行动态联编的时候，私有已经和公有没什么区别了

A错，p应改成*pB错，x后应有,C错，*p=x;应改成p=&x;D错，*p=&x;应改成p=&x;

非p

呵呵，要解决你问的这个问题其实很简单，你只是混淆了*的两个作用，为了让你理解，我改变了一种说法让你更容易理解，看下面的例子：(1)int*p;//用意在于定义一个指针变量，int*可以说是个整体，它为p申请了一个四个字节的内存空间，此时*只是一个指针运算符的作用；(2)inti=10,*p=&i;cout<<*p<<endl;//但是这个时候的*p是取p中的值，*是一个间接访问运算符，它间接地访问p中所存地址中的数值，因此输出的是一个数值10；综上可知：*有两个作用，一是指针运算符，二是间接访问运算符。

存储地址的变量

从这里来看是没有区别,因为本身就没有区别. 但是为什么会有这样的2种写法,在实际应用中,都必然会应用到.举一个不大恰当的例子,水果刀和菜刀,都是刀,都能切菜切水果吧(我们仅考虑功能),我们在需要时自然的会做出适当的选择,仅仅是在适当情况下做出适当的选择而已,最优解而已.

变量指针就是变量的指针，比如：int *p,t;p=&t;其中*p是指针变量，这个指针变量就是变量t的指针。

指针变量是变量，用于存放指针，或者说存放地址变量指针是指针，是变量的地址指针变量可以存放变量的指针，存放了变量的指针的指针变量可以访问那个变量的存储区，间接地修改或读取它的值

定义一个指针，例如：*i，*i是一个指针，i是这个指针的指针变量

指针的存储类型是指针变量本身的存储类型。指针说明时指定的数据类型不是指针变量本身的数据类型，而是指针目标的数据类型。在计算机内存中，每一个字节，都有一个编号，称为地址。程序打印出的是起始地址，连续存储。内存单元的地址成为指针，专门用来存放地址的变量，称为指针变量。指针一般形式：<存储类型><数据类型><指针变量名>。指针介绍指针，是C语言中的一个重要概念及其特点，也是掌握C语言比较困难的部分。指针也就是内存地址，指针变量是用来存放内存地址的变量，在同一CPU构架下，不同类型的指针变量所占用的存储单元长度是相同的，而存放数据的变量因数据的类型不同。所占用的存储空间长度也不同。有了指针以后，不仅可以对数据本身，也可以对存储数据的变量地址进行操作。指针描述了数据在内存中的位置，标示了一个占据存储空间的实体，在这一段空间起始位置的相对距离值。在C/C++语言中，指针一般被认为是指针变量。以上内容参考：百度百科——指针

这是正确的。先看一下解释吧，变量的指针就是变量的地址。存放变量地址的变量是指针变量。即在C语言中，允许用一个变量来存放指针，这种变量称为指针变量。因此，一个指针变量的值就是某个变量的地址或称为某变量的指针。可能有些难以理解，再附一段程序，1234567891011#include<stdio.h>#include<stdlib.h>int main(){ int a=10; int *p; p=&a; printf("the pointer p address %x ",p); printf("the pointer p value %d ",*p); return 0;}下面是运行结果，可以看到第一行输出了指针数据p，也就是变量a的地址。采用十六进制显示。第二行输出了目标标量a的值，也就是10。这里用存取内容运算符"*"对目标变量a读写数据。解释的不知道能不能懂，可以自己多看一些别的书，可能有更好的解释吧

一个变量的地址成为该变量的指针.例如,地址2000是变量i的指针.如果有一个变量专门用来存放另一变量的地址(即指针),则它称为"指针变量".假设定义了一个变量i_pointer(变量名可任意取),用来存放整形变量的地址.可以通过下面语句将i的地址(2000)存放到i_pointer中.i_pointer=&i;这时,i_pointer的值就是2000(即变量i所占用单元的起始地址)上述的i_pointer就是一个指针变量.指针变量就是地址变量,用来存放地址,指针变量的值是地址(即指针).请区分"指针"与"指针变量"这两个概念.例如,可以说变量i的指针是2000,而不能说i的指针变量是2000.指针是一个地址,而指针变量是存放地址的变量.希望对你有帮助.

是一个“指针”，指向某个变量。

你可以直接赋值语句来完成赋值语句的方法 int a; int *p; p=&a; 你的意思应该是给a赋值，你可以scanf("%d",p),再直接点就是*p=3.

#include<stdio.h>main(){ int a, *p; p = &a; // 将a的内存地址赋给指针p scanf("%d", a); printf("%d ", &p)}

可以，只是不同语言的表现形式和实现方式不同，但是思想上是一致的。

要让一个指针变量指向数组中的一个汉字，可以先定义一个存储汉字的字符数组，然后用指针变量指向该数组中的一个元素，例如：scsschar name[] = "张三";char *p = &name[0];这里定义了一个存储汉字名字的字符数组name，然后用指针变量p指向该数组的第一个元素，也就是汉字“张”的地址。要输出该汉字，可以使用printf()函数，指定格式符为%c，例如：perlprintf("%c", *p);这样就可以输出该汉字了。如果要在数组中存储多个汉字人名，可以使用字符数组，例如：javachar names[][4] = {"张三", "李四", "王五"};这里定义了一个二维字符数组names，每个一维数组存储一个汉字人名，每个一维数组的长度为4，其中包括三个汉字和一个结束符。如果需要存储更长的汉字名字，需要相应增加每个一维数组的长度。

地址

我看的《c与指针》这本书中写到这样定义应该不对，应该是P的初始化的地方有问题，p没有一个一个确定的地址，无法将p所包含的的地址读出，并将p所指向的地址里面的值改变为8；建议你将p先初始化为一个确定的地址！

指针变量和普通变量类似，其值是可变的。存放地址的变量称为指针变量，指针变量是一种特殊的变量，它不同于一般的变量一般变量存放的是数据本身，而指针变量存放的是数据的地址，如果一个指针变量存放的是某个对象的地址，则称这个指针变量指向该对象。指针变量区别指针是语言的精华部分，通过利用指针，我们能很好地利用内存资源，使其发挥最大的效率，有了指针技术，我们可以描述复杂的数据结构，对字符串的处理可以更灵活，对数组的处理更方便，使程序的书写简洁高效清爽，但由于指针对初学者来说，难于理解和掌握需要一定的计算机硬件的知识做基础，这就需要多做多练多上机动手，才能在实践中尽快掌握成为的高手。

“*”表示这是个指针变量，也表示这个指针的地址上的内容比如int *i;表示i是指针，其中int *可以作为一个整体，比如(int *)0x214FF835,把0x214FF835直接强制转换为存放int的地址。“&”表示引用当前变量地址。比如int i=14;\假设i的地址为0x214FF835;printf ("%d",i);\输出结果：14printf ("%x",&i);\输出结果：214ff835同时引用指针指向的内容还有一个方法比如int *i;i=(int *)malloc (sizeof (int));\分配内存并把内存地址放入指针i[0]=100;\下标引用，当成数组使用printf ("%d",*i);\输出结果：100同时函数由于只有一个返回值，因此采用传递地址参数为多数人所用比如int myfunc (int *a,int *b);\表示这两个是指针变量传递时就直接引用变量地址比如int i,j;myfunc (&i,&j);\到时函数里就可以直接对i和j进行修改，无须返回，这里的&i和&j表示只传递了i和j的地址，因此任myfunc杀和剐最后再附带介绍变参法（变参指函数参数数量不固定，比如常用的scnaf和printf就是典型的变参）比如int newfunc (int a,...);\到时利用a来获取参数main (){ int i,j,k,l,m,n; newfunc (i,j,k,l,m,n); return 0;}这时newfunc可以用&a[x]来调用剩下的参数，但记住入参方向这里的&a[x]中&a表示引用了当前位置，由于入参时参数是放在一起的（因此变参不要用fastcall等入参法），剩下的x表示a的地址偏移（单向），如果意图向另一边偏移，可以直接用指针加减比如&a++;\表示存放a的地址加上sizeof (int)*1，因为a是int指针&a--;\表示存放a的地址减去sizeof (int)*1但由于是直接的指针操作，可能会被编译器判错上面这些例子应该让你清楚什么时候用“*”什么时候用“&”了吧，希望对你有帮助。 int j = 9;int *i = &j;//定义指针i，并通过取地址符"&"赋值*i=10;//这个时候通过*实际上*i与j是同一个变量。所以j的值为10;不是说什么时候用哪个，你要先理解它们的意义才得。

可以阿，只针变量也是变量阿

*后面跟指针变量，意思是取该指针所指内存单元的数值；*P1=*P2；意思应该是将P2所指内存单元的数赋给P1所指的内存单元；结果是P1和P2所指向的内存单元数据相等；

对指针变量的定义包括三个内容：(1)指针类型说明，即定义变量为一个指针变量；(2)指针变量名；(3)变量值(指针)所指向的变量的数据类型。其一般形式为：类型说明符*变量名；其中，*表示这是一个指针变量，变量名即为定义的指针变量名，类型说明符表示本指针变量所指向的变量的数据类型。例如：int*p1;表示p1是一个指针变量，它的值是某个整型变量的地址。或者说p1指向一个整型变量。至于p1究竟指向哪一个整型变量，应由向p1赋予的地址来决定。再如：int*p2;/*p2是指向整型变量的指针变量*/float*p3;/*p3是指向浮点变量的指针变量*/char*p4;/*p4是指向字符变量的指针变量*/应该注意的是，一个指针变量只能指向同类型的变量，如P3只能指向浮点变量，不能时而指向一个浮点变量，时而又指向一个字符变量。

这里有一个误区，指针变量作为一个变量只能存储一个指针而已，不能存储任何类型的变量。例如，int * p;这里的p只能保存一个指针，而且只能是指向int类型的变量的地址。为了实现可变类型的指针，通常可以定义void类型的指针。void * p；此时，p可以保存任何类型的变量的地址，而通过类型转换来访问地址里面的内容。例如，int a =1 ;p = &a;