第7章 指针和内存分配.txt

我自己整理的c语言教程 来自 c语言之家

   一个递归数据结构同样由它本身来定义。最简单和最常见的递归数据结构是(单向)链表，
  链表中的每一个元素都包含一个值和一个指向链表中下一个元素的指针。请看下例：
    struct string_list    
    {    
        char  *str；  /* string(inthiscase)*/
        struct string_list    *next；    
    }；
    此外还有双向链表(每个元素还包含一个指向链表中前一个元素的指针)、键树和哈希表等许多整洁的数据结构，一本较好的介绍数据结构的书中都会介绍这些内容。
    你可以通过指向链表中第一个元素的指针开始引用一个链表，并通过每一个元素中指向下一个元素的指针不断地引用下一个元素；在链表的最后一个元素中，指向下一个元素的指针被赋值为NULL，当你遇到该空指针时，就可以终止对链表的引用了。请看下例：
    while(p!=NULL)    
    {
       /*dO something with p->str*/
       p＝p->next；
    }
    请注意，即使p一开始就是一个空指针，上例仍然能正常工作。
    (2)用空指针作函数调用失败时的返回值。
    许多C库函数的返回值是一个指针，在函数调用成功时，函数返回一个指向某一对象的指针；反之，则返回一个空指针。请看下例：
    if(setlocale(cat，loc_p)==NULL)
    {
        /* setlocale()failed；do something*/
        /*  ...*/
    }
    返回值为一指针的函数在调用成功时几乎总是返回一个有效指针(其值不等于零)，在调用失败时则总是返回一个空指针(其值等于零)；而返回值为一整型值的函数在调用成功时几乎总是返回一个零值，在调用失败时则总是返回一个非零值。请看下例：
    if(raise(sig)!＝0){
        /* raise()failed；do something*/
        /*  ．．．  */
    }
    对上述两类函数来说，调用成功或失败时的返回值含义都是不同的。另外一些函数在调用成功时可能会返回一个正值，在调用失败时可能会返回一个零值或负值。因此，当你使用一个函数之前，应该先看一下它的返回值是哪种类型，这样你才能判断函数返回值的含义。
    (3)用空指针作警戒值    
    警戒值是标志事物结尾的一个特定值。例如，main()函数的预定义参数argv是一个指针数组，它的最后一个元素(argv[argc])永远是一个空指针，因此，你可以用下述方法快速地引用argv中的每一个元素：

