C语言指针注意事项

转自：http://hi.baidu.com/deep%5Fpro/blog/category/c%D7%A8%BC%D2%BB%FD%C0%DB

在这里表示---------大爱！！！！

我自认还算对c有点自信，没想到今天看到这点很是惊讶，今天如若不发现，难保以后不贻害无穷。
首先看程序
char *foo_err(int num)
{
char p[20]="tset string/n";
return &p;
}
这个倒是很容易看出是无效的返回值，栈中的变量在子函数返回后就不再有意义。

再看

void foo_getmem(void * p,int num)
{
p=malloc(sizeof(char)*num);
strcpy(p,"test string/n");
}

int main()
{
char *str=NULL;
foo_getmem(str,100);

printf(str);
free(str);
return 0;
}
乍一眼看过去完全没有问题，但其实是包含一个巨大的问题，执行会报一个段错误。
因为char *str还是指向NULL，而foo_getmem制造了一个无法free的内存泄露。

这个foo_getmem函数里的参数void * p，并不能完整地带有实参char *str的全部特性。
仔细想想c语言函数调用和汇编知识，就知道要在一个子函数里，操作一个指针指向的内存空间，只要传递
这个指针所指的内存空间首地址和这片内存的长度，其他的什么指针类型以及这个指针本身的地址都没有意义。
参数中的指针类型可以在子函数里随意强制转换，使用这点，操作内存数据真是得心应手。

你要问为什么在子函数里修改了形参指针参数所指的地址，对于实参指针没有任何影响？
我不想用什么临时副本之类的话来敷衍，那会越讲越让人迷糊。但是又很难组织语言讲清楚。
熟悉汇编语言子程序调用的就能理解了。
学懂学通c语言，我觉得一定还要学汇编、编译原理以及一些计算机组成原理之类的课程。

现在我突然醒悟，c语言函数里的指针参数，应该都加上一个const关键字来限制对参数地址的修改。
不知为什么这么做的人不多
void foo_getmem(void * const p,int num) ，就能及时发现问题。

按照源程序本意，应该写成
void *foo2(int num)
{
void *p;
p=malloc(num);
strcpy(p,"test string/n");
return p;
}
int main()
{
char *str=NULL;
str=(char *)foo2(100);
printf(str);
free(str);
return 0;
}

但是这也是一个不好的写法，使得malloc和free没有直观地成对出现，很容易造成忘记free的内存泄露。

 

不用不知道，一用吓一跳

无论多么怪异的事情，存在即合理的
gcc 版本 4.3.0 20080428 (Red Hat 4.3.0-8) (GCC)

#include <unistd.h>
#include <fcntl.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>

static int inline foo(void)
{
printf("this is %s %d/n",__FUNCTION__ ,__LINE__);
}

int main(int argc, char *argv[])
{
int (*p1)()=foo;
(&*p1)();
int (*p2)()=&foo;
(p2)();
int (*p3)()=*foo;
(**********************************p3)();
int (*p4)()=********foo;
(***********************************&*p4)();
return 0;
}

在这里贴上作者的小解释把  - -！

<!-- @page { margin: 2cm } P { margin-bottom: 0.21cm } A:link { so-language: zxx } -->

基本解释

　　1、指针的本质是一个与地址相关的复合类型，它的值是数据存放的位置（地址）；数组的本质则是一系列的变量。

　　2、数组名对应着（而不是指向）一块内存，其地址与容量在生命期内保持不变，只有数组的内容可以改变。指针可以随时指向任意类型的内存块，它的特征是“可变”，所以我们常用指针来操作动态内存。

　　3、当数组作为函数的参数进行传递时，该数组自动退化为同类型的指针。

　　问题：指针与数组

　　听说char a[]与char *a是一致的，是不是这样呢？

　　答案与分析：

　　指针和数组存在着一些本质的区别。当然，在某种情况下，比如数组作为函数的参数进行传递时，由于该数组自动退化为同类型的指针，所以在函数内部，作为函数参数传递进来的指针与数组确实具有一定的一致性，但这只是一种比较特殊的情况而已，在本质上，两者是有区别的。请看以下的例子：

char a[] = "Hi, pig!"; char *p = "Hi, pig!";

　　上述两个变量的内存布局分别如下：

　　数组a需要在内存中占用8个字节的空间，这段内存区通过名字a来标志。指针p则需要4个字节的空间来存放地址，这4个字节用名字p来标志。其中存放的地址几乎可以指向任何地方，也可以哪里都不指，即空指针。目前这个p指向某地连续的8个字节，即字符串“Hi, pig!”。

　　另外，例如：对于a[2]和p[2]，二者都返回字符‘i’，但是编译器产生的执行代码却不一样。对于a[2]，执行代码是从a的位置开始，向后移动2两个字节，然后取出其中的字符。对于p[2]，执行代码是从p的位置取出一个地址，在其上加2，然后取出对应内存中的字符。

　　问题：数组指针

　　为什么在有些时候我们需要定义指向数组而不是指向数组元素的指针？如何定义？

　　答案与分析：

　　使用指针，目的是用来保存某个元素的地址，从而来利用指针独有的优点，那么在元素需要是数组的情况下，就理所当然要用到指向数组的指针，比如在高维需要动态生成情况下的多维数组。

　　定义例子如下： int (*pElement)[2]。

