指针和指针变量的区别?

指针是C语言的精华部分，通过利用指针，我们能很好地利用内存资源，使其发挥最大的效率。有了指针技术，我们可以描述复杂的数据结构，对字符串的处理可以更灵活，对数组的处理更方便，使程序的书写简洁，高效，清爽。但由于指针对初学者来说，难于理解和掌握，需要一定的计算机硬件的知识做基础，这就需要多做多练，多上机动手，才能在实践中尽快掌握，成为C的高手。过去，我们在编程中定义或说明变量，编译系统就为已定义的变量分配相应的内存单元，也就是说，每个变量在内存会有固定的位置，有具体的地址。由于变量的数据类型不同，它所占的内存单元数也不相同。若我们在程序中做定义为：int a=1,b=2;float x=3.4, y = 4 . 5 ;double m=3.124;char ch1="a", ch2="b";让我们先看一下编译系统是怎样为变量分配内存的。变量a,b是整型变量，在内存各占2个字节；x,y是实型，各占4个字节；m是双精度实型，占8个字节；ch1,ch2是字符型，各占1个字节。由于计算机内存是按字节编址的，设变量的存放从内存2000单元开始存放，则编译系统对变量在内存的安放情况为图6-1所示。变量在内存中按照数据类型的不同，占内存的大小也不同，都有具体的内存单元地址，如变量a在内存的地址是2000，占据两个字节后，变量b的内存地址就为2002，变量m的内存地址为2012等。对内存中变量的访问，过去用scanf("%d%d%f",&a,&b,&x)表示将数据输入变量的地址所指示的内存单元。那么，访问变量，首先应找到其在内存的地址，或者说，一个地址唯一指向一个内存变量，我们称这个地址为变量的指针。如果将变量的地址保存在内存的特定区域，用变量来存放这些地址，这样的变量就是指针变量，通过指针对所指向变量的访问，也就是一种对变量的“间接访问”。设一组指针变量pa、pb、px、py、pm、pch1、pch2，分别指向上述的变量a、b、x、y、m、ch1、ch2，指针变量也同样被存放在内存，二者的关系如图6-2所示：在图6-2中，左部所示的内存存放了指针变量的值，该值给出的是所指变量的地址，通过该地址，就可以对右部描述的变量进行访问。如指针变量pa的值为2000，是变量a在内存的地址。因此，pa就指向变量a。变量的地址就是指针，存放指针的变量就是指针变量。

指针是地址,指针变量就是针对存放地址的变量;

指针变量是地址

语言中，指针是一种类型，被称为“指针类型”。指针类型描述的是一个地址，这个地址指向内存中另外一个对象的位置。简单地说，指针表示的是它所指向对象的地址。1、比较point,*point,&point三者的区别对于int*point；point：是指针变量，其内容是地址量。*point：是指针变量的目标变量，即指针指向的那个变量，其内容是数据。&point：是指指针变量本身所占据的存储地址。2、指针与数组用指针和数组名在访问内存中的数据时，他们的表现形式是等价的，因为他们都是地址量。数组名表示整个数组的首地址，可以看作是固定地址的指针，不能被赋值。数组名无须赋初值，而指针在使用前必须赋初值。3、字符指针和字符串字符串是一个字符数组，字符串以‘"结束。printf函数的%s格式输出字符时，是从给定的地址开始，到遇上第一个‘"字符时结束。对字符指针初始化，是将字符串的首地址赋给指针。4、指针型函数所谓指针型函数，即返回值是指针（地址）的函数。5、多级指针指向指针的指针（**p）就是二级指针，指向指针的指针的指针（***p）是3级指针。多级指针类似于间接寻址。6、指向函数的指针C语言中的函数名表示函数的首地址，即函数执行的人口地址。定义形式：[存储类型][数据类型标示符](*指向函数的指针变量名)()；例子：int(*fun)();//指向函数的指针，int*fun()；//指针型函数，注意（*fun）括号不能少7、动态指针当需要一大片内存的时候，最好使用动态分配。使用malloc函数：void*malloc(size_tsize)。例子：int*pn=malloc(10*sizeof(int));double*pd=malloc(10*sizeof(double));

根据你的定义，使用LinkList定义的变量是指针变量，而加上*即LinkList *C表示的是指向指针的指针，表示二级指针变量。你的合并函数是一个没有返回值的函数，所以你在函数体内更改C要达到更改实参的效果，你必须传入实参的地址。如果是一级指针，C接收实参指向的对象地址，如果此时在函数体内对C进行赋值，只是改变了函数体内C的指向，实参还是指向原来的地址。函数内是改变不了实参C本身的指向，只有传入实参C变量本身的地址，那么形参就要定义指向指针的变量来接收实参。以上是一种方法，另外一种方法就是通过函数返回值，返回新合并的链表的头。那函数类型就可以改为：LinkList MergeList(LinkList a, LinkList b)。这可以多练习好好理解一下。