/*
    A simple program that prints all its arguments.
     It doesn't use argc ("argument count"); instread.
     it takes advantage of the fact that the last 
    value in argv ("argument vector") is a null pointer. 
*/
# include <stdio. h>
# include <assert. h> 
int
main ( int argc, char  * * argv) 
{
    int i;
    printf ("program name = \"%s\"\n", argv[0]);
    for (i=l; argv[i] !=NULL; ++i)
        printf ("argv[%d] = \"%s\"\n", i, argv[f]);
    assert (i = = argc) ;         / *  see FAQ XI. 5  * /
    return 0;                     / * see FAQ XVI. 4  * / 
}

   请参见：
    7．3  什么是空指针?
    7．10 NULL总是等于0吗?
    20．2 程序总是可以使用命令行参数吗?

    7．5  什么是void指针?
    void指针一般被称为通用指针或泛指针，它是C关于“纯粹地址(raw address)”的一种约定。void指针指向某个对象，但该对象不属于任何类型。请看下例：
    int    *ip;
    void    *p;
    在上例中，ip指向一个整型值，而p指向的对象不属于任何类型。
    在C中，任何时候你都可以用其它类型的指针来代替void指针(在C++中同样可以)，或者用void指针来代替其它类型的指针(在C++中需要进行强制转换)，并且不需要进行强制转换。例如，你可以把char *类型的指针传递给需要void指针的函数。

    请参见：
    7．6  什么时候使用void指针?    
    7．27 可以对void指针进行算术运算吗?
    15．2 C++和C有什么区别?

   7．6 什么时候使用void指针?
    当进行纯粹的内存操作时，或者传递一个指向未定类型的指针时，可以使用void指针。void指针也常常用作函数指针。
    有些C代码只进行纯粹的内存操作。在较早版本的C中，这一点是通过字符指针(char *)实现的，但是这容易产生混淆，因为人们不容易判断一个字符指针究竟是指向一个字符串，还是指向一个字符数组，或者仅仅是指向内存中的某个地址。
    例如，strcpy()函数将一个字符串拷贝到另一个字符串中，strncpy()函数将一个字符串中的部分内容拷贝到另一个字符串中：
    char  *strepy(char'strl，const char *str2)；
    char  *strncpy(char *strl，const char *str2，size_t n)；    
    memcpy()函数将内存中的数据从一个位置拷贝到另一个位置：
    void  *memcpy(void *addrl，void *addr2，size_t n)；
    
    memcpy()函数使用了void指针，以说明该函数只进行纯粹的内存拷贝，包括NULL字符(零字节)在内的任何内容都将被拷贝。请看下例：
    #include "thingie.h"    /* defines struct thingie */
    struct thingie *p_src，*p_dest；
    /*  ...  */
    memcpy(p_dest，p_src，sizeof(struct thingie) * numThingies)；
    在上例中，memcpy()函数要拷贝的是存放在structthingie结构体中的某种对象op_dest和p_src都是指向structthingie结构体的指针，memcpy()函数将把从p_src指向的位置开始的sizeof(stuctthingie) *numThingies个字节的内容拷贝到从p_dest指向的位置开始的一块内存区域中。对memcpy()函数来说，p_dest和p_src都仅仅是指向内存中的某个地址的指针。
    请参见：
    7．5  什么是void指针?
    7．14 什么时候使用指向函数的指针?

    7．7  两个指针可以相减吗?为什么?
    如果两个指针向同一个数组，它们就可以相减，其为结果为两个指针之间的元素数目。仍以本章开头介绍的街道地址的比喻为例，假设我住在第五大街118号，我的邻居住在第五大街124号，每家之间的地址间距是2(在我这一侧用连续的偶数作为街道地址)，那么我的邻居家就是我家往前第(124-118)/2(或3)家(我和我的邻居家之间相隔两家，即120号和122号)。指针之间的减法运算和上述方法是相同的。
    在折半查找的过程中，同样会用到上述减法运算。假设p和q指向的元素分别位于你要找的元素的前面和后面，那么(q-p)/2+p指向一个位于p和q之间的元素。如果(q-p)/2+p位于你要找的元素之前，下一步你就可以在(q-p)/2+p和q之间查找要找的元素；反之，你可以停止查找了。
    如果两个指针不是指向一个数组，它们相减就没有意义。假设有人住在梅恩大街110号，我就不能将第五大街118号减去梅恩大街110号(并除以2)，并以为这个人住在我家往回第4家中。
    如果每个街区的街道地址都从一个100的倍数开始计算，并且同一条街的不同街区的地址起址各不相同，那么，你甚至不能将第五大街204号和第五大街120号相减，因为它们尽管位于同一条街，但所在的街区不同(对指针来说，就是所指向的数组不同)。
    C本身无法防止非法的指针减法运算，即使其结果可能会给你的程序带来麻烦，C也不会给出任何提示或警告。
    指针相减的结果是某种整类型的值，为此，ANSIC标准<stddef.h>头文件中预定义了一个整类型ptrdiff_t。尽管在不同的编译程序中ptrdiff_t的类型可能各不相同(int或long或其它)，但它们都适当地定义了ptrdiff_t类型。
    例7．7演示了指针的减法运算。该例中有一个结构体数组，每个结构体的长度都是16字节。
    如果是对指向结构体数组的指针进行减法运算，则a[0]和a[8]之间的距离为8；如果将指向结构体数组的指针强制转换成指向纯粹的内存地址的指针后再相减，则a[0]和aL8]之间的距离为128(即十六进制数0x80)。如果将指向a[8]的指针减去8，该指针所指向的位置并不是往前移了8个字节，而是往前移了8个数组元素。
    
    注意：把指针强制转换成指向纯粹的内存地址的指针，通常就是转换成void *类型，但是，本例将指针强制转换成char *类型，因为void。类型的指针之间不能进行减法运算(见7．27)。

例 7.7 指针的算术运算

# include <stdio. h>
# include <stddef.h> 

struct stuff {
    char   name[l6];
    / *  other stuff could go here, too  * / 
}; 
struct stuff array [] =  {
    { "The"  },
    { "quick"  },
    { "brown"  >,
    { "fox" },
    { "jumped"  },
    { "over"  },
    { "the"  },
    { "lazy"  },
    { "dog. "  },
    /*
    an empty string signifies the end;
    not used in this program,
    but without it, there'd be no way
    to find the end (see FAQ IX. 4)
    */
    { " " } 
};
main ( ) 
{
    struct stuff         * p0 = &.array[0];
    struct stuff         * p8 = &-array[8];
    ptrdiff_t           diff = p8-p0;
    ptrdiff_t          addr.diff = (char * ) p8 - (char * ) p0;
    /*
    cast the struct stuff pointers to void *
    (which we know printf() can handles see FAQ VII. 28)
    */
    printf ("&array[0] = p0 = %P\n" ,  (void* ) p0);
    printf ("&. array[8] = p8 = %P\n" , (void* ) p8) ; 
    */
    cast the ptrdiff_t's to long's
    (which we know printf () can handle) 
    */
    printf ("The difference of pointers is %ld\n" , (long) diff) ;
    printf ("The difference of addresses is %ld\n" , (long) addr_diff);
    printf ("p8-8 = %P\n" , (void*) (p8-8));
    / *  example for FAQ VII. 8  * /
    printf ("p0 + 8 =  %P (same as p8)\n",  (void* ) (p0 + 8));
    return 0;    / *  see FAQ XVI. 4  * /