　　下面是一个例子：

int array[2][3] = {{1，2，3}，{4，5，6}}; int (*pa)[3]; //定义一个指向数组的指针 pa = &array[0]; // '&'符号能够体现pa的含义，表示是指向数组的指针 printf ("%d", (*pa)[0]）; //将打印array[0][0]，即1 pa++； // 猜一猜，它指向谁？array[1]？对了！ printf ("%d", (*pa)[0]); // 将打印array[1][0]，即4

　　上述这个例子充分说明了数组指针—一种指向整个数组的指针的定义和使用。

　　需要说明的是，按照我们在第四篇讨论过的，指针的步进是参照其所指对象的大小的，因此，pa++将整个向后移动一个数组的尺寸，而不是仅仅向后移动一个数组元素的尺寸。

　　问题：指针数组

　　有如下定义：

struct UT_TEST_STRUCT *pTo[2][MAX_NUM];

　　请分析这个定义的意义，并尝试说明这样的定义可能有哪些好处？

　　答案与分析：

　　前面我们谈了数组指针，现在又提到了指针数组，两者形式很相似，那么，如何区分两者的定义呢？分析如下：

　　数组指针是：指向数组的指针，比如 int (*pA)[5]。

　　指针数组是：指针构成的数组，比如int *pA[5]。

　　至于上述指针数组的好处，大致有如下两个很普遍的原因：

　　a)、各个指针内容可以按需要动态生成，避免了空间浪费。

　　b)、各个指针呈数组形式排列，索引起来非常方便。

　　在实际编程中，选择使用指针数组大多都是想要获得如上两个好处。
问题：指向指针的指针

　　在做一个文本处理程序§的时候，有这样一个问题：什么样的数据结构适合于按行存储文本？

　　答案与分析：

　　首先，我们来分析文本的特点，文本的主要特征是具有很强的动态性，一行文本的字符个数或多或少不确定，整个文本所拥有的文本行数也是不确定的。这样的特征决定了用固定的二维数组存放文本行必然限制多多，缺乏灵活性。这种场合，使用指向指针的指针有很大的优越性。

　　现实中我们尝试用动态二维数组（本质就是指向指针的指针）来解决此问题：

　　图示是一个指针数组。所谓动态性指横向（对应每行文本的字符个数）和纵向（对应整个文本的行数）两个方向都可以变化。

　　就横向而言，因为指针的灵活性，它可以指向随意大小的字符数组，实现了横向动态性。

　　就竖向而言，可以动态生成及扩展需要的指针数组的大小。

　　下面的代码演示了这种动态数组的用途：

// 用于从文件中读取以 '/0'结尾的字符串的函数 extern char *getline(FILE *pFile); FILE *pFile; char **ppText = NULL; // 二维动态数组指针 char *pCurrText = NULL； // 指向当前输入字符串的指针 ULONG ulCurrLines = 0； ULONG ulAllocedLines = 0； while （p = getline(pFile)) { 　if (ulCurrLines >= ulAllocedLines) 　{ 　　// * 当前竖向空间已经不够了，通过realloc对其进行扩展。 　　ulAllocedLines += 50; // 每次扩展50行。 　　ppText = realloc (ppText, ulAllocedLines * (char *)); 　　if (NULL == ppText) 　　{ 　　　return; // 内存分配失败，返回 　　} 　} 　ppText[ulCurrLines++] = p; // 横向“扩展”，指向不定长字符串 }

　　问题：指针数组与数组指针与指向指针的指针

　　指针和数组分别有如下的特征：

　　指针：动态分配，初始空间小

　　数组：索引方便，初始空间大

　　下面使用高维数组来说明指针数组、数组指针、指向指针的指针各自的适合场合。

　　 多维静态数组:各维均确定，适用于整体空间需求不大的场合，此结构可方便索引，例a[10][40]。

　　 数组指针：低维确定，高维需要动态生成的场合，例a[x][40]。

　　 指针数组：高维确定，低维需要动态生成的场合，例a[10][y]。

　　 指向指针的指针：高、低维均需要动态生成的场合，例a[x][y]。

　　问题：数组名相关问题

　　假设有一个整数数组a，a和&a的区别是什么？

　　答案与分析：

　　a == &a == &a[0],数组名a不占用存储空间。需要引用数组(非字符串)首地址的地方，我一般使用&a[0]，使用a容易和指针混淆，使用&a容易和非指针变量混淆。

　　区别在于二者的类型。对数组a的直接引用将产生一个指向数组第一个元素的指针，而&a的结果则产生一个指向全部数组的指针。例如：

int a[2] = {1, 2}; int *p = 0; p = a; /* p指向a[0]所在的地方 */ x = *p; /* x = a[0] = 1*/ p = &a; /* 编译器会提示你错误，*/ /*显示整数指针与整数数组指针不一样 */

　　问题：函数指针与指针函数
　
　　请问：如下定义是什么意思：

int *pF1(); int (*pF2)();

　　答案与分析：

　　首先清楚它们的定义：

　　 指针函数，返回一个指针的函数。

　　 函数指针，指向一个函数的指针。

　　可知：

　　 pF1是一个指针函数，它返回一个指向int型数据的指针。

　　 pF2是一个函数指针，它指向一个参数为空的函数，这个函数返回一个整数。