指针是C语言的精华部分，通过利用指针，我们能很好地利用内存资源，使其发挥最大的效率。有了指针技术，我们可以描述复杂的数据结构，对字符串的处理可以更灵活，对数组的处理更方便，使程序的书写简洁，高效，清爽。但由于指针对初学者来说，难于理解和掌握，需要一定的计算机硬件的知识做基础，这就需要多做多练，多上机动手，才能在实践中尽快掌握，成为C的高手。过去，我们在编程中定义或说明变量，编译系统就为已定义的变量分配相应的内存单元，也就是说，每个变量在内存会有固定的位置，有具体的地址。由于变量的数据类型不同，它所占的内存单元数也不相同。若我们在程序中做定义为：int a=1,b=2;float x=3.4, y = 4 . 5 ;double m=3.124;char ch1="a", ch2="b";让我们先看一下编译系统是怎样为变量分配内存的。变量a,b是整型变量，在内存各占2个字节；x,y是实型，各占4个字节；m是双精度实型，占8个字节；ch1,ch2是字符型，各占1个字节。由于计算机内存是按字节编址的，设变量的存放从内存2000单元开始存放，则编译系统对变量在内存的安放情况为图6-1所示。变量在内存中按照数据类型的不同，占内存的大小也不同，都有具体的内存单元地址，如变量a在内存的地址是2000，占据两个字节后，变量b的内存地址就为2002，变量m的内存地址为2012等。对内存中变量的访问，过去用scanf("%d%d%f",&a,&b,&x)表示将数据输入变量的地址所指示的内存单元。那么，访问变量，首先应找到其在内存的地址，或者说，一个地址唯一指向一个内存变量，我们称这个地址为变量的指针。如果将变量的地址保存在内存的特定区域，用变量来存放这些地址，这样的变量就是指针变量，通过指针对所指向变量的访问，也就是一种对变量的“间接访问”。设一组指针变量pa、pb、px、py、pm、pch1、pch2，分别指向上述的变量a、b、x、y、m、ch1、ch2，指针变量也同样被存放在内存，二者的关系如图6-2所示：在图6-2中，左部所示的内存存放了指针变量的值，该值给出的是所指变量的地址，通过该地址，就可以对右部描述的变量进行访问。如指针变量pa的值为2000，是变量a在内存的地址。因此，pa就指向变量a。变量的地址就是指针，存放指针的变量就是指针变量。

这是指针与数组可以互换的关系了，比如int buf[10]; int *ptr = buf; 所以*ptr = buf[0]; *(ptr+1) = buf[1];也可以表示ptr[0] = buf[0]; ptr[1] = buf[1];所以说在scanf函数里，传入的是一个地址，而ptr[i]明显是这个地址的值，所以要加个取地址符&。

要想学好C,C++，必须学好指针。。

指针变量，顾名思义首先是一个变量，专门用来存放地址的。如果说指针和指针变量严格来说的话，指针就是地址的意思，但是一般我们习惯于将指针变量叫做指针。一个指针变量占4个字节的大小（32位机）。里面存放的就是一个其他变量的地址。通过这个地址就能访问响应的变量了

变量指针：指向的数据为变量的指针，如char *p。与此相对的是常量指针，如const char* p。指针变量：类型为指针的变量，如char *p。与此相对的是指针常量，如char* const p。

指针就是保存对象地址的好牌。一级指针:比如你知道小明的家、在一栋楼里面的门牌号。你就可以直接找到这个门牌号，而找到小明了。别人也可以通过这个门牌号，找到小明。小明也可以通过这个门牌号，告诉别人自己家的位置。通过门牌号=找到小明(门牌号)二级指针:就比如物业的登记薄，登记薄里就有小明家，对应的门牌号。通过登记薄，找到门牌号=找到小明(登记薄，门牌号)

在C语言中：1.普通指针：*p指向一个值，本身存的是其地址；2.指向指针的指针：*（*p）指向一个值，这个值是个地址，所以也就是上面说的指针，指针的指针本身存的还是个地址；以下均是以上两种指针的变种：char*p，1变形，指向字符或指向字符串或指向一维字符数组的指针，指向的是字符的地址或一维数组的首元素；char（*p）[N]，行指针，2变形，指向的是二维数组的首地址，也就是上面所说的char*p；int(*p)()，函数指针，1变形，指向的是某函数，本身存的是该函数的入口地址其实就两类，区分时就看指针指向的是值还是指针

指针指向数组元素时，可以对指针进行以下运算： 加一个整数(用+或+=)， 减一个整数(用-或-=)，自加运算，如p++，++p自减运算，如p--，--p 两个指针相减，只有p1和p2都指向同一数组中的元素时才有意义)。

