指针详解

 指针和结构类型的关系
    可以声明一个指向结构类型对象的指针。
例十一：
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/C++编译器在排列数组的单元时，总是把各个数组单元存放在连续的存储区里，单元和单元之间没有空隙。但在存放结构对象的各个成员时，在某种编译环境下，可能会需要字对齐或双字对齐或者是别的什么对齐，需要在相邻两个成员之间加若干个“填充字节”，这就导致各个成员之间可能会有若干个字节的空隙。
    所以，在例十二中，即使*pstr访问到了结构对象ss的第一个成员变量a，也不能保证*(pstr+1)就一定能访问到结构成员b。因为成员a和成员b之间可能会有若干填充字节，说不定*(pstr+1)就正好访问到了这些填充字节呢。这也证明了指针的灵活性。要是你的目的就是想看看各个结构成员之间到底有没有填充字节，
    嘿，这倒是个不错的方法。
    通过指针访问结构成员的正确方法应该是象例十二中使用指针ptr的方法。

七。指针和函数的关系
    可以把一个指针声明成为一个指向函数的指针。
int fun1(char*,int);
int (*pfun1)(char*,int);
pfun1=fun1;
....
....
int a=(*pfun1)("abcdefg",7);//通过函数指针调用函数。
    可以把指针作为函数的形参。在函数调用语句中，可以用指针表达式来作为实参。
例十三：
int fun(char*);
int a;
char str[]="abcdefghijklmn";
a=fun(str);
...
...
int fun(char*s)
{
int num=0;
for(int i=0;i {
num+=*s;s++;
}
return num;
}
    这个例子中的函数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。两者不一致，直接赋值的方法是不行的。至少在我的MSVC++6.0上，对指针的赋值语句要求赋值号两边的类型一致，所指向的类型也一致，其它的编译器上我没试过，大家可以试试。为了实现我们的目的，需要进行“强制类型转换”：
    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（十进制）
    编译一下吧。结果发现后面两条语句全是错的。那么我们的目的就不能达到了吗？不，还有办法：
    unsigned int a;
    TYPE *ptr;//TYPE是int，char或结构类型等等类型。
    ...
    ...
    a=某个数，这个数必须代表一个合法的地址；
    ptr=(TYPE*)a；//呵呵，这就可以了。
    严格说来这里的(TYPE*)和指针类型转换中的(TYPE*)还不一样。这里的(TYPE*)的意思是把无符号整数a的值当作一个地址来看待。上面强调了a的值必须代表一个合法的地址，否则的话，在你使用ptr的时候，就会出现非法操作错误。    
    想想能不能反过来，把指针指向的地址即指针的值当作一个整数取出来。完全可以。下面的例子演示了把一个指针的值当作一个整数取出来，然后再把这个整数当作一个地址赋给一个指针：
例十六：
int a=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所指向的存储区时是不安全的。至于为什么，读者结合例十七来想一想，应该会明白的。

十、指针与链表问题
红色部分所示的程序语句有问题，改正后的程序在下面。
list1.c

#include
#include

struct listNode{
    int data;
     struct listNode *nextPtr;
};
typedef struct listNode LISTNODE;
typedef LISTNODE * LISTNODEPTR;
void list(LISTNODEPTR *, int);
void printlist(LISTNODEPTR);
main()
{
    LISTNODEPTR newPtr=NULL;
    int i,a;
    for(i=0;i<3;i++){
      printf("please enter a number\n");
      scanf("%d,",&a);
      list(&newPtr,a);
      // 此处给的是newPtr的地址， 注意！
    }
      printlist(newPtr);

    free(newPtr);
     // 链表的释放不能这样写，这样，只释放了newPtr指向的一个节点。
     // 可以先找到链表的尾，然后反向释放；或者，利用 printlist的顺序释放，
     // 改函数printlist，或在此函数里释放。
    return 0;
}

void list(LISTNODEPTR *sPtr, int a)
{
    LISTNODEPTR newPtr,currentPtr;
    newPtr=malloc(sizeof(LISTNODEPTR));
    // 此处错， LISTNODEPTR 是指针类型，不是结构类型，
    // malloc返回void指针，应该强制转换类型，此处会告警不报错，但应有良好的编程风格与习惯。
    if(newPtr!=NULL){
        newPtr->data=a;
        newPtr->nextPtr=NULL;
         currentPtr=*sPtr;
    }
    if(currentPtr==NULL){
     // 此处条件不确切，因为currentPtr没有初始化，
     // 如newPtr一旦为NULL，此句及以下就有问题。
    newPtr->nextPtr=*sPtr;
    *sPtr=newPtr;}
     // 在第一个数来的时候，main里的newPtr通过sPtr被修改指向此节点。
     // 在第二个数来的时候，main里的newPtr通过sPtr被修改指向此节点。
     // 在第三个数来的时候，main里的newPtr通过sPtr被修改指向此节点。
     // 最后，main里的newPtr指向第三个数。
}

void printlist(LISTNODEPTR currentPtr)
{
    if(currentPtr==NULL)
      printf("The list is empty\n");
    else{
        printf("This list is :\n");
       while(currentPtr!=NULL){
            printf("%d-->",currentPtr->data);
            // main里的newPtr指向第三个数。你先打印了最后一个数。
             // currentPtr=currentPtr->nextPtr->data;
             // 此句非法， 类型不同， 有可能让你只循环一次，如data为0。
       }
       printf("NULL\n\n");
    }
}
    // 对类似程序能运行，但结果似是而非的情况，应该多利用跟踪调试，看变量的变化。


改正后的正确程序
#include
#include
struct listNode{
    int data;
    struct listNode *nextPtr;
};
typedef struct listNode LISTNODE;
typedef LISTNODE * LISTNODEPTR;

LISTNODEPTR list(LISTNODEPTR , int); // 此处不同
void printlist(LISTNODEPTR);
void freelist(LISTNODEPTR); // 增加

main()
{
    LISTNODEPTR newPtr=NULL;
    int i,a;
    for(i=0;i<3;i++){
        printf("please enter a number\n");
        scanf("%d,",&a);
        newPtr = list(newPtr,a); // 此处注意
    }
    printlist(newPtr);
    freelist(newPtr); // 此处
    return 0;
}

LISTNODEPTR list(LISTNODEPTR sPtr, int a)
{
    if ( sPtr != NULL )
        sPtr->nextPtr = list( sPtr->nextPtr, a ); // 递归，向后面的节点上加数据。
    else
    {
        sPtr =(LISTNODEPTR) malloc(sizeof(LISTNODE)); // 注意，是节点的尺寸,类型转换
        sPtr->nextPtr = NULL;
        sPtr->data = a;
    }
    return sPtr;
}

void freelist(LISTNODEPTR sPtr )
{
    if ( sPtr != NULL )
    {
        freelist( sPtr->nextPtr ); // 递归， 先释放后面的节点
        free( sPtr ); // 再释放本节点
    }
    else //
    return ; // 此两行可不要
}

void printlist(LISTNODEPTR currentPtr)
{
    if(currentPtr==NULL)
        printf("The list is empty\n");
    else
    {
        printf("This list is :\n");
        while(currentPtr!=NULL)
        {
            printf("%d-->",currentPtr->data);
            currentPtr=currentPtr->nextPtr; // 这里不一样
        }
        printf("NULL\n\n");
    }