【导语】下面给大家分享c/c++中的指针的应用及注意问题（共8篇），欢迎阅读!
篇1：c/c++中的指针的应用及注意问题
指针是c/c++学习一个比较让人头痛的问题，在程序设计过程中，指针也往往是产生隐含bug的原因，下面就来
谈谈指针的应用以及需要注意的一些问题，里面也许就有你平时没有注意到的问题，希望能帮助各位读者理解好指针。
一、我们先来回忆一下指针的概念吧，方便下面的介绍
指针是存放地址值的变量或者常量。例如：int a=1;&a就表示指针常量（“&”表示
取地址运算符，也即引用）。int *b，b表示的是指针变量（注意，是b表示指针变量而
不是*b），*表示要说明的是指针变量。大家注意int *b[2]和int（*b）[2]是不同的，
int *b表示一个指针数组，而int （*b）[2]表示含有两个元素的int指针，这里要注意
运算优先级问题，有助于理解指针问题。
在这里大概介绍基本概念就够了，至于具体使用方法，如赋值等，很多书都有介绍
，我就不多说了。
二、应用以及注意的问题
1、 理解指针的关键所在——对指针类型和指针所指向的类型的理解
①、 指针类型：可以把指针名字去掉，剩下的就是这个指针
例如：int *a;//指针类型为int *
int **a;//指针类型为int **
int *（*a）[8];//指针类型为 int *（*）[8]
②、 指针所指向的类型：是指编译器将把那一片内存所看待成的类型。这里只要把
指针声明语句中的指针名字和名字右边的“*”号去掉就可以了，剩下的就是指针所指向
的类型。
我之所以把他们放在第一位，是因为弄清楚他们是学c/c++指针的重点，正确理解他
们才能使你打好c/c++的编程基础。
2、 指针的应用——传递参数。
其实它可以相当于隐式的返回值，这就比return的方法更加灵活了，可以返回更多
的值，看看下面的例子自然就明白了：
#include “iostream.h”
void example（int *a1,int &b1,int c1）
{
*a1*=3;
++b1;
++c1;
}
void main
{
int *a;
int b,c;
*a=6;
b=7;c=10;
example（a,b,c）；
cout 《“*a=”《*a<
cout 《“b=”<
cout 《“c=”<
}
输出：*a=18
b=8
c=10
注意到没有，*a和b的值都改变了，而c没有变，
这是由于a1是指向*a（=6）的指针
，也即与a是指向同一个地址，所以当a1指向的值改变了，*a的值也就改变了。在函数中
的参数使用了引用（int &b1），b1是b的别名，也可以把它当作特殊的指针来理解，所
以b的值会改变。函数中的参数int c1只是在函数中起作用，当函数结束时候便消失了，
所以在main（）中不起作用。
3、 关于全局变量和局部变量的一个问题
先不废话了，先看看程序：
#include “iostream.h”
int a=5;
int *example1（int b）
{
a+=b;
return &a;
}
int *example2（int b）
{
int c=5;
b+=c;
return &b;
}
void main（）
{
int *a1=example1（10）；
int *b1=example2（10）；
cout 《”a1=”《*a1<
cout 《”b1=”《*b1<
}
输出结果：
a1=15
b1=4135
*b1怎么会是4135，而不是15呢？是程序的问题？没错吧？
由于a是全局变量，存放在全局变量的内存区，它一直是存在的；而局部变量则是存
在于函数的栈区，当函数example2（）调用结束后便消失，是b指向了一个不确定的区域
，产生指针悬挂。
下面是对example1（）和example2（）的反汇编（用TC++ 3.0编译）：
example1（）：
push bp;入栈
mov bp,sp
mov ax,[bp+04];传递参数
add [00AA],ax;相加
mov ax,00AA ;返回了结果所在的地址
.
.
.
pop bp；恢复栈，出栈
篇2：c语言指针
一、数组的指针、指针数组以及指向指针的指针
考虑数组的指针的时候我们要同时考虑类型和维数这两个属性，换一句话，就是说一个数组排除在其中存储的数值，那么可以用类型和维数来位置表示他的种类。
A）一维数组
在c和c++中数组的指针就是数组的起始地址（也就第一个元素的地址），而且标准文档规定数组名代表数组的地址（这是地址数值层面的数组表示）。例如：
int a[10]; int *p;
p=&a[0]//和p=a是等价的：
因为a是数组名，所以他是该数组的地址，同时因为第一个元素为a[0]，那么&a[0]也代表了该数组的地址。但是我们是不是就说一个数组名和该数组的第一个元素的&运算是一回事呢？在一维的时候当时是的，但是在高维的时候，我们要考虑到维数给数组带来的影响。
a[10]是一个数组，a是数组名，它是一个包含10个int类型的数组类型，不是一般的指针变量噢！（虽然标准文档规定在c++中从int[]到int*直接转换是可以的，在使用的时候似乎在函数的参数为指针的时候，我们将该数组名赋值没有任何异样），a代表数组的首地址，在数字层面和a[10]的地址一样。这样我们就可以使用指针变量以及a来操作这个数组了。
所以我们要注意以下问题：
（1） p[i]和a[i]都是代表该数组的第i+1个元素；
（2） p+i和a+i代表了第i+1个元素的地址，所以我们也可以使用 *（p+I）和*（a+I）来引用对象元素；
（3）p+1不是对于指针数量上加一，而是表示从当前的位置跳过当前指针指向类型长度的空间，对于win32的int为4byte；
B)多维数组
对于二维数组a[4][6];由于数组名代表数组的起始地址，所以a（第一层）和第一个元素a[0][0]地址的数字是相同的，但是意义却是不同的。对于该数组我们可以理解为：a的一维数组（第一层），它有四个元素a[0]、a[1]、a[2]、a[3]（第二层），而每个元素又含有6个元素a[0][0],a[0][1],a[0][2],a[0][3],a[0][4]，a[0][5]（第三层）,…到此我们终于访问到了每个元素了，这个过程我们经历了：a->a[0]->a[0][0]；
整体来讲：a是一个4行5列的二维数组，a表示它指向的数组的首地址（第一个元素地址&a[0]）,同时a[0]指向一行，它是这个行的名字（和该行的第一个元素的首地址相同（第一个元素为地址&a[0][0]））。所以从数字角度说：a、a[0]、&a[0][0]是相同的，但是他们所处的层次是不同的。
既然a代表二维数组，那么a+i就表示它的第i+1个元素*（a+i）的地址，而在二维数组中
*（a+i）又指向一个数组，*（a+i）+j表示这个数组的第j+1个元素的地址，所以要访问这个元素可以使用 *（*（a+i）+j）（也就是a[i][j]）。
他们的示意图为（虚线代表不是实际存在的）：
对照这个图，如下的一些说法都是正确的（对于a[4][6]）：
a是一个数组类型，*a指向一个数组；
a+i指向一个数组；
a、*a和&a[0][0]数值相同；
a[i]+j和*（a+i）+j是同一个概念；
总结一下就是：我们对于二维指针a，他指向数组a[0，1，2，3]，使用*，可以使他降级到第二层次，这样*a就指向了第一个真正的数组。对于其他的情况我们也可以采用相同的方式，对于其他维数和类型的数组我们可以采用相类似的思想，
说到指向数组的指针，我们还可以声明一个指针变量让它指向一个数组。例如：
int （*p）[5]；
这时p就是一个指针，要指向一个含有5个int类型元素的数组，指向其他的就会出现问题。
这个时候我们可以使用上面的什么东西来初始化呢？
我们可以使用*a,*(a+1)，a[2]等。
原因很简单：我们在一个二维的数组中，那么表达方式有上面的相互类似的意义呢？只有 *a,*(a+1)，a[2]等，
C)指针数组
一个指针数组是指一个数组中的每个元素都是一个指针，例如：
int *p[10];//而不能是int (*p)[10]
或者
char *p[10];
此时p是一个指针（数值上和&p[0]一样）；
在前面有int t[10]；
int * pt=t;//使用pt指向t
那么这里我们用什么指向int *t[10]中的t呢？我们要使用一个指针的指针：
int **pt=t;
这是因为：在int *t[10]中，每个元素是指针，那么同时t又指向这个数组，数组上和&t[0]相同，也就是指向t[0]，指向一个指针变量，可以说是一个指针的指针了，所以自然要用
int **pt;
D)指针的指针
一个指针变量内部可以存储一个值，这个值是另外一个对象的地址，所以我们说一个指针变量可以指向一个普通变量，同样这个指针变量也有一个地址，也就是说有一个东西可以指向这个指针变量，然后再通过这个指针变量指向这个对象。那么如何来指向这个指针变量呢？由于指针变量本身已经是一个指针了（右值），那么我们这里就不能用一般的指针了，需要在指针上体现出来这些特点，我们需要定义指针的指针（二重指针）。
int *p1=&i; int**p2=&p1；
综合以上的所有点，下面是我们常常看到一些匹配（也是经常出错的地方）：
int a[3],b[2][3],c,*d[3]; void fun1(int *p)； void fun2(int (*p)[3]); void fun3(int **p); void fun4(int p[3]); void fun5(int p[]); void fun6(int p[2][3]); void fun7(int (&p)[3]);
函数 不会产生编译时刻的可能值（但逻辑上不一定都对）
函数
不会产生编译时刻的可能值（但逻辑上不一定都对）
fun1
a, &a[i], *b ,b[i],&b[i][j] ,&c ,d[i]
fun2
b，b+i，
fun3
d
fun4
a, &a[i], *b ,b[i],&b[i][j] ,&c ,d[i]
fun5
a, &a[i], *b ,b[i],&b[i][j] ,&c ,d[i]
fun6
b
篇3：C语言指针
指针变量是包含内存地址的变量，它指向内存中的一块区域，通过指针的值，可以间接访问到相应的内存单元的数据，并做相应的修改，
1、指针的定义和简单使用
定义一个指针变量和定义一般的变量类似，只需在变量名前面加一个“*”。对一个指针变量赋值可以用取地址符&来获取到一个变量的地址，如果要获得指针指向的内存区域的数据，用解参考运算符*(也称为间接运算符，它返回其操作数指向的对象的值)。指针的值为NULL(NULL是stdio.h中定义的符号变量，实际上是0)说明其不指向任何的内存单元，0是唯一直接可以赋值给指针变量的整数值。实际上，*和&是互补的，当两个运算符连续应用于一个指针变量时，无论顺序如何，运算结果相同。同时可以用printf中的格式化字符串%p来输出指针变量的值，下面是一个简单的程序。
[cpp]
#include
int main
{
int a;
a=9;
//定义并初始化一个指针，命名就可以看出
int *aPtr=NULL;
//将指针指向变量a
aPtr=&a;
printf(“The address of a is %p”
“nThe value of aPtr is %p”,&a,aPtr);
printf(“nnThe value of a is %d”
“nThe value of *aPtr is %d”,a,*aPtr);
printf(“nnShowing that * and & are complements of ”
“each othern&*aPtr = %p”
“n*&aPtr = %pn”,&*aPtr,*&aPtr);
return 0;
}
2、用指针做函数的参数
2.1 通过指针实现的引用传递
程序设计语言的参数传递方式，大致分两种：值传递和引用传递。C语言中没有引用传递，但是C语言通过指针间接实现了引用传递。通过用指针变量作为函数的参数，可以传递变量的地址(只需要在变量前面加上&运算符就可以)，这样，用该地址就可以访问到主调函数中的该变量的内存地址，并可以进行相应的修改。这样，在函数执行完毕之后，修改仍然可以得到保留。
2.2 const
const限定符可以告诉编译器特定的变量的值是不能被修改的。如果想确保函数不会修改传递进来的参数值，应该将参数声明为const。这样对于C语言中用指针实现的引用传递，有四种情况：指向非常量数据的非常量指针(int *aPtr)，指向非常量数据的常量指针(int *const aPtr)，指向常量数据的非常量指针(const int *aPtr)和指向常量数据的常量指针(const int * const aPtr)。简单的说，就是指针变量自身和指针指向的变量都有可能是const，这样就产生了四种情况，这四种情况提供了四种不同的访问权限，下面分别解释。
指向非常量数据的非常量指针(int *aPtr)：指针的值本身和指针指向变量的值都可以在函数中被修改。
指向非常量数据的常量指针(int *const aPtr)：指针的值不能被修改，但是指针指向的变量的值可以被修改。
指向常量数据的非常量指针(const int *aPtr)：指针指向的值不能被修改，但是指针本身的值可以被修改。
指向常量数据的常量指针(const int * const aPtr)：指针本身和指针指向变量的值都不能被修改。
3、sizeof和指针运算
3.1 sizeof
sizeof是C语言中特殊的一元运算符，可以应用在变量名称、数据类型和常量之前，它在程序编译期间以字节为单位来确定数组或其他数据类型的大小。当应用于数组时，sizeof返回数组中的字节总数。如float a[20]，sizeof(a)的值应该是4*20，80。当然，如果想获得数组的大小可以采用sizeof(a)/sizeof(float)。
3.2 指针运算
实际上，指针变量可以进行的算术操作是有限的：递增，递减，将指针和整数相加，从指针中减去一个整数或者一个指针减去另一个指针，
需要注意的是，对于指针的算术运算，其单位长度并不是一般意义上的1，而是sizeof(TYPE)。这样，如果float a[14]; float *aPtr=a;(或者int *aPtr=&a[0]); aPtr++;这样aPtr应该指向的是数组a的第二个元素，也就是a[1]，这里的单位长度就是sizeof(float)。同样地，如果aPtr=aPtr+5;，这样aPtr又指向了数组a的第6个元素。如果aPtr-a，这样可以得到两个指针之间的元素间隔个数。应该是6。
进行指针运算要注意：
(1)如果将一个指针的值赋给另外一个指针，那么这两个指针的类型必须相同，否则应该用类型转换运算符进行类型转换。但是，有一个例外就是指向void类型的指针，它是通用指针，可以代表任何指针类型。因此，所有指针类型都可以赋值给void指针，而void指针也可以赋值给任何类型的指针，而不需要任何类型转换运算符。但是，void指针不能解参考，编译器知道指向int类型的指针引用的是32位计算机上的4个字节内存，但指向void的指针仅包含未知数据类型的内存位置，也就是说，编译器不知道指针所引用的字节数。编译器必须知道数据类型，才能确定所引用的字节数。
(2)除非两个指针变量都指向的是一个数组中的元素，否则对它们相减的结果没有任何意义，因为我们不能假设两个变量在内存中是连续的。
4、指针和数组
4.1 数组和指针的共性
实际上，数组名称的本质是一个常量指针。因此，int a[6]; int *aPtr;定义一个数组和指针之后，通过a[3]，*(a+3)和*(aPtr+3)都可以访问到数组的第四个元素的值。但是区别在于，aPtr=aPtr+3;这样aPtr就指向了a数组的第四个元素，但是，不能a=a+3;，因为a是一个数组名，它是一个常量指针它的值不能被修改，更加具体地说，它应该是一个指向非常量数据的常量指针。
4.2 指针数组
数组元素也可以是指针类型，指针数组常见的用途就是构成由字符串组成的数组，简单地说就是字符串数组，数组中的每一个元素都是字符串。下面是一个例子，const限定符说明不能修改每个元素指针所指向的字符串。
[cpp]
#include
int main()
{
const char *suit[4]={“Hearts”,“Diamonds”,“Clubs”,“Spades”};
int i;
for(i=0;i<4;i++)
printf(“sizeof pointer to ”%s“ :%dn”,suit[i],sizeof(suit[i]));
printf(“nsizeof suit:%dn”,sizeof(suit));
return 0;
}
运行结果如下：
从这个例子中，可以看出const char *suit[4]={“Hearts”,“Diamonds”,“Clubs”,“Spades”};定义了一个指针数组，但是，其中的每个元素只是一个指针，而不是数组名(如果是数组名的话，sizeof的结果不应该都是4)。这样定义字符串数组可以节省空间。
5、函数指针
和数组名实际上就是数组第一个元素在内存中的地址类似，函数迷你实际上就是执行函数任务的代码在内存中的起始地址。函数指针包含函数在内存中的地址，可以传递给函数、从函数返回、存储在数组中或者是赋值给其它的函数指针，下面是两个函数指针的例子。
(1) 用函数指针实现升序/降序排序
[cpp]
#include
#define SIZE 10
int ascending(int a,int b)
{
return a>b;
}
int descending(int a,int b)
{
return a
}
void swap(int *aPtr,int *bPtr)
{
int temp=*aPtr;
*aPtr=*bPtr;
*bPtr=temp;
}
篇4：c中指针指针、指针的指针、指针数组和数组指针
一、指针
如果在程序中定义一个变量，在对程序进行编译，系统会自动给这个变量分配内存单元，根据不同的类型，分配不同长度的空间，如int占用4个字节，char占用1个字节，内存单元中每个字节都有编号，这就是地址。由于可通过地址能够找到所需的变量单元，可以说地址指向该变量单元。打个比方，一个房间的门口挂了一个房间号301，这个301就是房间的地址，将该地址形象化为指针。对于一个内存单元来说，单元的地址（编号）即为指针，其中存放的数据才是该单元的内容。
严格地说，一个指针是一个地址，是一个常量，
而一个指针变量却可以被赋予不同的指针值，是变量。但常把指针变量简称为指针。为了避免混淆，约定：“指针”是指地址，是常量，“指针变量”是指取值为地址的变量。定义指针的目的是为了通过指针去访问内存单元。
例如：
int a=12;
int *p=&a;
二、指针的指针（二级指针）
简单来说，二级指针变量就是一级指针变量的地址。
例如：
int a=12;
int *p=&a;
int **=&p;
篇5：c指针笔试题
1. 变量的指针，其含义是指该变量的_________.
a)值 b)地址
c)名 d)一个标志
2.若有语句int *point,a=4;和point=&a;下面均代表地址的一组选项是_____. a)a,point,*&a b)&*a,&a,*point
c)*&point,*point,&a d)&a,&*point ,point
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. 以下程序中调用scanf函数给变量a输入数值的方法是错误的，其错误原因是________.
main
{
int *p,*q,a,b;
p=&a;
printf(“input a:”);
scanf(“%d”,*p);
……
}
a)*p表示的是指针变量p的地址
b)*p表示的是变量a的值，而不是变量a的地址
c)*p表示的是指针变量p的值
d)*p只能用来说明p是一个指针变量
5. 已有变量定义和函数调用语句：int a=25; print_value(&a); 下面函数的正确输出结果是________.
void print_value(int )
{ printf(“%dn”,++);}
a)23 b)24 c)25 d)26
6.若有说明：long *p,a;则不能通过scanf语句正确给输入项读入数据的程序段是
A) *p=&a; scanf(“%ld”，p);
B) p=(long *)malloc(8); scanf(“%ld”，p);
C) scanf(“%ld”，p=&a);
D) scanf(“%ld”，&a);
7.有以下程序
#include
main
{ int m=1,n=2,*p=&m,*q=&n,*r;
r=p;p=q;q=r;
printf(“%d,%d,%d,%dn”,m,n,*p,*q); }
程序运行后的输出结果是
A)1，2，1，2
C)2，1，2，1
篇6：c指针笔试题
1. 有以下程序
main { int a=1, b=3, c=5; int *p1=&a, *p2=&b, *p=&c; *p =*p1*(*p2); printf(“%dn”,c); }
执行后的输出结果是
A)1
2. 有以下程序
main
{ int a,k=4,m=4,*p1=&k,*p2=&m;
a=p1==&m;
printf(“%dn”,a);
}
程序运行后的输出结果是
A)4
B)1 C)0 D)运行时出错，无定值 B)2 C)3 D)4 B)1，2，2，1 D)2，1，1，2
3. 在16位编译系统上，若有定义int a={10,20,30}, *p=a;，当执行p++;后，下列说法错误的是
A)p向高地址移了一个字节
C)p向高地址移了两个字节
4.有以下程序段
int a[10]={1,2,3,4,5,6,7,8,9,10},*p=&a[3],b;
b=p[5];
b中的值是
A)5 B)6 C)8 D)9
5.若有以下定义，则对a数组元素的正确引用是_________.
int a[5],*p=a;
a)*&a[5] b)a+2 c)*(p+5) d)*(a+2)
6.若有以下定义，则p+5表示_______.
int a[10],*p=a;
a)元素a[5]的地址 b)元素a[5]的值
c)元素a[6]的地址 d)元素a[6]的值
7.设已有定义: int a[10]={15,12,7,31,47,20,16,28,13,19}，*p; 下列语句中正确的是
A) for(p=a;a<(p+10);a++);
B) for(p=a;p<(a+10);p++);
C) for(p=a,a=a+10;p
D) for(p=a;a
篇7：c指针笔试题
1.有以下程序段
#include
int main
{ int x = {10, 20, 30};
int *px = x;
printf(“%d,”, ++*px); printf(“%d,”, *px);
px = x;
printf(“%d,”, (*px)++); printf(“%d,”, *px);
px = x;
printf(“%d,”, *px++); printf(“%d,”, *px);
px = x;
printf(“%d,”, *++px); printf(“%dn”, *px);
return 0; B)p向高地址移了一个存储单元 D)p与a+1等价
}
程序运行后的输出结果是( )
A)11,11,11,12,12,20,20,20 B)20,10,11,10,11,10,11,10
C)11,11,11,12,12,13,20,20 D)20,10,11,20,11,12,20,20
2.设有如下定义：
int arr={6,7,8,9,10};
int *ptr;
ptr=arr;
*(ptr+2)+=2;
printf (“%d,%dn”,*ptr,*(ptr+2));
则程序段的输出结果为
A)8,10 B)6,8 C)7,9 D)6,10
3.若有定义:int a={2,4,6,8,10,12},*p=a;则*(p+1)的值是______. *(a+5)的值是_________.
4.若有以下说明和语句，int c[4][5],(*p)[5];p=c;能正确引用c数组元素的是______.
A) p+1 B) *(p+3) C) *(p+1)+3 D) *(p[0]+2)
5.若有定义：int a[2][3],则对a数组的第i行j列元素地址的正确引用为______. a)*(a[i]+j) b)(a+i) c)*(a+j) d)a[i]+j
6.若有以下定义:int a[2][3]={2,4,6,8,10,12};则a[1][0]的值是_____. *(*(a+1)+0)的值是________.
7.有以下定义
char a[10],*b=a;
不能给数组a输入字符串的语句是
A)gets(a) B)gets(a[0]) C)gets(&a[0]); D)gets(b);
8.下面程序段的运行结果是_________.
char *s=“abcde”;
s+=2;printf(“%d”,s);
a)cde b)字符'c' c)字符'c'的地址 d)无确定的输出结果
9.以下程序段中，不能正确赋字符串(编译时系统会提示错误)的是
A) char s[10]=“abcdefg”; B) char t=“abcdefg”,*s=t;
C) char s[10];s=“abcdefg”; D) char s[10];strcpy(s,“abcdefg”);
10.设已有定义: char *st=“how are you”; 下列程序段中正确的是
A) char a[11], *p; strcpy(p=a+1,&st[4]);
B) char a[11]; strcpy(++a, st);
C) char a[11]; strcpy(a, st);
D) char a, *p; strcpy(p=&a[1],st+2);
篇8：C语言指针讲解
指针是C语言的一种数据类型，类似于C中的其他类型，例如int ,char 等，既然指针是一种类型，当我们定义该类型变量，该类型变量就称为指针变量。
C中有了指针就有了指向。指向：指针变量指向本身保存的内容（地址或指针）所表示的内存单元。
C语言指针是一个特殊的变量，其里面储存的数值被解释成为内存里的一个地址。
在计算机中，所有对数据的操作，都是通过其地址进行的，指针让程序的效率更高，代码更少。
在学习指针的时间，一定要理解并区分指针的四个感念：指针的类型，指针所指向的类型，指针的值，指针本身所占据的内存区。
指针变量定义的一般形式：类型说明符* 变量名。 类型说明符：表示该指针变量指向的变量的数据类型，并且该指针变量只能指向该数据类型的变量。这是指针变量的特征。
*:表示该变量的指针变量。这也是指针变量的特征。
变量名：表示指针变量的名称。
例如：char *pstu; *表示pstu是一个指针变量，char是指针变量pstu指向的变量的数据类型。整个语句表示定义了一个指向char类型变量的指针变量。但具体pstu指向哪个char类型的变量，这就要看在使用pstu时，给pstu赋予的值，值是什么就指向哪。
讲指针不得不说的两个运算符。取地址运算符&和取值运算符*.通过取地址运算符&可以获得某个变量的地址，用取值运算符可以获得某个地址中存放的数据。
指针变量使用前，先定义，给指针初始化以后，也就是赋值以后才能使用。在赋值时只能赋兼容类型的值。
例如：
#include
#include
void main（）
{
int name,stuName=1;
int *pStu;
int *pNew;
pStu = &stuName;
pNew = pStu;
name = *pNew;
printf（“%dn%dn%dn%dnn”,stuName,*pStu,name,*pNew）；
printf（“%dn%dn%dn%dnn”,&stuName,&pStu,&name,&pNew）；
printf（“%dn%dn”,pStu,pNew）；
}
从打印的值完全可以理解内存中存放的是什么。
简单修改：
#include
#include
void main（）
{
int name,stuName=1;
int *pStu = NULL;
int *pNew = NULL;
pStu = &stuName;
pNew = *（&pStu）；
name = *pNew;
*pStu =100;
printf（“%dn%dn%dn%dnn”,stuName,*pStu,name,*pNew）；
printf（“%dn%dn%dn%dnn”,&stuName,&pStu,&name,&pNew）；
printf（“%dn%dn”,pStu,pNew）；
}
指针与整数的加法。主要用于数组中。
int arr []= {1,2,3,4,5};<罚www.2cto.com/kf/ware/vc/“ target=”_blank“ class=”keylink“>vcD4KPHA+aW50ICpwTmV3ID0gYXJyOzwvcD4KPHA+cE5ldyYjNDM7JiM0Mzs7PC9wPgo8cD5wTmV3ID0gcE5ldyAmIzQzOyAyOzwvcD4KPHA+yv3X6cP7vs3Kx7Xa0ru49sr91+nUqsvYtcS12Na3oaMgaW50ICpwTmV3ID0gJmFtcDsgYXJyWzBdOzwvcD4KPHA+cE5ldyA9IHBOZXcgJiM0MzsgNzsgcE5ld7XE1rjP8tLRvq3Uvb3no6y+38zl1rjP8rK71qq1wKOsv8nE3MrH0tG05tTatcS12Na3u/LOtNaqtdjWt6Os1NrKudPDJiMyMDU0MDvKx7vht6LJ+s601qq1xLTtzvOho9TayrnTw9a41euy2df3yrGjrNK7tqjSqtei0uLKx7fxs6yz9sHLyv3X6bXEtPPQoaGjPGJyPgo8L3A+CjxwPsn5w/fSu7j21rjV66Gj1rjV67Hkwb/Kx7Hkwb+hozwvcD4KPHA+yv3X6da41eujurrN1rjV67Hkwb/Tw7eou/mxvtK70fmhozwvcD4KPHA+1rjV68r91+mjutK7z7XB0Na4z/LNrNK7yv2+3cDg0M21xNa41eux5MG/tcS8r7rPo6yzxs6q1rjV68r91+mho9a41evK/dfptcTL+dPQ1KrL2La8ysfWuNXrseTBv6Gjy/zDx7HY0Ou+39PQz+DNrLXEtKK05sDg0M2jrLHY0OvWuM/yz+DNrLXEyv2+3cDg0M2hozwvcD4KPHA+wODQzcu1w/e3+yAgKsr91+nD+1vK/dfps6S2yF07PC9wPgo8cD7A/cjno7ppbnQgICAqYXJyWzVdOzwvcD4KPHA+Y2hhciAqc3RyW10gPSB7”Chain“,”Beijing“,”LongMai“};
-）常量指针（指向可以修改，指向对应的值不可以修改）
常量是形容词，指针是名词，以指针为中心的一个偏正结构短语，
这样看，常量指针本质是指针，常量修饰它，表示这个指针乃是一个指向常量的指针（变量）。
指针指向的对象是常量，那么这个对象不能被更改。
在C/C++中，常量指针是这样声明的：
1）const int *p;
2）int const *p;
常量指针的使用要注意，指针指向的对象不能通过这个指针来修改，可是仍然可以通过原来的声明修改，也就是说常量指针可以被赋值为变量的地址，之所以叫做常量指针，是限制了通过这个指针修改变量的值。
例如：
int a = 5,b=6;
const int *c = &a; // 这是合法的，非法的是对c的使用
c = &b; //合法
*c = 6; // 非法，但可以这样修改c指向的对象的值：a = 6;
const int *d = &b; // b是常量，d可以指向b,d被赋值为b的地址是合法的
二） 指针常量（指向不可以修改，指向对应的值可以修改）
指针是形容词，常量是名词。这回是以常量为中心的一个偏正结构短语。那么，指针常量的本质是一个常量，而用指针修饰它，那么说明这个常量的值应该是一个指针。
指针常量的值是指针，这个值因为是常量，所以不能被赋值。
在C/C++中，指针常量这样声明：
int a;
int *const b = &a; //const放在指针声明操作符的右侧
只要const位于指针声明操作符右侧，就表明声明的对象是一个常量，且它的内容是一个指针，也就是一个地址。上面的声明可以这么读，声明了一个常量b,它的值是变量a的地址（变量a的地址，不就是指向变量a的指针吗）。
因为指针常量是一个常量，在声明的时候一定要给它赋初始值。一旦赋值，以后这个常量再也不能指向别的地址。
虽然指针常量的值不能变，可是它指向的对象是可变的，因为我们并没有限制它指向的对象是常量。
因此，有这么段程序：
char *a = ”abcde1234“;
char *b = ”bcde";
char *const c = &a;
下面的操作是可以的。
a[0] = 'x'; // 我们并没有限制a为常量指针（指向常量的指针）
或者
*c[0] = 'x' // 与上面的操作一致
三）指向常量的指针常量（指向不可以修改，指向对应的值也不可以修改）
顾名思议，指向常量的指针常量就是一个常量，且它指向的对象也是一个常量。
因为是一个指针常量，那么它指向的对象当然是一个指针对象，而它又指向常量，说明它指向的对象不能变化。
在C/C++中，这么声明：
文档为doc格式
