指针变量

1.首先,就是最基本的知识,写头文件、函数声明、定义变量。2.下面还需要定义指针,需要定义两个指针p1和p2,然后把a的地址赋值给p1,把b的地址赋值...3.然后就是调用函数,该函数没有返回值,就直接调用,但是参数进入的是a和b的地址,而不是a和...4.函数点用完之后,就是输出a和b的值看一看是否互换了。5.首先,a和b的地址传给x和y,通过指针直接对a和b的值进行操作。

No

你可以反汇编试试,好象会自动匹配.

指针变量不管指向多大的空间，它本身就占4个字节。如果指向的空间很大的话，那用指针就更快啊

#include<stdio.h>1.申明数组a[5],下标是应该从0~4的;2.进行排序时需要用2个变量进行冒泡排序;3.scanf时%d后面不需要空格。程序修改如下:voidpa(int*a,intn){inti,j;intt;for(i=0;i<n;i++)for(j=0;j<n-i-1;j++)if(*(a+j)>*(a+j+1)){t=*(a+j);*(a+j)=*(a+j+1);*(a+j+1)=t;}}voidmain(){inta[5],i;for(i=0;i<5;i++)scanf("%d",&a[i]);printf("未排序前的数列为: ");for(i=0;i<5;i++)printf("%d",a[i]);pa(a,5);printf("排序后的数列为: ");for(i=0;i<5;i++)printf("%d",a[i]);}

这样不会，因为a="i love china"是将"i love china"这个字符串的首字符的地址赋给指针a，而一旦出现了"i love china"这个字符串，程序就会自动分配一个内存空间用于存储"i love china"，a的地址本来不可预知，但赋值之后是可预知的,即新分配的"i love china"的地址。 楼上，谁说不可以这样赋值char *a;a="i love china"; 至少Turbo C++和vs2008可以，至于别的编译器没试过。

指针变量是指向一个实际内存地址的变量。而scanf函数的输入中后一个参数正好是需要一个地址来表明这个输入的数据放置在内存中的什么地方，还记得对于这样的输入scanf("%d",&(int))int或者可以是其他某个值类型的变量名，前面的&符号就是取他的地址。你这里p是一个指针变量，所以就不需要取地址符号了。对于字符指针，他指向的是一个字符的地址，所以你后面的char*a;scanf("%s",a)语句会出错，%s是一串字符，而不是一个字符，类型不匹配，a没有办法指向字符串；而char*string="ilovechina"这个语句中，其实并不是把后面的"ilovechina"赋值给了string，c语言中是用一连串的内存地址存放字符串的，类似于字符数组，而这样的复制语句其实是把数组的首地址进行赋值，或许你还见过这样的语句inta[]={1.2.3};int*p; p=a; 这些复制都是把数组的首地址进行复制，而数组首地址是第一个元素(序号为0)的地址，所以类型是相匹配的。

既不是“指针变量的存储单元”，也不是指针“存储单元的内容”，而是“指针所指目标元素的地址”。

NULL宏的值就是0原则上对指针赋任何整型常量都是合法的,单片机编程中就经常有这种操作只不过是指针指向的空间多半是无法操作的内存空间而已

指针就是地址，跟类型无关。占用的存储单元跟操作系统有关，比如在64位操作系统中，指针占8字节，32位操作系统中，占4字节，16位操作系统中，占2字节，以此类推。

p q都是地址，n是int整数

4byte，32bit

基本上是一样的概念，只是指针还有指针常量而已。

1楼说的对，int* a就是局部变量嘛

指针是一个地址，而指针变量时存放地址的变量。*的意思是“指向”。地址应该对应地址。

inta；int*p；p=&a；在定义指针变量的时候，我们这样写：“int*p”，这里定义了一个指针，没有具体让他指向某个具体地址（事实上，它有可能指向任何地方），在这里这个“p”，就是"指针变量"。而我们用指针"p"的时候,如果要给他赋值，比如:p=&a；这里的意思是将a的地址赋值给p，指针p指向了a的地址，所以这时候"p"就成了"指针常量"。

语言中，指针是一种类型，被称为“指针类型”。指针类型描述的是一个地址，这个地址指向内存中另外一个对象的位置。简单地说，指针表示的是它所指向对象的地址。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_t size)。例子： int * pn=malloc(10*sizeof(int)); double *pd=malloc(10*sizeof(double));

关于 指针变量 int *p;有两个概念。一是指针自己，指针自己的单元，用来存放它要指向的数据的地址，另一个是被指向的数据存放单元。要分清，你打算给谁赋值，你打算给被指向的数据存放单元赋值，还是给指针自己赋值。

指针其实就是变量存放的地址。 int a = 5; int *p = &a; p指针就指向了a变量，&是单目运算符，取变量地址的。 然后就可以通过p指针来访问a变量了

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

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

