http://www.jackxiang.com/index.php zh-cn http://www.jackxiang.com/post// jack <xdy108@126.com> Mon, 14 Apr 2008 04:29:43 +0000 http://www.jackxiang.com/post// C语言指针传递详解：http://www.cnblogs.com/archimedes/p/c-transfer-point.html
从函数返回对象经常使用以下两种技术：
使用malloc在函数内部分配内存并返回其地址，调用者负责释放返回的内存
传递一个对象给函数，让函数修改它，这样分配和释放对象的内存都是调用者的责任

先讲难度大一点的，指针的地址传入函数里，传递指针的指针-将指针传递给函数的时候，传递的是值，如果希望修改原指针而不是指针的副本，就需要传递指情况一，针的指针,如下，allocateArray.c ：
#include <stdio.h> #include <stdlib.h> void allocateArray(int ** arr,int size,int value){     int i;     *arr = (int*)malloc(size*sizeof(int));     if(*arr != NULL){         if(*arr != NULL){             for(i=0;i<size;i++){                 *(*arr+i) = value;             }         }     } } int main(){     int i;     int *vector = NULL;     allocateArray(&vector,5,45);     for(i = 0; i < 5; i++) {                                                                                                                                                                                 printf("%d\n", vector[i]);     }     free(vector); }
gcc -g -o allocateArray allocateArray.c

[root@test pointerparam]# ./allocateArray
45
45
45
45
45
用gdb看一下其指针地址，为何这样就能实现在函数里malloc后，在外面依然能够获取到malloc里的值呢？是因为传入的指针的地址，相当于这个malloc的内存根本没有退出函数后销毁，而且传入的地址是指针的地址，不是指针，这两点保证了其地址是同一个地址，不是副本，所以，函数退出后还在，需要外面作free(;vector),vector=NULL：
(gdb) b 4
Breakpoint 1 at 0x40053a: file allocateArray.c, line 4.
(gdb) b 18
Breakpoint 2 at 0x4005ad: file allocateArray.c, line 18.
(gdb) r
Breakpoint 2, main () at allocateArray.c:18
18          allocateArray(&vector,5,45);
(gdb) p &vector
$1 = (int **) 0x7fff3cb989f0         //函数外的地址： 0x7fff3cb989f0
(gdb) c
Continuing.

