一.对于众多人提出的c/c++中指针难学的问题做个总结： 
　　指针学习不好关键是概念不清造成的，说的简单点就是书没有认真看，指针的学习犹如人在学习饶口令不多看多学多练是不行的，下面是两个很经典的例子，很多书上都有,对于学习的重点在于理解*x和x的理解，他们并不相同，*x所表示的其实就是变量a本身，x表示的是变量a在内存中的地址，如果想明白可以输出观察cout<<*x"|"x;，当定义了int *x;后对x=&a的理解的问题。仔细阅读和联系下面的两个例子我想指针问题就不是难点了！ 

#include    
main() 
{ 
int a,b; /* 定义a,b两个整形变量用于输入两个整数 */ 
int *point_1,*point_2,*temp_point; /* 定义三个指针变量 */ 
scanf("%d,%d",&a,&b); /* 格式化输入a,b的值 */ 
point_1=&a; /* 把指针变量point_1的值指向变量a的地址 */ 
point_2=&b; /* 把指针变量point_2的值指向变量b的地址 */ 
if (a { 
    temp_point=point_1; /* 这里的temp_point是用于临时存储point_1的值也就是变量a的地址的 */ 
    point_1=point_2; /* 把point_2的值赋予point_1 */ 
    point_2=temp_point; 
    /* 由于point_1的值已经改变无法找到,利用前面临时存储的也就是temp_point找回原point_1的值赋予point_2,打到把point_1和point_2值对换的目的*/ 
} 
printf("%d,%d",*point_1,*point_2); /* 利用*point_1和*point_2也就是分辨指向b和a的方法把值显示屏幕上 */ 
}   
/* 此题需要注意和了解是的此法并没有改变变量a,b的值只是利用指针变量分别存储a和b的地址,然后再把那两个指针变量的值对换一下其实就是存储在指针变量里面a与b的地址对换,在利用*point_1和*point_2的方式把调换后的值显示出来这里的*point_1实际就是a,此中算法并非真的改变a,b的值,而是利用指针进行地址交换达到大小排序的目的. */ 

#include  
main() 
{ 
int a,b; /* 定义a,b两个整形变量用于输入两个整数 */ 
int *point_1,*point_2; /* 定义三个指针变量 */ 
scanf("%d,%d",&a,&b); /* 格式化输入a,b的值 */ 
point_1 = &a; /* 把指针变量point_1的值指向变量a的地址 */ 
point_2 = &b; /* 把指针变量point_2的值指向变量b的地址 */ 
compositor(point_1,point_2); /* 调用自定义的排序涵数,把a,b的地址传递给point_1和point_2 */ 
printf("%d,%d",a,b); /* 打印出a,b的值 */ 
} 
static compositor(p1,p2) 
int *p1,*p2; /* 定义形式参数p1,p2为指针变量 */ 
{ 
int temp; /* 建立临时存储变量 */ 
    if (*p1<*p2) /* 如果*p1注意这里的*p1和*p2其实就是a和b */ 
    { 
        temp = *p1; /* 利用变量temp用于临时存储*p1和就是a的值 */ 
        *p1 = *p2; /* 将*p1的值也就是a的值换成*p2的值也就是b的值,等价于a=b */ 
        *p2 = temp; /* 将*p2的值也就是temp的值等价于b=temp */ 
    } 
}   
/* 注意:此题与上题不同的是,直接改变了a于b的值达到真实改变的目的 */

二．C++指针使用方法解惑

“void ClearList(LNode * & HL)”

仔细看一下这种声明方式，确实有点让人迷惑。
下面以void func1（ MYCLASS *&pBuildingElement ）； 为例来说明这个问题。在某种意义上，"*"和"&"是意思相对的两个东西，把它们放在一起有什么意义呢？。为了理解指针的这种做法，我们先复习一下C/C++编程中无所不在的指针概念。我们都知道MYCLASS*的意思：指向某个对象的指针，此对象的类型为MYCLASS。 Void func1（MYCLASS *pMyClass）； 

// 例如： MYCLASS* p = new MYCLASS；
func1（p）； 
上面这段代码的这种处理方法想必谁都用过，创建一个MYCLASS对象，然后将它传入func1函数。现在假设此函数要修改pMyClass： void func1（MYCLASS *pMyClass）
{
DoSomething（pMyClass）；
pMyClass = // 其它对象的指针
}

　　第二条语句在函数过程中只修改了pMyClass的值。并没有修改调用者的变量p的值。如果p指向某个位于地址0x008a00的对象，当func1返回时，它仍然指向这个特定的对象。（除非func1有bug将堆弄乱了，完全有这种可能。）

　　现在假设你想要在func1中修改p的值。这是你的权利。调用者传入一个指针，然后函数给这个指针赋值。以往一般都是传双指针，即指针的指针，例如，CMyClass**。
MYCLASS* p = NULL；
func1（&p）；

void func1（MYCLASS** pMyClass）；
{
*pMyClass = new MYCLASS；
……
}
　　调用func1之后，p指向新的对象。在COM编程中，你到处都会碰到这样的用法--例如在查询对象接口的QueryInterface函数中：
interface ISomeInterface {
HRESULT QueryInterface（IID &iid, void** ppvObj）； 
……
}； 
LPSOMEINTERFACE p=NULL； 
pOb->QueryInterface（IID_SOMEINTERFACE, &p）； 

　　此处，p是SOMEINTERFACE类型的指针，所以&p便是指针的指针，在QueryInterface返回的时候，如果调用成功，则变量p包含一个指向新的接口的指针。

如果你理解指针的指针，那么你肯定就理解指针引用，因为它们完全是一回事。如果你象下面这样声明函数：
void func1（MYCLASS *&pMyClass）；
{
pMyClass = new MYCLASS； 
……
}

其实，它和前面所讲得指针的指针例子是一码事，只是语法有所不同。传递的时候不用传p的地址&p，而是直接传p本身：

　　MYCLASS* p = NULL；
　　func1（p）；

　　在调用之后，p指向一个新的对象。一般来讲，引用的原理或多或少就象一个指针，从语法上看它就是一个普通变量。所以只要你碰到*&，就应该想到**。也就是说这个函数修改或可能修改调用者的指针，而调用者象普通变量一样传递这个指针，不使用地址操作符&。

　　至于说什么场合要使用这种方法，我会说，极少。MFC在其集合类中用到了它--例如，CObList，它是一个Cobjects指针列表。 

Class CObList : public Cobject {
……

// 获取/修改指定位置的元素
Cobject*& GetAt（POSITION position）；
Cobject* GetAt（POSITION position） const；
}；
　　这里有两个GetAt函数，功能都是获取给定位置的元素。区别何在呢？

　　区别在于一个让你修改列表中的对象，另一个则不行。所以如果你写成下面这样： Cobject* pObj = mylist.GetAt（pos）；

　　则pObj是列表中某个对象的指针，如果接着改变pObj的值： pObj = pSomeOtherObj；

　　这并改变不了在位置pos处的对象地址，而仅仅是改变了变量pObj。但是，如果你写成下面这样： Cobject*& rpObj = mylist.GetAt（pos）；

　　现在，rpObj是引用一个列表中的对象的指针，所以当改变rpObj时，也会改变列表中位置pos处的对象地址--换句话说，替代了这个对象。这就是为什么CObList会有两个GetAt函数的缘故。一个可以修改指针的值，另一个则不能。注意我在此说的是指针，不是对象本身。这两个函数都可以修改对象，但只有*&版本可以替代对象。 

在C/C++中引用是很重要的，同时也是高效的处理手段。所以要想成为C/C++高手，对引用的概念没有透彻的理解和熟练的应用是不行的。

 三．数据指针

在C/C++语言中一直是很受宠的；几乎找不到一个不使用指针的C/C++应用。用于存储数据和程序的地址，这是指针的基本功能。用于指向整型数，用整数指针(int*)；指向浮点数用浮点数指针(float*)；指向结构，用对应的结构指针(struct xxx *)；指向任意地址，用无类型指针(void*)。
    有时候，我们需要一些通用的指针。在C语言当中，(void*) 可以代表一切；但是在C++中，我们还有一些比较特殊的指针，无法用(void*)来表示。事实上，在C++中，想找到一个通用的指针，特别是通用的函数指针简直是一个“不可能任务”。
   
    C++是一种静态类型的语言，类型安全在C++中举足轻重。在C语言中，你可以用void*来指向一切；但在C++中，void*并不能指向一切，就算能，也失去了类型安全的意义了。类型安全往往能帮我们找出程序中潜在的一些BUG。
   
    下面我们来探讨一下，C++中如何存储各种类型数据的指针。

C++指针探讨 （一）数据指针      沐枫网志
   
    1.  数据指针
     数据指针分为两种：常规数据指针和成员数据指针
     
    1.1 常规数据指针 
     这个不用说明了，和C语言一样，定义、赋值是很简单明了的。常见的有：int*, double* 等等。
     如：

     int value = 123;
     int * pn = &value;

         
    1.2 成员数据指针
     有如下的结构：

     struct MyStruct
     {
       int key;
       int value;
     };

   
     现在有一个结构对象:

     MyStruct me;
     MyStruct* pMe = &me;

   
     我们需要 value 成员的地址，我们可以：

     int * pValue = &me.value;
     //或
     int * pValue = &pMe->value; 

   
     当然了，这个指针仍然是属于第一种范筹----常规数据指针。
     
     好了，我们现在需要一种指针，它指向MyStruct中的任一数据成员，那么它应该是这样的子：

     int MyStruct::* pMV = &MyStruct::value;
     //或
     int MyStruct::* pMK = &MyStruct::key;

   
     这种指针的用途是用于取得结构成员在结构内的地址。我们可以通过该指针来访问成员数据：

     int value = pMe->*pMV; // 取得pMe的value成员数据。
     int key = me.*pMK; // 取得me的key成员数据。

   
     那么，在什么场合下会使用到成员数据指针呢？
    确实，成员指针本来就不是一种很常用的指针。不过，在某些时候还是很有用处的。我们先来看看下面的一个函数：

  int sum(MyStruct* objs, int MyStruct::* pm, int count)
  {
      int result = 0;
      for(int i = 0; i < count; ++i)
          result += objs[i].*pm;
      return result;
  }

     这个函数的功能是什么，你能看明白吗？它的功能就是，给定count个MyStruct结构的指针，计算出给定成员数据的总和。有点拗口对吧？看看下面的程序，你也许就明白了：
     

     MyStruct me[10] =
     {
      {1,2},{3,4},{5,6},{7,8},{9,10},{11,12},{13,14},{15,16},{17,18},{19,20}
     };     
     int sum_value = sum(me, &MyStruct::value, 10);
     //计算10个MyStruct结构的value成员的总和： sum_value 值 为 110     (2+4+6+8++20)
     int sum_key = sum(me, &MyStruct::key, 10);

   //计算10个MyStruct结构的key成员的总和：   sum_key 值 为 100       (1+3+5+7++19)

     也许，你觉得用常规指针也可以做到，而且更易懂。Ok，没问题：

     int sum(MyStruct* objs, int count)
     {
      int result = 0;
      for(int i = 0; i < count; ++i)
       result += objs[i].value;
      return result;
     }

你是想这么做吗？但这么做，你只能计算value，如果要算key的话，你要多写一个函数。有多少个成员需要计算的话，你就要写多少个函数，多麻烦啊。指针

四．C++指针使用

在下列函数声明中，为什么要同时使用*和&符号？以及什么场合使用这种声明方式?  

void func1( MYCLASS *&pBuildingElement ); 论坛中经常有人问到这样的问题。

 本文试图通过一些实际的指针使用经验来解释这个问题。 

仔细看一下这种声明方式，确实有点让人迷惑。在某种意义上，"*"和"&"是意思相对的两个东西，把它们放在一起有什么意义呢？。为了理解指针的这种做法，我们先复习一下C/C++编程中无所不在的指针概念。我们都知道MYCLASS*的意思：指向某个对象的指针，此对象的类型为MYCLASS。 void func1(MYCLASS *pMyClass);  

// 例如： MYCLASS* p = new MYCLASS; 

func1(p); 

上面这段代码的这种处理方法想必谁都用过，创建一个MYCLASS对象，然后将它传入func1函数。现在假设此函数要修改pMyClass： void func1(MYCLASS *pMyClass) 

{ 
DoSomething(pMyClass); 
pMyClass = // 其它对象的指针 
} 

第二条语句在函数过程中只修改了pMyClass的值。并没有修改调用者的变量p的值。如果p指向某个位于地址0x008a00的对象，当func1返回时，它仍然指向这个特定的对象。（除非func1有bug将堆弄乱了，完全有这种可能。） 

现在假设你想要在func1中修改p的值。这是你的权利。调用者传入一个指针，然后函数给这个指针赋值。以往一般都是传双指针，即指针的指针，例如，CMyClass**。 MYCLASS* p = NULL; 

func1(&p); 
void func1(MYCLASS** pMyClass); 
{ 
*pMyClass = new MYCLASS; 
…… 
} 

调用func1之后，p指向新的对象。在COM编程中，你到处都会碰到这样的用法--例如在查询对象接口的QueryInterface函数中： 
interface ISomeInterface { 
HRESULT QueryInterface(IID &iid, void** ppvObj); 
…… 
}; 

LPSOMEINTERFACE p=NULL; 
pOb->QueryInterface(IID_SOMEINTERFACE, &p); 

此处，p是SOMEINTERFACE类型的指针，所以&p便是指针的指针，在QueryInterface返回的时候，如果调用成功，则变量p包含一个指向新的接口的指针。 

如果你理解指针的指针，那么你肯定就理解指针引用，因为它们完全是一回事。如果你象下面这样声明函数： 
void func1(MYCLASS *&pMyClass); 
{ 
pMyClass = new MYCLASS; 
…… 
} 
其实，它和前面所讲得指针的指针例子是一码事，只是语法有所不同。传递的时候不用传p的地址&p，而是直接传p本身： 
MYCLASS* p = NULL; 
func1(p); 
在调用之后，p指向一个新的对象。一般来讲，引用的原理或多或少就象一个指针，从语法上看它就是一个普通变量。所以只要你碰到*&，就应该想到**。也就是说这个函数修改或可能修改调用者的指针，而调用者象普通变量一样传递这个指针，不使用地址操作符&。 

至于说什么场合要使用这种方法，我会说，极少。MFC在其集合类中用到了它--例如，CObList，它是一个CObjects指针列表。 
class CObList : public CObject { 
…… 
// 获取/修改指定位置的元素 
CObject*& GetAt(POSITION position); 
CObject* GetAt(POSITION position) const; 
}; 
这里有两个GetAt函数，功能都是获取给定位置的元素。区别何在呢？ 

区别在于一个让你修改列表中的对象，另一个则不行。所以如果你写成下面这样： CObject* pObj = mylist.GetAt(pos); 

则pObj是列表中某个对象的指针，如果接着改变pObj的值： pObj = pSomeOtherObj; 

这并改变不了在位置pos处的对象地址，而仅仅是改变了变量pObj。但是，如果你写成下面这样： CObject*& rpObj = mylist.GetAt(pos); 

现在，rpObj是引用一个列表中的对象的指针，所以当改变rpObj时，也会改变列表中位置pos处的对象地址--换句话说，替代了这个对象。这就是为什么CObList会有两个GetAt函数的缘故。一个可以修改指针的值，另一个则不能。注意我在此说的是指针，不是对象本身。这两个函数都可以修改对象，但只有*&版本可以替代对象。 

在C/C++中引用是很重要的，同时也是高效的处理手段。所以要想成为C/C++高手，对引用的概念没有透彻的理解和熟练的应用是不行的。

五．新手学习之浅析一下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；恢复栈，出栈
　　ret；退出函数
　　example2（）：
　　push bp；入栈
　　
　　mov bp,sp
　　sub sp,02
　　mov word ptr [bp-02],0005
　　
　　mov ax,[bp-02]；传递参数
　　
　　add [bp+04],ax;相加
　　
　　lea ax,[bp+04];问题就出在这里
　　.
　　.
　　mov sp,bp
　　
　　pop bp；恢复栈，出栈
　　ret；退出函数
　　对比之后看出来了吧？ax应该是存储的是结果的地址。而在example2（）中，返回的却是[bp+04]的内容，因此指针指向了一个不确定的地方，由此产生的指针悬挂。example1（）中，ax返回了正确的结果的地址。4、 内存问题：使用指针注意内存的分配和边界。使用指针过程中应该给变量一个适当的空间，以免产生不可见的错误。请看以下代码：
　　#include “iostream.h”
　　void main()
　　{
　　char *a1;
　　char *a2;
　　cin >>a1;
　　cin >>a2;
　　cout <<”a1=”<
　　cout <<”a2=”<
　　}
　　输入：abc
　　123
　　输出：
　　a1=123
　　a2=
　　Null pointer assignment
　　指针指向了“空”。解决办法就是分配适当的内存给这两个字符串。修正后的代码
　　如下：
　　#include “iostream.h”
　　void main()
　　{
　　char *a1;
　　char *a2;
　　a1=new char [10];
　　a2=new char [10];
　　cin >>a1;
　　cin >>a2;
　　cout <<”a1=”<
　　cout <<”a2=”<
　　delete(a1);注意,别忘了要释放内存空间
　　delete(a2);
　　}
　　到此就能输出正确的结果了。分配了适当的内存之后要注意释放内参空间，同时还应该注意不要超出所分配的内存的大小，否则会有溢出现象产生，导致不可预料的结果。
　　 5、 关于特殊的指针——引用　　
　　引用有时候应用起来要比指针要灵活，用它做返回的时候是不产生任何变量的副本的这样减小了内存的占用，提高执行的速度。引用使用起来要比指针好理解，比较直观。当引用作为参数时，不会改变参数的地址，因此可以作为左值。
　　下面请看一个例子：
　　#include “iostream.h”
　　char ch[5]=”ABCD”;
　　char &example(int b)
　　{
　　return ch;
　　}
　　void main()
　　{
　　cout <<”ch=”<
　　example(2)=”c”;
　　cout<<”ch=”<
　　}
　　输出结果：
　　ch=ABCD
　　ch=ABcD
　　在实际编程过程中，可以灵活地引用或指针，尽量提高程序的可读性和执行效率。
　　三、小结：
　　指针是学习c/c++的重点难点，主要原因是指针较为抽象，不容易理解。使用指针千万要明白让指针指向什么地方，如何让指针指向正确的地方。在深入系统底层之中需要应用到大量的指针，因此需要理解好指针的基本概念，例如：指针类型和指针所指向的类型。平时应该对留心观察，了解程序的工作过程，必要时候可以对程序进行反汇编，加深对指针的理解，这种方法同样适合学别的编程方面的知识。
　　四、结束：
　　指针的应用是很广泛的，利用指针可以做很多事情，要成为一个好的程序员，必须对指针有比较深刻的了解。写本文的目的在于让大家对指针有更深一层的了解，提高指针的应用能力，内容大都是我在实际编程中遇到的问题。相信能给大家一定的帮助。

六．C++中关于指针入门的最好的文章

什么是指针？
　　其实指针就像是其它变量一样，所不同的是一般的变量包含的是实际的真实的数据，而指针是一个指示器，它告诉程序在内存的哪块区域可以找到数据。这是一个非常重要的概念，有很多程序和算法都是围绕指针而设计的，如链表。
　　开始学习
　　如何定义一个指针呢？就像你定义一个其它变量一样，只不过你要在指针名字前加上一个星号。我们来看一个例子：下面这个程序定义了两个指针，它们都是指向整型数据。
　　int* pNumberOne;
　　int* pNumberTwo;
　　你注意到在两个变量名前的“p”前缀了吗？这是程序员通常在定义指针时的一个习惯，以提高便程序的阅读性，表示这是个指针。现在让我们来初始化这两个指针：
　　pNumberOne = &some_number;
　　pNumberTwo = &some_other_number;　　
　　&号读作“什么的地址”，它表示返回的是变量在内存中的地址而不是变量本身的值。在这个例子中，pNumberOne 等于some_number的地址，所以现在pNumberOne指向some_number。 如果现在我们在程序中要用到some_number，我们就可以使用pNumberOne。　　
　　我们来学习一个例子：　　
　　在这个例子中你将学到很多，如果你对指针的概念一点都不了解，我建议你多看几遍这个例子，指针是个很复杂的东西，但你会很快掌握它的。　　
　　这个例子用以增强你对上面所介绍内容的了解。它是用C编写的(注：原英文版是用C写的代码，译者重新用C++改写写了所有代码，并在DEV C++ 和VC++中编译通过！）　　
　　#include 　　
　　void main()
　　{　　// 声明变量：
　　int nNumber;
　　int *pPointer;
　　// 现在给它们赋值：　
　　nNumber = 15;
　　pPointer = &nNumber;
　　//打印出变量nNumber的值：
　　cout<<"nNumber is equal to :"<< nNumber< // 现在通过指针改变nNumber的值：
　　*pPointer = 25;
　　//证明nNumber已经被上面的程序改变
//重新打印出nNumber的值:　　
　　cout<<"nNumber is equal to :"< 　　}
　　通读一下这个程序，编译并运行它，务必明白它是怎样工作的。如果你完成了，准备好，开始下一小节。
　　陷井！
　　试一下，你能找出下面这段程序的错误吗？
　　#include
　　int *pPointer;
　　void SomeFunction();
　　{
　　int nNumber;
　　nNumber = 25;　　
　　//让指针指向nNumber:
　　pPointer = &nNumber;
　　}
　　
　　void main()
　　{
　　SomeFunction(); //为pPointer赋值　　
　　//为什么这里失败了?为什么没有得到25　　
　　cout<<"Value of *pPointer: "<<*pPointer< 　　}
　　这段程序先调用了SomeFunction函数，创建了个叫nNumber的变量，接着让指针pPointer指向了它。可是问题出在哪儿呢？当函数结束后，nNumber被删掉了，
　　因为这一个局部变量。局部变量在定义它的函数执行完后都会被系统自动删掉。也就是说当SomeFunction 函数返回主函数main()时，这个变量已经被删掉，但pPointer还指着变量曾经用过的但现在已不属于这个程序的区域。如果你还不明白，你可以再读读这个程序，注意它的局部变量和全局变量，这些概念都非常重要。
　　但这个问题怎么解决呢？答案是动态分配技术。注意这在C和C++中是不同的。由于大多数程序员都是用C++，所以我用到的是C++中常用的称谓。
　　　动态分配　　
　　动态分配是指针的关键技术。它是用来在不必定义变量的情况下分配内存和让指针去指向它们。尽管这么说可能会让你迷惑，其实它真的很简单。下面的代码就是一个为一个整型数据分配内存的例子：　　
　　int *pNumber;
　　pNumber = new int;　　
　　第一行声明一个指针pNumber。第二行为一个整型数据分配一个内存空间，并让pNumber指向这个新内存空间。下面是一个新例，这一次是用double双精型：　　
　　double *pDouble;
　　pDouble = new double;　　
　　这种格式是一个规则，这样写你是不会错的。　　
　　但动态分配又和前面的例子有什么不同呢？就是在函数返回或执行完毕时，你分配的这块内存区域是不会被删除的所以我们现在可以用动态分配重写上面的程序：　　
　　#include 　　
　　int *pPointer;　　
　　void SomeFunction()
　　{　　// 让指针指向一个新的整型
　　　pPointer = new int;
　　*pPointer = 25;
　　}　　
　　void main()
　　{
　　SomeFunction(); // 为pPointer赋值　　
　　cout<<"Value of *pPointer: "<<*pPointer< 　　}
　　通读这个程序，编译并运行它，务必理解它是怎样工作的。当SomeFunction调用时，它分配了一个内存，并让pPointer指向它。这一次，当函数返回时，新的内存区域被保留下来，所以pPointer始终指着有用的信息，这是因为了动态分配。但是你再仔细读读上面这个程序，虽然它得到了正确结果，可仍有一个严重的错误。
　　分配了内存，别忘了回收
　　太复杂了，怎么会还有严重的错误！其实要改正并不难。问题是：你动态地分配了一个内存空间，可它绝不会被自动删除。也就是说，这块内存空间会一直存在，直到你告诉电脑你已经使用完了。可结果是，你并没有告诉电脑你已不再需要这块内存空间了，所以它会继续占据着内存空间造成浪费，甚至你的程序运行完毕，其它程序运行时它还存在。当这样的问题积累到一定程度，最终将导致系统崩溃。所以这是很重要的，在你用完它以后，请释放它的空间，如：　　
　　delete pPointer;　　
　　这样就差不多了，你不得不小心。在这你终止了一个有效的指针（一个确实指向某个内存的指针）。下面的程序，它不会浪费任何的内存：　　
　　#include 　　
　　int *pPointer;　　
　　void SomeFunction()
　　{　　// 让指针指向一个新的整型
　　pPointer = new int;
　　*pPointer = 25;
　　}　　
　　void main()
　　{
　　SomeFunction(); //为pPointer赋值
　　cout<<"Value of *pPointer: "<<*pPointer< 　　delete pPointer;
　　}　　
　　只有一行与前一个程序不同，但就是这最后一行十分地重要。如果你不删除它，你就会制造一起“内存漏洞”，而让内存逐渐地泄漏。(译者:假如在程序中调用了两次SomeFunction，你又该如何修改这个程序呢？请读者自己思考)
　　传递指针到函数
　　传递指针到函数是非常有用的，也很容易掌握。如果我们写一个程序，让一个数加上5,看一看这个程序完整吗？：
　　#include
　　void AddFive(int Number)
　　{
　　Number = Number + 5;
　　}　　
　　void main()
　　{
　　int nMyNumber = 18;　　
　　cout<<"My original number is "< 　　AddFive(nMyNumber);
　　cout<<"My new number is "<//得到了结果23吗？问题出在哪儿？　　
　　}　　
　　问题出在函数AddFive里用到的Number是变量nMyNumber的一个副本而传递给函数，而不是变量本身。因此， " Number = Number + 5" 这一行是把变量的副本加了5，而原始的变量在主函数main()里依然没变。试着运行这个程序，自己去体会一下。要解决这个问题，我们就要传递一个指针到函数，所以我们要修改一下函数让它能接受指针：把'void AddFive(int Number)' 改成 'void AddFive(int*Number)'　。下面就是改过的程序，注意函数调用时要用＆号，以表示传递的是指针：　　
　　#include
　　void AddFive(int* Number)
　　{
　　*Number = *Number + 5;
　　}　　
　　void main()
　　{
　　int nMyNumber = 18;　　
　　cout

七．我眼中的指针--学习指针不可少的好文章

我眼中的指针--学习指针不可少的好文章 
为初学者服务。这是我的帖子的宗旨。我也是个初学者（强调了无数遍了），我以我的理解把初学者觉得难懂的东西用浅显的语言写出来。由于小学时语文没学好，所以竭尽全力也未必能达到这个目的。尽力而为吧。 
指针是c和c++中的难点和重点。我只精通dos下的basic。c语言的其它各种特性，在basic中都有类似的东西。只有指针，是baisc所不具备的。指针是c的灵魂。 
我不想重复大多数书上说得很清楚的东西，我只是把我看过的书中说得不清楚或没有说，而我又觉得我理解得有点道理的东西写出来。我的目的是： 
1。通过写这些东西，把我脑袋中关于c的模糊的知识清晰化。 
2。给初学者们一点提示。 
3。赚几个经验值。（因为贴这些东西没有灌水之嫌啊） 

第一章。指针的概念 
指针是一个特殊的变量，它里面存储的数值被解释成为内存里的一个地址。要搞清一个指针需要搞清指针的四方面的内容：指针的类型，指针所指向的类型，指针的值或者叫指针所指向的内存区，还有指针本身所占据的内存区。让我们分别说明。 先声明几个指针放着做例子： 
例一： 
(1)int *ptr;
(2)char *ptr;
(3)int **ptr;
(4)int (*ptr)[3];
(5)int *(*ptr)[4];
如果看不懂后几个例子的话，请参阅我前段时间贴出的文?lt;<如何理解c和c++的复杂类型声明>>。 

1。 指针的类型。 
从语法的角度看，你只要把指针声明语句里的指针名字去掉，剩下的部分就是这个指针的类型。这是指针本身所具有的类型。让我们看看例一中各个指针的类型： 
(1)int *ptr; //指针的类型是int *
(2)char *ptr; //指针的类型是char * 
(3)int **ptr; //指针的类型是 int ** 
(4)int (*ptr)[3]; //指针的类型是 int(*)[3] 
(5)int *(*ptr)[4]; //指针的类型是 int *(*)[4] 
怎么样？找出指针的类型的方法是不是很简单？ 

2。指针所指向的类型。 
当你通过指针来访问指针所指向的内存区时，指针所指向的类型决定了编译器将把那片内存区里的内容当做什么来看待。从语法上看，你只须把指针声明语句中的指针名字和名字左边的指针声明符 * 去掉，剩下的就是指针所指向的类型。例如： 
(1)int *ptr; //指针所指向的类型是int 
(2)char *ptr; //指针所指向的的类型是char 
(3)int **ptr; //指针所指向的的类型是 int *
(4)int (*ptr)[3]; //指针所指向的的类型是 int()[3] 
(5)int *(*ptr)[4]; //指针所指向的的类型是 int *()[4] 
在指针的算术运算中，指针所指向的类型有很大的作用。 
指针的类型(即指针本身的类型)和指针所指向的类型是两个概念。当你对C越来越熟悉时，你会发现，把与指针搅和在一起的"类型"这个概念分成"指针的类型"和"指针所指向的类型"两个概念，是精通指针的关键点之一。我看了不少书，发现有些写得差的书中，就把指针的这两个概念搅在一起了，所以看起书来前后矛盾，越看越糊涂。 

3。 指针的值，或者叫指针所指向的内存区或地址。 
指针的值是指针本身存储的数值，这个值将被编译器当作一个地址，而不是一个一般的数值。在32位程序里，所有类型的指针的值都是一个32位整数，因为32位程序里内存地址全都是32位长。指针所指向的内存区就是从指针的值所代表的那个内存地址开始，长度为sizeof(指针所指向的类型)的一片内存区。以后，我们说一个指针的值是XX，就相 
当于说该指针指向了以XX为首地址的一片内存区域；我们说一个指针指向了某块内存区域，就相当于说该指针的值是这块内存区域的首地址。 
指针所指向的内存区和指针所指向的类型是两个完全不同的概念。在例一中，指针所指向的类型已经有了，但由于指针还未初始化，所以它所指向的内存区是不存在的，或者说是无意义的。 
以后，每遇到一个指针，都应该问问：这个指针的类型是什么？指针指向的类型是什么？该指针指向了哪里？ 
4。 指针本身所占据的内存区。 
指针本身占了多大的内存？你只要用函数sizeof(指针的类型)测一下就知道了。在32位平台里，指针本身占据了4个字节的长度。 指针本身占据的内存这个概念在判断一个指针表达式是否是左值时很有用。 

第二章。指针的算术运算 
指针可以加上或减去一个整数。指针的这种运算的意义和通常的数值的加减运算的意义是不一样的。例如： 
例二： 
1。 char a[20];
2。 int *ptr=a;
...
...
3。 ptr++;
在上例中，指针ptr的类型是int*,它指向的类型是int，它被初始化为指向整形变量a。接下来的第3句中，指针ptr被加了1，编译器是这样处理的：它把指针ptr的值加上了sizeof(int)，在32位程序中，是被加上了4。由于地址是用字节做单位的，故ptr所指向的地址由原来的变量a的地址向高地址方向增加了4个字节。 
由于char类型的长度是一个字节，所以，原来ptr是指向数组a的第0号单元开始的四个字节，此时指向了数组a中从第4号单元开始的四个字节。我们可以用一个指针和一个循环来遍历一个数组，看例子： 
例三： 
例三： 
int array[20];
int *ptr=array;
...
//此处略去为整型数组赋值的代码。 
...
for(i=0;i<20;i++)
{
(*ptr)++;
ptr++； 
}
这个例子将整型数组中各个单元的值加1。由于每次循环都将

八．指针详解

第一章。指针的概念 

指针是一个特殊的变量，它里面存储的数值被解释成为内存里的一个地址。 

要搞清一个指针需要搞清指针的四方面的内容：指针的类型，指针所指向的类型，指针的值或者叫指针所指向的内存区，还有指针本身所占据的内存区。让 我们分别说明。 先声明几个指针放着做例子： 
例一： 
(1)int*ptr; 
(2)char*ptr; 
(3)int**ptr; 
(4)int(*ptr)[3]; 
(5)int*(*ptr)[4]; 

1。指针的类型。 
从语法的角度看，你只要把指针声明语句里的指针名字去掉，剩下的部分就是这个指针的类型。这是指针本身所具有的类型。让我们看看例一中各个指针的类型： 
(1)int*ptr;//指针的类型是int* 
(2)char*ptr;//指针的类型是char* 
(3)int**ptr;//指针的类型是int** 
(4)int(*ptr)[3];//指针的类型是int(*)[3] 
(5)int*(*ptr)[4];//指针的类型是int*(*)[4] 
怎么样？找出指针的类型的方法是不是很简单？ 

2。指针所指向的类型。 
当你通过指针来访问指针所指向的内存区时，指针所指向的类型决定了编译器将把那片内存区里的内容当做什么来看待。从语法上看，你只须把指针声明语句中的指针名字和名字左边的指针声明符 *去掉，剩下的就是指针所指向的类型。例如： 
(1)int*ptr;//指针所指向的类型是int 
(2)char*ptr;//指针所指向的的类型是char 
(3)int**ptr;//指针所指向的的类型是int* 
(4)int(*ptr)[3];//指针所指向的的类型是int()[3] 
(5)int*(*ptr)[4];//指针所指向的的类型是int*()[4] 
在指针的算术运算中，指针所指向的类型有很大的作用。 
指针的类型(即指针本身的类型)和指针所指向的类型是两个概念。当你对C越来越熟悉时，你会发现，把与指针搅和在一起的"类型"这个概念分成"指针的类型"和"指针所指向的类型"两个概念，是精通指针的关键点之一。我看了不少书，发现有些写得差的书中，就把指针的这两个概念搅在一起了，所以看起书来前后矛盾，越看越糊涂。 

3。指针的值，或者叫指针所指向的内存区或地址。 
指针的值是指针本身存储的数值，这个值将被编译器当作一个地址，而不是一个一般的数值。在32位程序里，所有类型的指针的值都是一个32位整数，因为32位程序里内存地址全都是32位长。指针所指向的内存区就是从指针的值所代表的那个内存地址开始，长度为sizeof(指针所指向的类型)的一片内存区。以后，我们说一个指针的值是XX，就相当于说该指针指向了以XX为首地址的一片内存区域；我们说一个指针指向了某块内存区域，就相当于说该指针的值是这块内存区域的首地址。指针所指向的内存区和指针所指向的类型是两个完全不同的概念。在例一中 ，指针所指向的类型已经有了，但由于指针还未初始化，所以它所指向的内存区 是不存在的，或者说是无意义的。 以后，每遇到一个指针，都应该问问：这个指针的类型是什么？指针指向的类型是什么？该指针指向了哪里？ 

4。指针本身所占据的内存区。 
指针本身占了多大的内存？你只要用函数sizeof(指针的类型)测一下就知道了。在32位平台里，指针本身占据了4个字节的长度。 指针本身占据的内存这个概念在判断一个指针表达式是否是左值时很有用。 
第二章。指针的算术运算 
指针可以加上或减去一个整数。指针的这种运算的意义和通常的数值的加减运算的意义是不一样的。例如： 
例二： 
1。char a[20]; 
2。int *ptr=a; 
... 
... 
3。ptr++; 
在上例中，指针ptr的类型是int*,它指向的类型是int，它被初始化为指向整形变量a。接下来的第3句中，指针ptr被加了1，编译器是这样处理的：它把指针 ptr的值加上了sizeof(int)，在32位程序中，是被加上了4。由于地址是用字节做单位的，故ptr所指向的地址由原来的变量a的地址向高地址方向增加了4个字节。 
由于char类型的长度是一个字节，所以，原来ptr是指向数组a的第0号单元开始的四个字节，此时指向了数组a中从第4号单元开始的四个字节。我们可以用一个指针和一个循环来遍历一个数组，看例子： 
例三： 
int array[20]; 
int *ptr=array; 
... 
//此处略去为整型数组赋值的代码。 
... 
for(i=0;i<20;i++) 
{ 
        (*ptr)++; 
        ptr++； 
} 
这个例子将整型数组中各个单元的值加1。由于每次循环都将指针ptr加1，所以每次循环都能访问数组的下一个单元。 
再看例子： 
例四： 
1。char a[20]; 
2。int *ptr=a; 
... 
... 
3。ptr+=5; 
在这个例子中，ptr被加上了5，编译器是这样处理的：将指针ptr的值加上5乘sizeof(int)，在32位程序中就是加上了5乘4=20。由于地址的单位是字节，故现在的ptr所指向的地址比起加5后的ptr所指向的地址来说，向高地址方向移动了20个字节。在这个例子中，没加5前的ptr指向数组a的第0号单元开始的四个字节，加5后，ptr已经指向了数组a的合法范围之外了。虽然这种情况在应用上会出问题，但在语法上却是可以的。这也体现出了指针的灵活性。 
如果上例中，ptr是被减去5，那么处理过程大同小异，只不过ptr的值是被减去5乘sizeof(int)，新的ptr指向的地址将比原来的ptr所指向的地址向低地址方向移动了20个字节。 

总结一下，一个指针ptrold加上一个整数n后，结果是一个新的指针ptrnew， 
ptrnew的类型和ptrold的类型相同，ptrnew所指向的类型和ptrold所指向的类型也相同。ptrnew的值将比ptrold的值增加了n乘sizeof(ptrold所指向的类型)个字节。就是说，ptrnew所指向的内存区将比ptrold所指向的内存区向高地址方向移动了n乘sizeof(ptrold所指向的类型)个字节。一个指针ptrold减去一个整数n后，结果是一个新的指针ptrnew，ptrnew的类型和ptrold的类型相同，ptrnew所指向的类型和ptrold所指向的类型也相同。ptrnew的值将比ptrold的值减少了n乘sizeof(ptrold所指向的类型)个字节，就是说，ptrnew所指向的内存区将比ptrold所指向的内存区向低地址方向移动了n乘sizeof(ptrold所指向的类型)个字节。 

第三章。运算符&和* 
这里&是取地址运算符，*是...书上叫做"间接运算符"。&a的运算结果是一个指针，指针的类型是a的类型加个*，指针所指向的类型是a的类型，指针所指向的地址嘛，那就是a的地址。*p的运算结果就五花八门了。总之*p的结果是p所指向的东西，这个东西有这些特点：它的类型是p指向的类型，它所占用的地址是p所指向的地址。 
例五： 
int a=12; 
int b; 
int *p; 
int **ptr; 
p=&a;//&a的结果是一个指针，类型是int*，指向的类型是int，指向的地址是a的地址。 
*p=24;//*p的结果，在这里它的类型是int，它所占用的地址是p所指向的地址，显然，*p就是变量a。 
ptr=&p;//&p的结果是个指针，该指针的类型是p的类型加个*，在这里是int **。该指针所指向的类型是p的类型，这里是int*。该指针所指向的地址就是指针p自己的地址。

*ptr=&b;//*ptr是个指针，&b的结果也是个指针，且这两个指针的类型和所指向的类型是一样的，所以用&b来给*ptr赋值就是毫无问题的了。 
**ptr=34;//*ptr的结果是ptr所指向的东西，在这里是一个指针，对这个指针再做一次*运算，结果就是一个int类型的变量。 

第四章。指针表达式。 
一个表达式的最后结果如果是一个指针，那么这个表达式就叫指针表达式。下面是一些指针表达式的例子： 
例六： 
int a,b; 
int array[10]; 
int *pa; 
pa=&a;//&a是一个指针表达式。 
int**ptr=&pa;//&pa也是一个指针表达式。 
*ptr=&b;//*ptr和&b都是指针表达式。 
pa=array; 
pa++;//这也是指针表达式。 
例七： 
char*arr[20]; 
char**parr=arr;//如果把arr看作指针的话，arr也是指针表达式 
char*str; 
str=*parr;//*parr是指针表达式 
str=*(parr+1);//*(parr+1)是指针表达式 
str=*(parr+2);//*(parr+2)是指针表达式 

由于指针表达式的结果是一个指针，所以指针表达式也具有指针所具有的四个要素：指针的类型，指针所指向的类型，指针指向的内存区，指针自身占据的内存。

好了，当一个指针表达式的结果指针已经明确地具有了指针自身占据的内存的话，这个指针表达式就是一个左值，否则就不是一个左值。在例七中，&a不是一个左值，因为它还没有占据明确的内存。*ptr是一个左值，因为*ptr这个指针已经占据了内存，其实*ptr就是指针pa，既然pa已经在内存中有了自己的位置，那么*ptr当然也有了自己的位置。 

第五章。数组和指针的关系 
数组的数组名其实可以看作一个指针。看下例： 
例八： 
int array[10]={0,1,2,3,4,5,6,7,8,9},value; 
... 
... 
value=array[0];//也可写成：value=*array; 
value=array[3];//也可写成：value=*(array+3); 
value=array[4];//也可写成：value=*(array+4); 
上例中，一般而言数组名array代表数组本身，类型是int [10]，但如果把array看做指针的话，它指向数组的第0个单元，类型是int*，所指向的类型是数组单元的类型即int。因此*array等于0就一点也不奇怪了。同理，array+3是一个指向数组第3个单元的指针，所以*(array+3)等于3。其它依此类推。 
例九： 
char*str[3]={ 
"Hello,thisisasample!", 
"Hi,goodmorning.", 
"Helloworld" 
}; 
chars[80]； 
strcpy(s,str[0]);//也可写成strcpy(s,*str); 
strcpy(s,str[1]);//也可写成strcpy(s,*(str+1)); 
strcpy(s,str[2]);//也可写成strcpy(s,*(str+2)); 
上例中，str是一个三单元的数组，该数组的每个单元都是一个指针，这些指针各指向一个字符串。把指针数组名str当作一个指针的话，它指向数组的第0号单元，它的类型是char**，它指向的类型是char*。*str也是一个指针，它的类型是char*，它所指向的类型是char，它指向的地址是字符串"Hello,thisisasample!"的第一个字符的地址，即''H''的地址。str+1也是一个指针，它指向数组的第1号单元，它的类型是char**，它指向的类型是char*。*(str+1)也是一个指针，它的类型是char*，它所指向的类型是char，它指向"Hi,goodmorning."的第一个字符''H''，等等。 
下面总结一下数组的数组名的问题。声明了一个数组TYPEarray[n]，则数组名称array就有了两重含义：第一，它代表整个数组，它的类型是TYPE[n]；第二，它是一个指针，该指针的类型是TYPE*，该指针指向的类型是TYPE，也就是数组单元的类型，该指针指向的内存区就是数组第0号单元，该指针自己占有单独的内存区，注意它和数组第0号单元占据的内存区是不同的。该指针的值是不能修改的，即类似array++的表达式是错误的。在不同的表达式中数组名array可以扮演不同的角色。在表达式sizeof(array)中，数组名array代表数组本身，故这时sizeof函数 测出的是整个数组的大小。在表达式*array中，array扮演的是指针，因此这个表达式的结果就是数组第0号单元的值。sizeof(*array)测出的是数组单元的大小。表达式array+n（其中n=0，1，2，....。）中，array扮演的是指针，故array+n的结果是一个指针，它的类型是TYPE*，它指向的类型是TYPE，它指向数组第n号单元。故sizeof(array+n)测出的是指针类型的大小。 
例十： 
int array[10]; 
int(*ptr)[10]; 
ptr=&array; 
上例中ptr是一个指针，它的类型是int(*)[10]，他指向的类型是int[10]，我们用整个数组的首地址来初始化它。在语句ptr=&array中，array代表数组本身。 

本节中提到了函数sizeof()，那么我来问一问，sizeof(指针名称)测出的究竟是指针自身类型的大小呢还是指针所指向的类型的大小？答案是前者。例如： 
int(*ptr)[10]; 
则在32位程序中，有： 
sizeof(int(*)[10])==4 
sizeof(int[10])==40 
sizeof(ptr)==4 
实际上，sizeof(对象)测出的都是对象自身的类型的大小，而不是别的什么类型的大小。 

第六章。指针和结构类型的关系 

可以声明一个指向结构类型对象的指针。 
例十一： 
struct MyStruct 
{ 
 int a; 
 int b; 
 int c; 
}MyStruct ss={20,30,40};
//声明了结构对象ss，并把ss的三个成员初始化为20，30和40。 
MyStruct*ptr=&ss;
//声明了一个指向结构对象ss的指针。它的类型是MyStruct*,
//它指向的类型是MyStruct。 
int *pstr=(int*)&ss;//声明了一个指向结构对象ss的指针。但是它的 
//类型和它指向的类型和ptr是不同的。 

请问怎样通过指针ptr来访问ss的三个成员变量？ 
答案： 
ptr->a; 
ptr->b; 
ptr->c; 
又请问怎样通过指针pstr来访问ss的三个成员变量？ 
答案： 
*pstr；//访问了ss的成员a。 
*(pstr+1);//访问了ss的成员b。 
*(pstr+2)//访问了ss的成员c。 
呵呵，虽然我在我的MSVC++6.0上调式过上述代码，但是要知道，这样使用pstr来访问结构成员是不正规的，为了说明为什么不正规，让我们看看怎样通过指针来访问数组的各个单元： 
例十二： 
int array[3]={35,56,37}; 
int*pa=array; 
通过指针pa访问数组array的三个单元的方法是： 
*pa;//访问了第0号单元 
*(pa+1);//访问了第1号单元 
*(pa+2);//访问了第2号单元 
从格式上看倒是与通过指针访问结构成员的不正规方法的格式一样。所有的C编译器在排列数组的单元时，总是把各个数组单元存放在连续的存储区里，单元和单元之间没有空隙。但在存放结构对象的各个成员时，在某种编译环境下，可能会需要字对齐或双字对齐或者是别的什么对齐，需要在相邻两个成员之间加若干个"填充字节"，这就导致各个成员之间可能会有若干个字节的空隙。 所以，在例十二中，即使*pstr访问到了结构对象ss的第一个成员变量a，也不能保证*(pstr+1)就一定能访问到结构成员b。因为成员a和成员b之间可能会有若干填充字节，说不定*(pstr+1)就正好访问到了这些填充字节呢。这也证明了指针的灵活性。要是你的目的就是想看看各个结构成员之间到底有没有填充字节， 
嘿，这倒是个不错的方法。 通过指针访问结构成员的正确方法应该是象例十二中使用指针ptr的方法。 

第七章。指针和函数的关系 
可以把一个指针声明成为一个指向函数的指针。 
int fun1(char*,int); 
int(*pfun1)(char*,int); 
pfun1=fun1; 
.... 
.... 
inta=(*pfun1)("abcdefg",7);//通过函数指针调用函数。 
可以把指针作为函数的形参。在函数调用语句中，可以用指针表达式来作为实参。 
例十三： 
int fun(char*); 
int a; 
char str[]="abcdefghijklmn"; 
a=fun(str); 
... 
... 
int fun(char*s) 
{ 
int num=0; 
while(*s != ''\0'')
{
        num+=*s;
        s++; 
} 
retur nnum; 
} 
这个例子中的函数fun统计一个字符串中各个字符的ASCII码值之和。前面说了，数组的名字也是一个指针。在函数调用中，当把str作为实参传递给形参s后，实际是把str的值传递给了s，s所指向的地址就和str所指向的地址一致，但是str和s各自占用各自的存储空间。在函数体内对s进行自加1运算，并不意味着同时对str进行了自加1运算。 

第八章。指针类型转换 
当我们初始化一个指针或给一个指针赋值时，赋值号的左边是一个指针，赋值号的右边是一个指针表达式。在我们前面所举的例子中，绝大多数情况下，指针的类型和指针表达式的类型是一样的，指针所指向的类型和指针表达式所指向 
的类型是一样的。 
例十四： 
1。float f=12.3; 
2。float *fptr=&f; 
3。int*p; 
在上面的例子中，假如我们想让指针p指向实数f，应该怎么搞？是用下面的语句吗？ 
p=&f; 
不对。因为指针p的类型是int*，它指向的类型是int。

表达式&f的结果是一 
个指针，指针的类型是float*,它指向的类型是float。两者不一致，直接赋值的方法是不行的。为了实现我们的目的，需要进行"强制类型转换"： 
p=(int*)&f; 
如果有一个指针p，我们需要把它的类型和所指向的类型改为TYEP*和TYPE， 那么语法格式是： 
(TYPE*)p； 
这样强制类型转换的结果是一个新指针，该新指针的类型是TYPE*，它指向的类型是TYPE，它指向的地址就是原指针指向的地址。而原来的指针p的一切属性都没有被修改。 

一个函数如果使用了指针作为形参，那么在函数调用语句的实参和形参的结合过程中，也会发生指针类型的转换。 
例十五： 
void fun(char*); 
int a=125,b; 
fun((char*)&a); 
... 
... 
void fun(char*s) 
{ 
char c; 
c=*(s+3);*(s+3)=*(s+0);*(s+0)=c; 
c=*(s+2);*(s+2)=*(s+1);*(s+1)=c; 
} 

注意这是一个32位程序，故int类型占了四个字节，char类型占一个字节。函数fun的作用是把一个整数的四个字节的顺序来个颠倒。注意到了吗？在函数调用语句中，实参&a的结果是一个指针，它的类型是int*，它指向的类型是int。形参这个指针的类型是char*，它指向的类型是char。这样，在实参和形参的结合过程中，我们必须进行一次从int*类型到char*类型的转换。结合这个例子，我们可以这样来想象编译器进行转换的过程：编译器先构造一个临时指针char*temp，然后执行temp=(char*)&a，最后再把temp的值传递给s。所以最后的结果是：s的类型是char*,它指向的类型是char，它指向的地址就是a的首地址。 

我们已经知道，指针的值就是指针指向的地址，在32位程序中，指针的值其实是一个32位整数。那可不可以把一个整数当作指针的值直接赋给指针呢？就象下面的语句： 
unsigned int a; 
TYPE*ptr;//TYPE是int，char或结构类型等等类型。 
... 
... 
a=20345686; 
ptr=20345686;//我们的目的是要使指针ptr指向地址20345686（十进制） 
ptr=a;//我们的目的是要使指针ptr指向地址20345686（十进制） 
编译一下吧。结果发现后面两条语句全是错的。那么我们的目的就不能达到了吗？不，还有办法： 
unsignedinta; 
TYPE*ptr;//TYPE是int，char或结构类型等等类型。 
... 
... 
a=某个数，这个数必须代表一个合法的地址； 
ptr=(TYPE*)a；//呵呵，这就可以了。 
严格说来这里的(TYPE*)和指针类型转换中的(TYPE*)还不一样。这里的(TYPE*)的意思是把无符号整数a的值当作一个地址来看待。上面强调了a的值必须代表一个合法的地址，否则的话，在你使用ptr的时候，就会出现非法操作错误。 

想想能不能反过来，把指针指向的地址即指针的值当作一个整数取出来。完全可以。下面的例子演示了把一个指针的值当作一个整数取出来，然后再把这个整数当作一个地址赋给一个指针： 
例十六： 
inta=123,b; 
int*ptr=&a; 
char*str; 
b=(int)ptr;//把指针ptr的值当作一个整数取出来。 
str=(char*)b;//把这个整数的值当作一个地址赋给指针str。 

好了，现在我们已经知道了，可以把指针的值当作一个整数取出来，也可以把一个整数值当作地址赋给一个指针。 

第九章。指针的安全问题 
看下面的例子： 
例十七： 
char s=''a''; 
int*ptr; 
ptr=(int*)&s; 
*ptr=1298； 
指针ptr是一个int*类型的指针，它指向的类型是int。它指向的地址就是s的首地址。在32位程序中，s占一个字节，int类型占四个字节。最后一条语句不但改变了s所占的一个字节，还把和s相临的高地址方向的三个字节也改变了。这三个字节是干什么的？只有编译程序知道，而写程序的人是不太可能知道的。也许这三个字节里存储了非常重要的数据，也许这三个字节里正好是程序的一条代码，而由于你对指针的马虎应用，这三个字节的值被改变了！这会造成崩溃性的错误。让我们再来看一例： 
例十八： 
1。char a; 
2。int*ptr=&a; 
... 
... 
3。ptr++; 
4。*ptr=115; 
该例子完全可以通过编译，并能执行。但是看到没有？第3句对指针ptr进行自加1运算后，ptr指向了和整形变量a相邻的高地址方向的一块存储区。这块存储区里是什么？我们不知道。有可能它是一个非常重要的数据，甚至可能是一条代码。而第4句竟然往这片存储区里写入一个数据！这是严重的错误。所以在使用指针时，程序员心里必须非常清楚：我的指针究竟指向了哪里。 
在用指针访问数组的时候，也要注意不要超出数组的低端和高端界限，否则也会造成类似的错误。 
在指针的强制类型转换：ptr1=(TYPE*)ptr2中，如果sizeof(ptr2的类型)大于sizeof(ptr1的类型)，那么在使用指针ptr1来访问ptr2所指向的存储区时是安全的。如果sizeof(ptr2的类型)小于sizeof(ptr1的类型)，那么在使用指针ptr1 来访问ptr2所指向的存储区时是不安全的。至于为什么，读者结合例十七来想一想，应该会明白的。