你可以定义指向指针的指针int a = 1;int *ptr = &a;int **ptr_to_ptr = &ptr;

我一直在承受这个年纪不该有的帅气和机智，我好累

指针变量是变量的一种，指针变量的值是地址（也是整数）。普通变量的值是整数或者实数。指针变量可以将存储地址的变量和存储普通整数的变量区分开来。指针变量的作用主要是用来修改其他函数的局部变量或者用来访问数组。指针变量需要额外的空间存放地址，由于是间接访问所指对象所以比起直接用名字访问所指对象而言，速度稍慢。指针变量的这些开销根本无需考虑，正确使用就行了。

用例子来看一下。int a=3;int *p;p=&a;现在来看一下。a=3这个式子先解释一下等式右边是常量，左边是变量。同理的p=&a，左边的是指针变量，右边的是指针指针的基本概念：为了区别内存的不同位置，内存被分成字节，内存的全部字节顺序地赋予一个称为地址的编号。程序中的变量将在内存中占据一定的内存字节，在这些字节中存储的数据信息称为变量的内容。一个变量占用连续的若干个内存字节时，最前面的一个字节的地址就作为该变量的地址。指针就是内存地址，是变量的地址，或函数的入口地址。变量的地址在程序执行时，起着非常重要的作用。当计算机在计算含有变量的表达式时，计算机按变量的地址取出其内容，并按变量的地址将计算结果存入到变量占据的内存中。如代码：　　int x＝l；　　x＝x＋2；　　其中语句“x＝x＋2；”中的第一个x涉及到变量x占据的内存，第二个 x是引用变量 x的内容。该语句的意义是“取X的内容，完成加上2的计算，并将计算结果存入变量X占据的内存中。”　　指针变量和它所指向的变量：在C语言中，地址也作为一种值，能被存储、比较、赋值，并称地址数据为指针类型，而称存储地址值的变量为指针变量，简称指针。C程序可用运算符＆取变量的地址，如表达式＆x的值就是变量X的地址。程序除能按名引用变量外，也可利用变量的地址引用变量。按变量名引用变量称为直接引用，而将变量A的地址存于另一变量B中，借助于变量B引用变量A称为对A的间接引用。　　定义指针变量的一般形式为：　　类型 * 指针变量名；　　或　　类型 * 指针变量名=初值表达式；　　其中，指针变量名是标识符，指针变量名之前的符号“*”，表示该变量是指针类型的。而最前面的“类型”，表示该指针变量能指向变量或函数的类型。初值表达式是一个地址表达式，如表达式中有某变量的地址表达式，则这个变量应是前面已定义的。　　在C语言中，当定义局部指针变量时，如未给它指定初值，则其值是不确定的。程序在使用它们时，应首先给它们赋值。误用其值不确定的指针变量间接引用其它变量，会引起意想不到的错误。为明确表示指针变量不指向任何变量，在C语言中用0值表示这种情况，记为NULL。如　　ip＝ NULL;　　也称指针值为0的指针变量为空指针。对于静态的指针变量，如在定义时未给它指定初值，系统自动给它指定初值0。　　指针变量取程序对象的（开始）地址值，不能将一个整型量或任何其它非地址值赋给一个指针变量。另外，指针变量对所指向的对象也有类型限制，不能将一个不能指向的对象的地址赋给指针变量。如有以下定义：　　int i＝100，j，*ip，*intpt；　　float f,*fp；　　以下代码如注释所叙。　　iP＝&i；/*使ip指向i*/　　intpt＝ip；/*使intpt指向ip所指变量*/　　fp= &f；/*使fp指向正*/　　ip＝NULL；/*使 ip不再指向任何变量*/拓展资料：在计算机科学中，指针(Pointer)是编程语言中的一个对象，利用地址，它的值直接指向(points to)存在电脑存储器中另一个地方的值。由于通过地址能找到所需的变量单元，可以说，地址指向该变量单元。因此，将地址形象化的称为"指针"。意思是通过它能找到以它为地址的内存单元。 在高级语言中，指针有效地取代了在低级语言，如汇编语言与机器码，直接使用通用暂存器的地方，但它可能只适用于合法地址之中。指针参考了存储器中某个地址，通过被称为反参考指针的动作，可以取出在那个地址中存储的值。作个比喻，假设将电脑存储器当成一本书，一张内容记录了某个页码加上行号的便利贴，可以被当成是一个指向特定页面的指针;根据便利粘贴面的页码与行号，翻到那个页面，把那个页面的那一行文字读出来，就相当于是对这个指针进行反参考的动作。指针是程序设计语言的一个重要概念。指针在C程序中有以下多方面的作用：　　利用指针能间接引用它所指的对象。　　利用各种类型的指针形式参数，能使函数增加描述能力。　　指针与数组结合，使引用数组元素的形式更加多样、访问数组元素的手段更加灵活。　　指针能用来描述数据和数据之间的关系，以便构造复杂的数据结构。当一个数据A要关联另一个数据B时，在数据A中增加一个指向数据B的指针就可实现数据A关联数据B。结合系统提供的动态分配存储设施，又能构造出各种动态数据结构。

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

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