指针指向的是一个地址,但这个地址里面可能是一个变量,也可以是个常量,或者是其它类型...

指针变量是一个存地址的变量，赋值是只能传地址(跟int型只能赋值整型一样的)

可以的。 在pc上你设置一个指针等于2000跟设置它等于0实际上是一样的

int **p;char **p;等等都是一个指向指针的指针变量。。

变量的指针，其含义是指该变量的地址。C语言用变量来存储数据，用函数来定义一段可以重复使用的代码，它们最终都要放到内存中才能供 CPU 使用。数据和代码都以二进制的形式存储在内存中，计算机无法从格式上区分某块内存到底存储的是数据还是代码。当程序被加载到内存后，操作系统会给不同的内存块指定不同的权限，拥有读取和执行权限的内存块就是代码，而拥有读取和写入权限（也可能只有读取权限）的内存块就是数据。CPU 只能通过地址来取得内存中的代码和数据，程序在执行过程中会告知 CPU 要执行的代码以及要读写的数据的地址。扩展资料：在C语言中，允许用一个变量来存放指针，这种变量称为指针变量。指针变量的值就是某份数据的地址，这样的一份数据可以是数组、字符串、函数，也可以是另外的一个普通变量或指针变量。现在假设有一个 char 类型的变量 c，它存储了字符 "K"（ASCII码为十进制数 75），并占用了地址为 0X11A 的内存（地址通常用十六进制表示）。另外有一个指针变量 p，它的值为 0X11A，正好等于变量 c 的地址，这种情况我们就称 p 指向了 c，或者说 p 是指向变量 c 的指针。参考资料来源：百度百科-指针

指针变量的值的含义是：指针变量存放的是地址值。任何一个指针变量，无论是什么类型的指针变量，其占用内存空间的大小都是4个字节，即32位二进制。

B

int *p = &num 这句是声明，初始化的时候*就是一种类型。*p = 9;这句是赋值，和声明不一样的，*代表取到p的值，就是给p指向的值赋值。int *p = &num这种形式不好理解，你可以写成 int * p = &num这种形式。

以下每一行都可以定义一个指针变量的：char *p1;int *p2;float *p3;double *p4;char **p5;…………