Breakpoint 1, allocateArray (arr=0x7fff3cb989f0, size=5, value=45) at allocateArray.c:5
5           *arr = (int*)malloc(size*sizeof(int));
(gdb) p arr
$2 = (int **) 0x7fff3cb989f0    //这个地址在函数里也一直是传入的地址： 0x7fff3cb989f0
(gdb) n
6           if(*arr != NULL){
(gdb) p arr
$4 = (int **) 0x7fff3cb989f0
(gdb) n
7               if(*arr != NULL){
(gdb) n
8                   for(i=0;i<size;i++){
(gdb) n
9                       *(*arr+i) = value;
(gdb) n
main () at allocateArray.c:19
............next............
19          for(i = 0; i < 5; i++) {
(gdb) n
20              printf("%d\n", vector[i]);
(gdb) p &vector
$6 = (int **) 0x7fff3cb989f0     //发现没到函数里转一圈后，这个地址一直是： 0x7fff3cb989f0
(gdb) n
45
19          for(i = 0; i < 5; i++) {//打印出函数里赋的值是没有问题的..正常运行结束。


情况二：下面这个版本的allocateArray函数传递了一个数组指针、数组的长度和用来初始化数组元素的值，返回指针只是为了方便
#include<stdio.h> #include<stdlib.h> void allocateArray(int *arr, int size, int value) {     int i;     if(arr != NULL) {         for(i = 0; i < size; i++) {             arr[i] = value;         }     }                                                                                                                                                                                                 } int main() {     int i;     int* vector = (int*)malloc(5 * sizeof(int));     allocateArray(vector, 5, 45);     for(i = 0; i < 5; i++) {         printf("%d\n", vector[i]);     }     free(vector);     return 0; }
[root@test pointerparam]# gcc  allocateArray3.c
[root@test pointerparam]# ./a.out
45
45
45
45
45
这个值是变了，但指针是没有变的，也就是说指针做了它该做的工作，并没有像第一种那样:  allocateArray(&vector,5,45);实现对指针本身地址通过函数进行了修改，这儿只是对指针里的值做了修改，是不一样的。
用gdb来跟踪一下这个指针的传指针值的操作：
[root@test pointerparam]# gdb allocateArray3
(gdb) b 15
Breakpoint 1 at 0x400571: file allocateArray3.c, line 15.
(gdb) b 5
Breakpoint 2 at 0x400536: file allocateArray3.c, line 5.
(gdb) r
Starting program: /tmp/pointerparam/allocateArray3
Breakpoint 1, main () at allocateArray3.c:15
15          int* vector = (int*)malloc(5 * sizeof(int));
(gdb) p vector
$1 = (int *) 0x0   //此时是光一个指针还没有分配指针指和的malloc真实数据地址
(gdb) n
16          allocateArray(vector, 5, 45);
(gdb) p vector
$2 = (int *) 0xb447010 //分配地址：0xb447010 这个值会带入进去，并在里面对其作赋值操作，出函数后这个值还在，因为在传入前就已经分配好空间，在函数里只是赋值，把东西放进这个空间，函数返回后空间并没有销毁，因为是在函数外。
(gdb) c
Continuing.
Breakpoint 2, allocateArray (arr=0xb447010, size=5, value=45) at allocateArray3.c:6
6           if(arr != NULL) {
(gdb) c
Continuing.
45
45
45
45
45


情况三，指针值传入函数里面，这样会出现一个segment default的，情况三作一下修改：
allocateArray2.c
#include <stdio.h> #include <stdlib.h> void allocateArray(int *arr,int size,int value){     int i;     arr = (int*)malloc(size*sizeof(int));     if(arr != NULL){         if(arr != NULL){             for(i=0;i<size;i++){                 arr[i] = value;             }         }     } } int main(){     int i;     int *vector = NULL;     allocateArray(vector,5,45);     for(i = 0; i < 5; i++) {         printf("%d\n", vector[i]);     }     free(vector); }
gcc -g -o allocateArray2 allocateArray2.c
[root@test pointerparam]# ./allocateArray2
Segmentation fault


如这样写呢？     *arr = (int*)malloc(size*sizeof(int));
void allocateArray(int *arr,int size,int value){     int i;      *arr = (int*)malloc(size*sizeof(int));     if(arr != NULL){         if(arr != NULL){             for(i=0;i<size;i++){                 arr[i] = value;             }         }     } }
如果想这样，编译都会报错，如下：
porinter.c:6:10: 警告：赋值时将指针赋给整数，未作类型转换 [默认启用]

因为文件名传入的是一个指针，而*arr是一个值，不再是一个指针了。
而传入的是指针的指针就不一样了，如前面的例子1：void allocateArray(int ** arr,int size,int value){
那么因为函数int ** arr是指针的指针，也就是这个指针是可以修改的，这个*arr它不是一个值了，而是一个指针，所以，它可以给它malloc一个空间，并把这个空间给到*arr这个脂针地址里去，这块一定要区分开来，否则指向指针这一块的概念就没彻底理解清楚。
再理解前面引用的Url里的这一段话，加强深入理解传入指向指针的指针是可以修改指针的地址，指针也理一个数据，和int char是一样的东西，它也是能被修改的，而一维指针可以修改int char，int这样的值，但指针地址不变，而指针的指针它的地址都能被修改，这就是指针的精华人所在，摘录如下：
传递指针可以让多个函数访问指针所引用的对象，而不用把对象声明为全局可访问，要在某个函数中修改数据，需要用指针传递数据，当数据是需要修改的指针的时候，就要传递指针的指针，传递参数（包括指针）的时候，传递的是它们的值，也就是说，传递给函数的是参数值的一个副本，也就是说这儿数据是需要修改的指针的时候，就要传递指针的指针,而咱们只传了指针，修改后退出函数这个指针并没有变，销毁函数后，没有对指针作出修改，等于空做了一次运算，像做梦一样，函数并没改变什么，所以出现错误。

为何会出现segment default的情况？是因为指针传入函数后进行了malloc，而这个指针是在函数里经过malloc时给修改了指向地址，而这个malloc的空间因为函数退出而回收了指针传值地址，也就是其并没有记得下来，其malloc出来的存放整数的空间还在，但退出函数时就丢了，为此，在外面打印一个不存在的地址，当然会出现了segment default的情况，gdb分析如下：
(gdb) b 18
Breakpoint 1 at 0x40059a: file allocateArray2.c, line 18.
(gdb) b 19
Breakpoint 2 at 0x4005ad: file allocateArray2.c, line 19.
(gdb) b 4
Breakpoint 3 at 0x40053a: file allocateArray2.c, line 4.
(gdb) r
Starting program: /tmp/pointerparam/allocateArray2

Breakpoint 1, main () at allocateArray2.c:18
18          allocateArray(vector,5,45);
(gdb) n

Breakpoint 3, allocateArray (arr=0x0, size=5, value=45) at allocateArray2.c:5 //arr传入是0x0，也就是副本vector的地址。
5           arr = (int*)malloc(size*sizeof(int));
(gdb) n
6           if(arr != NULL){
(gdb) p arr
$1 = (int *) 0x14c3c010 //经malloc后是0x14c3c010
(gdb) c
Continuing.

Breakpoint 2, main () at allocateArray2.c:19
19          for(i = 0; i < 5; i++) {
(gdb) p vector //返回main函数后，这个vector还是0x0，并没有经过函数而改变，当然，下面对其进行打印会Segmentation fault.
$2 = (int *) 0x0
(gdb) n
20              printf("%d\n", vector[i]);
(gdb) n

Program received signal SIGSEGV, Segmentation fault.
0x00000000004005c3 in main () at allocateArray2.c:20
20              printf("%d\n", vector[i]);

回顾总结：
allocateArray.c                    allocateArray2.c                  
#include <stdio.h>                   #include <stdio.h>                                          
#include <stdlib.h>                   #include <stdlib.h>                                          
void allocateArray(int *arr,int size,int value){           void allocateArray(int ** arr,int size,int value){      
    int i;                           int i;                                                            
    arr = (int*)malloc(size*sizeof(int));                 *arr = (int*)malloc(size*sizeof(int));                
    if(arr != NULL){                       if(*arr != NULL){                                          
        if(arr != NULL){                     if(*arr != NULL){                                      
            for(i=0;i<size;i++){                       for(i=0;i<size;i++){                              
                arr[i] = value;                     *(*arr+i) = value;                              
            }                             }                                                          
        }                         }                                                              
    }                             }                                                                  
}                         }                                                                      
                                                                                                      
int main(){                       int main(){                                                        
    int i;                           int i;                                                            
    int *vector = NULL;                       int *vector = NULL;                                      
    allocateArray(vector,5,45);                   allocateArray(&vector,5,45);                          
    for(i = 0; i < 5; i++) {                     for(i = 0; i < 5; i++) {                                    
        printf("%d\n", vector[i]);                 printf("%d\n", vector[i]);                            
    }                             }                                                                  
    free(vector);                         free(vector);                                                  
}                         }                                                                      
结论是malloc在函数里都得销毁掉，详细如下所述：
C语言是传值调用的，左边的你传递进去vector的地址，右边的是你传递了vector这个指针的地址值，所以左边的allocateArray函数内对arr的修改不会对函数外vector的值有什么影响，但是右边就不一样了，对arr的修改就是对vector变量所在的空间中的值的修改，也就是修改了vector的值,所以左边的allocateArray函数内对arr的修改不会对函数外vector的值有什么影响,那这个左边的malloc有没有运行完后还在呢？ 右边这个如果不free会有内存泄漏的呀。
两边的都要销毁,只是左边的你在函数外没办法销毁。
【活跃】回忆未来-向东-Jàck 15/3/18 星期三 11:13:40
哈哈，了解了，多谢兄弟啊，相当感谢，我都说这malloc这玩意用时要注意才是。搞不好就泄漏了呢。
11:13:53
【潜水】Now&Fight 15/3/18 星期三 11:13:53
嗯嗯


————————————————————————————————————————————————————————————————
内存分配方式有三种：
（1） 从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量，static变量。
（2） 在栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。（在函数中不要返回栈内存，但可以返回动态分配的内存）。
（3） 从堆上分配，亦称动态内存分配。程序在运行的时候用malloc 或new 申请任意多少的内存，程序员自己负责在何时用free 或delete释放内存。动态内存的生存期由我们决定，使用非常灵活，但问题也最多。
例子：
（1）
voidGetMemory(char *p)
{
     p = (char *)malloc(100);
}
void Test(void)
{
    char *str = NULL;
    GetMemory(str);
    strcpy(str, "hello world");
    printf(str);
}
请问运行Test 函数会有什么样的结果？
答：程序崩溃（段错误）。因为GetMemory 并不能传递动态内存，Test 函数中的str 一直都是 NULL。strcpy(str, "helloworld");将使程序崩溃。
（2）
char *GetMemory(void)
{
    char p = "hello world";
    return p;
}
void Test(void)
{
    char *str = NULL;
    str = GetMemory();
    printf(str);
}
请问运行Test 函数会有什么样的结果？
答：可能是乱码。
因为GetMemory 返回的是指向“栈内存”的指针，该指针的地址不是 NULL，但其原现的内容已经被清除，新内容不可知。
（3）
void GetMemory2(char **p, int num)
{
    *p = (char *)malloc(num);
}
void Test(void)
{
    char *str = NULL;
    GetMemory(&str, 100);
    strcpy(str, "hello");
    printf(str);
}
请问运行Test 函数会有什么样的结果？
答：
（1）能够输出hello
（2）内存泄漏。
（4）
void Test(void)
{
    char *str = (char *) malloc(100);
    strcpy(str, “hello”);
    free(str);//没有将str置为NULL，
if(str != NULL)
{
    strcpy(str, “world”);
    printf(str);
}
}
请问运行Test 函数会有什么样的结果？
答：篡改动态内存区的内容，后果难以预料，非常危险。
因为free(str);之后，str 成为野指针，
if(str != NULL)语句不起作用。
**********************************************************************************************
void GetMemory2(char **p, int num)
{
    *p = (char *)malloc(sizeof(char) * num);
}
void Test2(void)
{
    char *str = NULL;
    GetMemory2(&str, 100); // 注意参数是 &str，而不是str
    strcpy(str, "hello");
    cout<< str << endl;
    free(str);
}
如果非得要用指针参数去申请内存，那么应该改用“指向指针的指针”.由于“指向指针的指针”这个概念不容易理解，我们可以用函数返回值来传递动态内存。
char *GetMemory3(int num)
{
     char *p = (char *)malloc(sizeof(char) * num);
     return p;
}
void Test3(void)
{
     char *str = NULL;
     str = GetMemory3(100);
     strcpy(str, "hello");
     cout<< str << endl;
     free(str);
}
**********************************************************************************************
用函数返回值来传递动态内存这种方法虽然好用，但是常常有人把return 语句用错了。这里强调不要用return 语句返回指向“栈内存”的指针，因为该内存在函数结束时自动消亡
char*GetString(void)
{
     char p[] = "hello world";
     return p; // 编译器将提出警告（告诉你返回的是局部变量）
}
void Test4(void)
{
     char *str = NULL;
     str = GetString(); // str 的内容是垃圾
     cout<< str << endl;
}
用调试器逐步跟踪Test4，发现执行str= GetString 语句后str 不再是NULL 指针，但是str的内容不是“hello world”而是垃圾。
char *GetString2(void)
{
     char *p = "hello world";
     return p;
}
void Test5(void)
{
     char *str = NULL;
     str = GetString2();
     cout<< str << endl;
}
函数Test5 运行虽然不会出错，但是函数GetString2 的设计概念却是错误的。因为GetString2 内的“hello world”是常量字符串，位于静态存储区，它在程序生命期内恒定不变。无论什么时候调用GetString2，它返回的始终是同一个“只读”的内存块。

告诉你返回的是一个局部变量，警告。

来自：http://blog.csdn.net/ios_long/article/details/7019718
————————————————————————————————————————————————————————————————
#include <stdio.h>
int main()
{
   char **pa;
   char *p[3];
   pa = p;
   int n,m;
   *(pa+0) = "BOOK";
   *(pa+1) = "YOU";
   *(pa+2) = "LINUX";
   for(n = 0;n<3;n++)
   {
    printf("\npa+%d= %04x\n",n,pa+n);
    printf("Addr of * (pa+%d) = %04x\n",n,*(pa+n) );
    printf("string pointed by *(pa+%d) = %s\n",n,*(pa+n) );
    for(m=0;*(*(pa+n)+m)!='\0';m++)
    {
        printf("* (*(pa+%d)+%d) = %c\t",n,m,*(*(pa+n)+m));
    }
    printf("\n");
   }
}
运行结果：
pa+0= bfbfeb80
Addr of * (pa+0) = 8048668
string pointed by *(pa+0) = BOOK
* (*(pa+0)+0) = B       * (*(pa+0)+1) = O       * (*(pa+0)+2) = O       * (*(pa+0)+3) = K

pa+1= bfbfeb84
Addr of * (pa+1) = 804866d
string pointed by *(pa+1) = YOU
* (*(pa+1)+0) = Y       * (*(pa+1)+1) = O       * (*(pa+1)+2) = U

pa+2= bfbfeb88
Addr of * (pa+2) = 8048671
string pointed by *(pa+2) = LINUX
* (*(pa+2)+0) = L       * (*(pa+2)+1) = I       * (*(pa+2)+2) = N       * (*(pa+2)+3) = U       * (*(pa+2)+4) = X

注意：
char **pa是指向char*性的指针，而char *p[3] 其本质上是一个数组，而分别为char *p[0] char *p[1] char *p[2] 而，通过pa=p后，pa指向char *p[3] 的首地址及*p[0] (数组名称即是其首地址)。为此可以pa+1，pa+2等的操作，分别指向下面book的地址和You的地址，也就是*(pa+0)  = "BOOK" 就是让系统分配一个内存地址将BOOK放入，然后pa+0就指向BOOK的地址，以此类推，这个分配多少和操作系统有关，不像Java有回收机制，这个基本上由操作系统来分配！ ]]> http://www.jackxiang.com/post//#blogcomment <user@domain.com> Thu, 01 Jan 1970 00:00:00 +0000 http://www.jackxiang.com/post//#blogcomment