p中存地址 *p指 p地址指向的内容 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才对。所以有时看书要根据上下文理解实质，而不能过于拘泥于文字表述。

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

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

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

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 ;

前者是变量，后者是常量，指针变量很显然这个指针指向的存储单元存储的数据是可以变化的和指针常量指向的数据是程序运行前定义的一个不会变化的量，在程序运行过程中， 这个量既不能改变大小，也不能改变类型。存放地址的变量称为指针变量。指针变量是一种特殊的变量，它不同于一般的变量，一般变量存放的是数据本身，而指针变量存放的是数据的地址。举例：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++程序设计中，指针变量只有确定了指向才有意义。参考资料来源：百度百科-指针变量

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

*b=xxx就可以了

指针就是地址，地址就是指针；指针变量是一个变量，它保存了基本类型变量的地址。如果指针变量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位机）。里面存放的就是一个其他变量的地址。通过这个地址就能访问响应的变量了

可以 语法没问题

指针变量的地址只能赋给指针变量。#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;}

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

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

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

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

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

不可以。

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

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

变量指针：指向的数据为变量的指针，如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都指向同一数组中的元素时才有意义)。

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

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

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

指针是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]明显是这个地址的值，所以要加个取地址符&。

语言中，指针是一种类型，被称为“指针类型”。指针类型描述的是一个地址，这个地址指向内存中另外一个对象的位置。简单地说，指针表示的是它所指向对象的地址。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。变量的地址就是指针，存放指针的变量就是指针变量。

#include<stdio.h>void main(){ int a,b, *pa;scanf(" %d %d",&a,&b);pa=&a;}

inline void Node::CreatedListTail(int n) {Node* L = new Node;int i;srand(time(0));L->next = nullptr;Node* p;for (i = 0; i < n; i++) {p = new Node;p->data = rand() % 100 + 1;p = L->next->next; // 这里错了}p->next = nullptr;}给你改了下inline void Node::CreatedListTail(int n) {Node* L = new Node; int i;srand(time(0));L->next = nullptr;Node* p;p=L; //p先指向头 for (i = 0; i < n; i++) {p->data = rand() % 100 + 1;p->next = new Node; //挂一个新节点p=p->next; //p移动到新节点}p->next = nullptr; }

不会。在请求go同个http的时候，客户端指针变量是独立存在的，因此并不会覆盖。客户端（Client）或称为用户端，是指与服务器相对应，为客户提供本地服务的程序。除了一些只在本地运行的应用程序之外，一般安装在普通的客户机上，需要与服务端互相配合运行。

1、指针变量的赋值，分为定义时赋值（初始化）和单独赋值，如：int x ;int * px=&x ; //定义时赋值，也称初始化，注意这里的*是跟随int的，即变量px是int *类型变量！ 实际上的赋值语句是px=&x ;int * py ;py=&x ; //单独赋值，将py指向x*py=10 ; //这里的*，是引用指针中的数据操作符，*跟随的变量必须是指针类型变量，否则会出错！ *py就是x，这里相当于x=10;2、指针变量作为函数的参数时，子函数可以通过指针引用实参地址中的数据，达到修改实参地址中的数据。如：#include <stdio.h>void func( int a, int b, int *pmax ){ if ( a>b ) *pmax=a; else *pmax=b ;}void main(){ int a=2,b=3,max=0; func(a,b,&max ); //这里将变量max的地址传递到子函数，子函数中通过该地址，可以修改max的值，达到子函数结束后，max能带回运算结果的效果。 printf("max=%d ", max );}

将w指针指向单元的内容赋值到指针p指向的单元中最后p指向的单元的内容为3

左边的GetMax函数返回一个int类型的max右边的GetMax函数没有返回值，函数参数是int类型的变量a,b,c和指向int类型变量的指针变量m在调用GetMax函数时，函数参数中的max是指针变量，调用指针都要加上&表示调用的是指针地址。你这样记好了，如果遇到指针，定义函数的参数中要加*，调用函数的参数中要加&，一般都是这个规律。

int *p,a=3,*q;*q=3;*p=a;p=&a;p=q;

1.静态数据成员需要在类外单独做初始化，形式如： 变量类型 类名::变量名=初始值;看下面的例子：（调试环境VS2005）class BaiduTest{public: static int *m_instance;//静态指针变量};int _tmain(int argc, _TCHAR* argv[]){ int a = 10; BaiduTest::m_instance = &a;//静态指针变量初始化 return 0; }

在cpp文件里写一行: int *xxx::mmm=NULL;其中xxx是类名，mmm是静态成员指针变量

float(S::*mptr1)();跟这个是对应的