您好，这样的：一、字符串指针变量的说明和使用字符串指针变量的定义说明与指向字符变量的指针变量说明是相同的。只能按对指针变量的赋值不同来区别。对指向字符变量的指针变量应赋予该字符变量的地址。如： char c,*p=&c;表示p是一个指向字符变量c的指针变量。而： char *s="C Language";则表示s是一个指向字符串的指针变量。把字符串的首地址赋予s。请看下面一例。main(){　　char *ps;　　ps="C Language";　　printf("%s",ps);　　}　　运行结果为：　　C Language　　上例中，首先定义ps是一个字符指针变量， 然后把字符串的首　　地址赋予ps(应写出整个字符串，以便编译系统把该串装入连续的一　　块内存单元)，并把首地址送入ps。程序中的： char *ps;　　ps="C Language";等效于： char *ps="C Language";　　输出字符串中n个字符后的所有字符。　　二、字符指针变量的运算　　main(){　　char *ps="this is a book";　　int n=10;　　ps=ps+n;　　printf("%s ",ps);　　}　　运行结果为：　　book　　在程序中对ps初始化时，即把字符串首地址赋予ps，当ps= ps　　+10之后，ps指向字符“b”，因此输出为"book"。　　main(){　　char st[20],*ps;　　int i;　　printf("input a string: ");　　ps=st;　　scanf("%s",ps);　　for(i=0;ps[i]!="";i++)　　if(ps[i]=="k"){　　printf("there is a "k" in the string ");　　break;　　}　　if(ps[i]=="") printf("There is no "k" in the string ");　　}本例是在输入的字符串中查找有无‘k"字符。三、字符串指针作为函数参数的使用。要求把一个 字符串的内容复制到另一个字符串中，并且不能使用strcpy函数。函　　数cprstr的形参为两个字符指针变量。pss指向源字符串，pds指向目标字符串。表达式： (*pds=*pss)!=`"　　cpystr(char *pss,char *pds){　　while((*pds=*pss)!=""){　　pds++;　　pss++; }　　}　　main(){　　char *pa="CHINA",b[10],*pb;　　pb=b;　　cpystr(pa,pb);　　printf("string a=%s string b=%s ",pa,pb);　　}在上例中，程序完成了两项工作：一是把pss指向的源字符复制到pds所指向的目标字符中，二是判断所复制的字符是否为`"，若是则表明源字符串结束，不再循环。否则，pds和pss都加1，指向下一字符。四、使用字符串指针变量与字符数组的区别用字符数组和字符指针变量都可实现字符串的存储和运算。 但两者是有区别的。在使用时应注意以下几个问题：1. 字符串指针变量本身是一个变量，用于存放字符串的首地址。而字符串本身是存放在以该首地址为首的一块连续的内存空间中并以‘"作为串的结束。字符数组是由于若干个数组元素组成的，它可用来存放整个字符串。2. 对字符数组作初始化赋值，必须采用外部类型或静态类型，如： static char st[]={“C Language”};而对字符串指针变量则无此限制，如： char *ps="C Language";3. 对字符串指针方式 char *ps="C Language";可以写为： char *ps;　　ps="C Language"; 而对数组方式： static char st[]={"C Language"};不能写为： char st[20]; st={"C Language"};而只能对字符数组的各元素逐个赋值。从以上几点可以看出字符串指针变量与字符数组在使用时的区别，同时也可看出使用指针变量更加方便。前面说过，当一个指针变量在未取得确定地址前使用是危险的，容易引起错误。但是对指针变量直接赋值是可以的。因为C系统对指针变量赋值时要给以确定的地址。因此， char *ps="C Langage";或者 char *ps; ps="C Language";都是合法的。

不可以。

对；存放地址的变量称为指针变量。指针变量是一种特殊的变量，它不同于一般的变量，一般变量存放的是数据本身，而指针变量存放的是数据的地址；

指针定义类型是为了取值及指针运算。一、指针的本质为内存地址。不管什么类型的指针，其本质都是内存地址。二、定义指针类型，可以更方便的取值。不管定义什么指针，保存什么样的地址，其目的都不是为了获取到这个地址值，而是为了访问地址上的数据。定义了指针类型，就可以很方便的取得数据。如果指针p类型为long*型，那么当使用*p取值时，就是取p值这个地址上，连续4个字节的数据值。而如果p类型为char*型，那么使用*p就是在p这个地址上的一个字节数据。三、定义指针类型，方便指针运算。使用指针，最常用的操作除取值为，就是指针的移动，也就是加减运算。通过指针加减，可以很方便的访问相邻或者间接相邻的同类单元。同样的p+1,不同指针移动的实际内存字节数不同，其值为sizeof(指针指向类型)。即对于type*p;p+n的实际偏移地址值为sizeof(type)*n。

指针变量坟地址百型变量和指针型变量，地址型的指度针指向变量后变量数值不便例：a=10,若把b指向a的地址变量，那麽内b也=10，指针型变量就是说，a已经占了这块内容存，所以就是a=10,b若指向a将不可能=10

C语言中有两种非常有用的运算符++和--，分别称为递增和递减运算符，对变量执行加1或减1操作，且运算结果仍赋给该变量。递增、递减运算符和负号一样都是单目运算符，统称单项算术运算符。指针变量本身储存的是物理地址。使用*运算符可以取得该物理地址对应的值。连续使用两个*，就可以操作指向指针的指针变量。例如：printf("%d",(*(*p1))++);printf("%d",++(*(*p2)));

定义方法：数据类型 *指针变量名;如定义一个指向int型变量的指针——int *p;则我们可以继续写如下代码——int a = 4;p = &a;printf("%d", *p);在这里，我们定义了一个变量a，我们把它理解为内存空间连续的4个字节（int型占用4字节），则这4个字节的空间保存着一个数4。&是取地址符号，即把变量a的地址（即这4个字节的首地址）赋给指针p（记住指针p的类型和变量a的类型要保持一致，否则的话，要进行类型转换）。这样子，指针p就保存着变量a的地址。我们如果把指针p当做内存空间里面另外一个连续的4个字节，那么这4个字节保存的数就是变量a的地址。printf("%d",*p)和printf("%d",a)的结果是一样的。这里的*是取变量符号（与&刚好作用相反，通过变量的地址找到变量），与定义时int *p的*号作用不同（定义时的*表示该变量是个指针变量，而非是取它指向的变量）。指针在C语言学习中是一个很重要的部分，在将来数据结构中也会大量用到，你可以多看看书上的例题来掌握它。推荐你翻阅谭浩强著的《C程序设计》第10章。希望我的回答对你有帮助，祝你好运。

就和变量和常量的区别是一样的指针变量 这个指针可以改变值指针常量 指针本身是不能改变的。 比如int a[10];//定义一个数组int *p=a;这个是指针变量。 可以重新赋值 p++, p=&a[5];这些都可以而int * const p=a;这个是指针常量 p值不能更改 只能指向a

在C++中，指针用得比较多，对于里面众多的指针用法，不免弄得有些糊涂，自从我从图书馆里借到一本谭浩强教授主编的《C++面向对象程序设计》后，才帮我理清了思路。现把部分内容展现给大家，希望对大家有所帮助。C++程序设计重要基础就是类和对象，对象指针是很重要的一部分，包括指向对象的指针、指向对象成员的指针、this指针、指向对象的常指针、指向常对象的指针等。1、指向对象的指针定义：对象空间的起始地址就是对象的指针。说明：在建立对象时，编译系统就为每个对象分配一定的存储空间以存放其成员，不过注意，在一般情况下不同对象的数据存储单元中存放的数据成员是不相同，而不同对象的函数代码却是相同的，也就是说，它们的函数代码是共享的。这时我们可以定义一个指针变量用来存放对象的指针。定义指向类对象的指针变量的一般形式是：类名 *对象指针名；如对于与个Time类对象，我们可以有：Time t;Time *p;p=t;我们就可以通过对象指针访问对象和对象的成员，假如所定义的类中有数据成员hour、minute、sec,成员函数有gettime()，则(*p).hour 即为p指向对象中的hour成员，相当于t.hour(*p).gettime() 即为p指向对象中的成员函数gettime(),相当于t.gettime()也可以用如下形式：p-hour 和 p-gettime()和上面是等价的。2、指向对象成员的指针(1)指向对象数据成员的指针在C中我们学过指向普通变量的指针变量，在C++中定义指向对象数据成员的指针变量的方法和定义指向普通变量的指针变量方法相同，其一般形式为：数据类型名 *指针变量名；如：int *p;p=t.hour; //将对象t的数据成员hour的地址赋给p，p指向t.hour(2)指向对象成员函数的指针定义指向对象成员函数的指针变量和定义指向普通函数的指针变量不同。在定义指向普通函数的指针变量时我们可以这样定义：void (*p)();p=fun;(*p)(); //调用fun函数然而编译系统要求在将函数地址赋给指针变量时必须满足三个条件：函数参数类型及个数要匹配函数返回值的类型要匹配所属的类要匹配显然在上面的p与类是无关的。为了满足第三条，我们可以为指针指定类，故定义指向对象成员函数的指针变量一般形式为：数据类型（类名::*指针变量名）（参数表列）；可以让指针指向公用的成员函数，如：void (Time::*p)(); //定义指向Time类对象成员函数的指针变量pp=Time::gettime; //把Time类的公用成员函数gettime()地址赋给指针变量p(t.*p)(); //调用Time类对象t的成员函数gettime()注意：因为成员函数不存放在对象空间中，多个同类对象共享此成员函数代码，所以在将成员函数的入口地址赋给指针变量是应写成：指向对象成员函数的指针变量=类名::成员函数名；在成员函数名后面没有"()",如果写成p=Time::gettime()是错误的。[nextp3、this指针在每个成员函数中都包含了一个特殊的指针，称为this，它是指向本类对象的指针，它的值是当前被调用成员函数所在对象的起始地址。之所以有这个指针，是因为为了保证同类的不同对象的成员函数引用的是指定对象中的数据成员，它是系统自动实现的。如定义一个求体积的函数int box::vol(){return(height*width*length);}假如已经定义了对象t，当调用成员函数t.vol()时，编译系统就把对象t的起始地址赋给this指针，于是在成员函数引用数据成员时，根据指针this就可以引用到对象t的数据成员。所以C++把上面的函数处理成int box::vol(){return(this-height*this-width*this-length);}由于this的值是当前被调用成员函数所在对象的起始地址，所以可以写成int box::vol(){return((*this).height*(*this).width*(*this).length);}所以在调用成员函数t.vlo()时，实际的调用方式为t.vol(t),不过对象t的地址传给this指针是由系统自动完成的，不需人为加上。#p#副标题#e#4、指向对象的常指针将指向对象的指针变量声明为const型且进行处始化，这样指针值始终保持为其初值，不能改变其指向。如：Time t1(8,8,8),t2;Time *const p=t1; //常指针p指向对象t1p=t2; //试图改变p的指向，非法由上面我们可以看出定义指向对象的常指针的一般形式为：类名 *const 指针变量名=对象的起始地址；注意：指向对象的常指针变量的值不能改变，但可以改变它所指向对象中的数据成员的值。常指针一般用作函数的参数，这样就不允许在函数执行过程中改变指针变量的值，使其始终保持指向原来的对象。5、指向常对象的指针变量首先回顾一下指向常变量的指针变量，其一般形式为：const 类型名 *指针变量名；如：const char *p;如果一个变量已经被声明为常变量，那么只能用指向常变量的指针变量去指向它，而不能用一般的指针变量。另外，指向常变量的指针变量除了可以指向常变量外，还可以指向未被声明为const的变量，但也不能通过该指针改变其值。例如：char c="a" //定义字符变量c，未声名为constconst char *p; //定义指向常变量的指针变量pp=c; //p指向字符变量c*p="b"; //非法c="b"; //合法说明：上例中，指针变量p指向字符变量c，并不说把c也声明成常变量，而只是说在通过指针变量引用c时，c具有常变量的特征，其值是不能改变的，但c仍然是一个普通变量。在指向常变量的指针中，关于函数形参的指针类型有几点值得注意：如果函数形参是非const型指针变量，实参只能用指向非const型指针；如果函数形参是指向const型变量的指针，实参则可以是const型的或非const型的指针变量。换句话说就是指向常变量的指针可以指向const和非const型的变量，而指向非const型变量的指针只能指向非const的变量。用指针变量作形参时形参和实参的对应关系表形参实参合法与否改变指针所指对象的值指向非const型变量的指针非const变量的地址合法行指向非const型变量的指针const变量的地址非法/指向const型变量的指针const变量的地址合法不行指向const型变量的指针非const变量的地址合法不行下面说到正题，指向常对象的指针变量和指向常变量指针变量类似。如果一个对象已经被声明为长对象，只能用指向常对象的指针变量指向它，而不能用一般的指针变量指向它。如果定义了一个指向常对象的指针变量且使它指向一个非const的对象，其指向的对象不能通过指针来改变。如果定义了一个指向常对象的指针变量，是不能通过它改变所指向的对象的值的，但是指针变量本身的值是可以改变的。如：Time t1(8,8,8),t2; //定义对象const time *p=t1; //定义指向常对象的指针p，并使它指向t1p=t2; //合法，指针p指向对象t2所以当我们希望在调用函数时对象的值不被修改，我们就可以把形参定义为const型的指针变量，同时用对象的地址作实参（对象可以是const或非const型）；当要求对象不仅在调用函数中不被改变，而且在程序执行过程中也不发生改变，我们就把它定义为const型。所以指向常对象的指针最常用于函数的参数，以保护形参指针所指向的对象在函数执行过程中不被修改。#p#副标题#e#

可以 语法没问题

指针变量的地址只能赋给指针变量。#include"stdio.h"intmain(){doublepi=3.1415926,*p,**q; p=u03c0 /*把double变量的地址赋给p*/ q=&p; /*把指针变量p的地址赋给q*/ printf("pi=%.7lf *p=%.7lf **q=%.7lf ",pi,*p,**q);/*检查赋值的效果 */ system("pause"); return0;}

引用就是那个变量本身 ，指针是指向变量的地址

指针就是地址，地址就是指针；指针变量是一个变量，它保存了基本类型变量的地址。如果指针变量p保存了变量a的地址，那么称作p指向了a，*p 就是变量a。如果p是一个指针变量，*p 表示了以 p 的内容为地址的变量，就是p指向的变量。可以这样来理解指针：指针是一种特殊的语言机制，它存放的是其它变量的地址，并且可以通过解引用操作符*，来获取该地址的内容。这也造成了一种指向的关系。各变量的类型推导，foo_p是指针，且指向int，故foo_p的类型是int*，也就是在"*"前添加int；foo_pp也是指针，且指向foo_p，故foo_pp的类型是int**，也就是在"*"前添加int*。扩展资料指针变量的初始化：可以用赋值语句使一个指针变量得到另一个变量的地址，从而使它指向该变量。比如：int i, *j;j = &i;这样就将变量 i 的地址放到了指针变量 j 中，通过 i 的地址，j 就能找到 i 中的数据，所以 j 就“指向”了变量 i。其中 & 是“取地址运算符”，与 scanf 中的 & 是一样的概念；* 为“指针运算符”，功能是取其内部所存变量地址所指向变量中的内容。因为 j 是定义成指针型变量，所以 j 中只能存放变量的地址，所以变量i前一定要加 &。需要注意的是，指针变量中只能存放地址，不要将一个整数或任何其他非地址类型的数据赋给一个指针变量。此外，还有两点需要注意：1、j 不是 i，i 也不是 j。修改j的值不会影响i的值，修改 i 的值也不会影响 j 的值。j 是变量 i 的地址，而 i 是变量 i 里面的数据。一个是“内存单元的地址”，另一个是“内存单元的内容”。2、定义指针变量时的“*j”和程序中用到的“*j”含义不同。定义指针变量时的“*j”只是一个声明，此时的“*”仅表示该变量是一个指针变量，并没有其他含义。而且此时该指针变量并未指向任何一个变量，至于具体指向哪个变量要在程序中指定，即给指针变量初始化。而当指定 j 指向变量 i 之后，*j 就完全等同于 i 了，可以相互替换。

指针变量，顾名思义首先是一个变量，专门用来存放地址的。如果说指针和指针变量严格来说的话，指针就是地址的意思，但是一般我们习惯于将指针变量叫做指针。一个指针变量占4个字节的大小（32位机）。里面存放的就是一个其他变量的地址。通过这个地址就能访问响应的变量了

*b=xxx就可以了

指针变量也是变量，只是它的值是地址，你所说的存放是什么意思？

前者是变量，后者是常量，指针变量很显然这个指针指向的存储单元存储的数据是可以变化的和指针常量指向的数据是程序运行前定义的一个不会变化的量，在程序运行过程中， 这个量既不能改变大小，也不能改变类型。存放地址的变量称为指针变量。指针变量是一种特殊的变量，它不同于一般的变量，一般变量存放的是数据本身，而指针变量存放的是数据的地址。举例：int a = 68 ,系统为变量a分配的首地址为0X065FDF4H，声明空指针long *p = NULL，p=&a是存放变量a地址的指针变量，即p=&a中存放的值为0x065FDF4H（a的值为68，&a的值为0x065FDF4H）。对变量a的访问有两种方式：一是直接按地址0x065FDF4H找到a的存储单元，从而对变量a进行访问；二是按系统为p=&a分配的地址先找到p=&a，然后根据p，&a的值（即变量a地址0x065FDF4H）找到变量a在内存中的存储单元，从而对变量a进行访问。对于前一种访问方式称为直接访问方式，后一种访问方式称为间接访问方式。如果一个指针变量存放的是某个对象的地址，则称这个指针变量指向该对象。在C++程序设计中，指针变量只有确定了指向才有意义。参考资料百度百科.百度百科.百度百科：百度百科，百度百科

int*代表的是int型的指针。声明的变量就叫指针变量。存放地址的变量称为指针变量。指针变量是一种特殊的变量，不同于一般的变量，变量存放的是数据本身，而指针变量存放的是数据的地址。举例：int* a = 68 ,系统为变量a分配的首地址为0X065FDF4H，声明空指针long *p = NULL，p=&a是存放变量a地址的指针变量，即p=&a中存放的值为0x065FDF4H（a的值为68，&a的值为0x065FDF4H）。扩展资料对变量a的访问有两种方式：一是直接按地址0x065FDF4H找到a的存储单元，从而对变量a进行访问；二是按系统为p=&a分配的地址先找到p=&a，然后根据p，&a的值（即变量a地址0x065FDF4H）找到变量a在内存中的存储单元，从而对变量a进行访问。对于前一种访问方式称为直接访问方式，后一种访问方式称为间接访问方式。如果一个指针变量存放的是某个对象的地址，则称这个指针变量指向该对象。在C++程序设计中，指针变量只有确定了指向才有意义。参考资料来源：百度百科-指针变量

1. 定义指针变量的一般形式如下：类型名*指针变量名1，*指针变量名2，... *指针变量名n ;2. 空指针空指针是一个特殊的指针，它的值是0，C语言中用符号常量NULL（在stdio.h中定义）表示这个空值，并保证这个值不会是任何变量的地址。空指针对任何指针类型赋值都是合法的。一个指针变量具有空指针值表示当前它没有指向任何有意义的东西。3. void指针（void *）类型的指针叫通用指针，可以指向任何的变量，C语言允许直接把任何变量的地址作为指针赋给通用指针。但是有一点需要注意void*不能指向由const修饰的变量，eg const int test; void * ptv; ptv = &test;第三句是非法的，只有将ptv申明为const void * ptv;上述第三句(ptv = &test)，才是合法的.当需要使用通用指针所指的数据参加运算时，需要写出类型强制转换。如通用指针ptv 所指空间的数据是整型数据，p是整型指针，用此式转换：p=(int *)ptv ;

1、概念不同“指针”是概念，“指针变量”是具体实现，指针也是一个变量，所以需要进行定义，而对于指针的定义，与一般变量一样。2、 存放地址不同一个变量的(内存)地址称为该变量的“指针”，通过指针能找到以它为地址的内存单元。而指针变量是用来存放另一个变量的地址的（即指针）。扩展资料：指针和指针变量的关系1、指针就是地址，地址就是指针。2、地址就是内存单元的编号。3、指针变量就是存放内存地址的变量。4、指针和指针变量是两个不同的概念，但要注意的是，通常我们叙述时会把指针变量简称为指针，实际他们含义并不一样。注：指针里存的是100. 指针：地址 - 具体。指针里存的是地址，指针：指针变量 -可变。指针的好处：1、直接访问硬件2、快速传递数据（指针表示地址）3、返回一个以上的值返回一个（数组或者结构体的指针）4、表示复杂的数据结构（结构体）5、方便处理字符串6、指针有助于理解面向对象

变量的指针，其含义是指该变量的地址。存放地址的变量称为指针变量，指针变量是一种特殊的变量，它不同于一般的变量，一般变量存放的是数据本身，而指针变量存放的是数据的地址。举例：int a = 68 ,系统为变量a分配的首地址为0X065FDF4H，声明空指针long *p = NULL，p=&a是存放变量a地址的指针变量，即p=&a中存放的值为0x065FDF4H（a的值为68，&a的值为0x065FDF4H）。扩展资料：对变量a的访问有两种方式：一是直接按地址0x065FDF4H找到a的存储单元，从而对变量a进行访问；二是按系统为p=&a分配的地址先找到p=&a，然后根据p，&a的值（即变量a地址0x065FDF4H）找到变量a在内存中的存储单元，从而对变量a进行访问。对于前一种访问方式称为直接访问方式，后一种访问方式称为间接访问方式。如果一个指针变量存放的是某个对象的地址，则称这个指针变量指向该对象。在C++程序设计中，指针变量只有确定了指向才有意义。

指针变量的一般定义为: 类型标识符 *标识符; 其中标识符是指针变量的名字, 标识符前加了*号,表示该变量是指针变量, 而最前面的类型标识符表示该指针变量所指向的变量的类型。一个指针变量只能指向同一种类型的变量, 也就是讲, 我们不能定义一个指针变量, 既能指向一整型变量又能指向双精度变量。

指针是C语言的精华部分，通过利用指针，我们能很好地利用内存资源，使其发挥最大的效率。有了指针技术，我们可以描述复杂的数据结构，对字符串的处理可以更灵活，对数组的处理更方便，使程序的书写简洁，高效，清爽。但由于指针对初学者来说，难于理解和掌握，需要一定的计算机硬件的知识做基础，这就需要多做多练，多上机动手，才能在实践中尽快掌握，成为C的高手。过去，我们在编程中定义或说明变量，编译系统就为已定义的变量分配相应的内存单元，也就是说，每个变量在内存会有固定的位置，有具体的地址。由于变量的数据类型不同，它所占的内存单元数也不相同。若我们在程序中做定义为：int a=1,b=2;float x=3.4, y = 4 . 5 ;double m=3.124;char ch1="a", ch2="b";让我们先看一下编译系统是怎样为变量分配内存的。变量a,b是整型变量，在内存各占2个字节；x,y是实型，各占4个字节；m是双精度实型，占8个字节；ch1,ch2是字符型，各占1个字节。由于计算机内存是按字节编址的，设变量的存放从内存2000单元开始存放，则编译系统对变量在内存的安放情况为图6-1所示。变量在内存中按照数据类型的不同，占内存的大小也不同，都有具体的内存单元地址，如变量a在内存的地址是2000，占据两个字节后，变量b的内存地址就为2002，变量m的内存地址为2012等。对内存中变量的访问，过去用scanf("%d%d%f",&a,&b,&x)表示将数据输入变量的地址所指示的内存单元。那么，访问变量，首先应找到其在内存的地址，或者说，一个地址唯一指向一个内存变量，我们称这个地址为变量的指针。如果将变量的地址保存在内存的特定区域，用变量来存放这些地址，这样的变量就是指针变量，通过指针对所指向变量的访问，也就是一种对变量的“间接访问”。设一组指针变量pa、pb、px、py、pm、pch1、pch2，分别指向上述的变量a、b、x、y、m、ch1、ch2，指针变量也同样被存放在内存，二者的关系如图6-2所示：在图6-2中，左部所示的内存存放了指针变量的值，该值给出的是所指变量的地址，通过该地址，就可以对右部描述的变量进行访问。如指针变量pa的值为2000，是变量a在内存的地址。因此，pa就指向变量a。变量的地址就是指针，存放指针的变量就是指针变量。

前者是变量，后者是常量，指针变量很显然这个指针指向的存储单元存储的数据是可以变化的和指针常量指向的数据是程序运行前定义的一个不会变化的量，在程序运行过程中，这个量既不能改变大小，也不能改变类型。

比较严格的说法是这样的：系统为每一个内存单元分配一个地址值，C/C++把这个地址值称为“指针”。如有int i=5;，存放变量i的内存单元的编号(地址)&i被称为指针。“指针变量”则是存放前述“地址值”的变量，也可以表述为，“指针变量”是存放变量所占内存空间“首地址”的变量(因为一个变量通常要占用连续的多个字节空间)。比如在int i=5;后有一句int *p=&i;，就把i的指针&i赋给了int *型指针变量p，也就是说p中存入着&i。所以说指针变量是存放指针的变量。有一个事实值得注意，那就是有不少资料和教科书并没有如上区分，而是认为“指针是指针变量的简称”，如对int *p=&i;的解释是：声明一个int *型指针p，并用变量i的地址初始化；而严格说应该是声明一个int *型指针变量p才对。所以有时看书要根据上下文理解实质，而不能过于拘泥于文字表述。

指针变量 合法的赋值 只有地址值。 如果填两个的话 就是地址值和空值 也就是NULL很多人说地址值和变量值， 后者 是不对的。

p中存地址 *p指 p地址指向的内容 a 直接就是值

变量的指针就是变量的地址。存放变量地址的变量是指针变量。允许用一个变量来存放指针，这种变量称为指针变量。因此，一个指针变量的值就是某个变量的地址或称为某变量的指针 比如: int a;//变量 int *p;//指针变量 p=&a;//p就是变量a的指针,你可以叫它变量指针