二级指针的问题

如何在被调用函数里面新建数据，然后将数据的地址传递出来呢？

一般来说有两种方法,第一种思路是将数据的首地址以返回值的方法返回,第一种方法如下：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char *newBuf(int num)
{
    char *p;
    p = (char *)malloc(num * sizeof(char));
    return p;
}
void deleteBuf(char *p)
{
    if (p != NULL)
    {
        free(p);
        p = NULL; //垃圾代码，执行了也不会有任何用处
    }
}
void main()
{
    char *p = NULL;
    p = newBuf(100);
    printf("p :%x\n", p);
    deleteBuf(p);
    system("pause");
}

第一种方法虽然可用，但是实际上并不好，要是需要新建多个数据然后返回呢？显然返回值不能有多个。第二种方法是利用指针的间接赋值的性质，下面是第二种方法：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//间接赋值是指针存在的最大意义

void modifyP(int *p)
{//用一级指针去修改零级指针(通常是实参)的值
    *p = 20;
}

void main_01()
{
    int a = 0; //定义一个实参变量
    int *p = NULL; //定义一个形参
    p = &a; 

    *p = 10; //间接修改a的值*(a的地址)去间接修改a的值
    modifyP(&a);
    printf("%d\n", a);
    system("pause");
}

void getNewBuf(char **p)
{//用二级指针(通常是形参)去修改一级指针(通常是实参)的值
    //相当于在被调用函数里面分配内存，把结果给传出来了
    //这就是指针做函数参数的精华
    *p = 0x33;//间接修改p的值*(p的地址)去间接修改p的值
    char *tmp = NULL;
    tmp = (char *)malloc(100);
    *p = tmp;//可以甩出被调用函数的结果
}

void deleteBuf(char **p)
{
    if (p == NULL)
    {
        return;
    }
    if (*p != NULL)
    {
        free(*p);
    }
    *p = NULL; //这一句话就不是垃圾代码了
}
void main()
{
    char *p = NULL;
    char **p2 = NULL;

    p = 0x11; //直接修改p的值
    printf("p : %x \n", p);
    p2 = &p;

    //*p2 = 0x99;//间接修改p的值*(p的地址)去间接修改p的值
    getNewBuf(&p);
    printf("p : %x \n", p);
    deleteBuf(&p);
    system("pause");
}

从上面可以看到，第二种方法远远优于第一种，且第二种方法更加说明了使用者对于指针的理解。

野指针问题

什么是野指针？

指针指向的空间释放之后，指针的值并未有改变，这个指针就成为了野指针。

如何避免野指针？

1. 指针定义时初始化NULL;

char **myarray = NULL;

2. 释放的时候需要判断是否为NULL;

if (myarray != NULL)
{
    free(myarray);
}

3. 释放完毕之后置成NULL。

if (myarray != NULL)
{
    free(myarray);
    myarray = NULL;
}

二维指针做函数参数

如何使用二级数组做函数参数？

在解决这个问题之前，我们必须先了解这么一些知识：

1. 数组做函数参数，会退化为指针。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void printfArray(int a[10])
{
    printf("----------printfArray----------\n");
    printf("a:数组的地址:%x\n", a);
    for (int i = 0; i < 10; ++i)
    {
        printf("%d ", a[i]);
    }
    printf("\n");
}
void main()
{
    int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    printf("----------main----------\n");
    printf("a:数组的地址:%x\n", a);
    for (int i = 0; i < 10; ++i)
    {
        printf("%d ", a[i]);
    }
    printf("\n");
    printfArray(a);
    system("pause");
}

运行上面的代码，我们会发现，在函数printfArray中a的地址和我们传递的a数组的地址是一致的，函数并没有一个一个地拷贝数组的值。因此， 数组做函数参数，会退化为指针。

既然这样，我们可以总结出，下面三种输出函数参数的写法几乎没有区别

第一种：

void printArray(int *a, int size)
{
    for (int i = 0; i < size; ++i)
    {
        printf("%d ", a[i]);
    }
    printf("\n");
}

第二种：

void printArray(int a[], int size)
{
    for (int i = 0; i < size; ++i)
    {
        printf("%d ", a[i]);
    }
    printf("\n");
}

第三种:

void printArray(int a[10])
{
    for (int i = 0; i < 10; ++i)
    {
        printf("%d ", a[i]);
    }
    printf("\n");
}

2. 指针是一种数据类型，是指它指向的内存空间的数据类型

- 指针步长（p++），根据所致内存空间的数据类型来确定

- 指针的步长，根据所指内存空间类型来定。

3. 二维数组也是线性排列的。

看下面的代码：

void printArray(int *a, int size)
{
    int i = 0;
    printf("printArray: %d\n", sizeof(a));
    for(i = 0; i < size; i++)
    {
        printf("%d\n", a[i]);
    }
}

int main()
{
    int a[2][3] = {{1, 2, 3}, {4, 5, 6}};
    printArray(p, 6);
    getchar();
    return 0;
}

我们可以看到，函数轻易地输出了二维数组里面的值，也证明了二维数组里的值是线性排列的。

利用sizeof可以判断出指针的步长，指针的移动正是以步长为单位。下面的代码值得细细琢磨。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void printArray(int *a, int size)
{//说明了二维数组里的元素线性排列
//从二维数组指针转换为一维数组指针丢失了步长信息
    int i = 0;
    printf("-----------printArray函数中----------\n");
    printf("sizeof(&a):%d \n", sizeof(&a));
    printf("sizeof(a): %d\n", sizeof(a));
    printf("sizeof(*a): %d\n", sizeof(*a));
    printf("a数组的地址: %d\n", a);
    for (i = 0; i < size; i++)
    {
        printf("%d ", a[i]);
    }
    printf("\n");
}
//其实下面三种函数形参的写法在编译器看来都一样，不信的话可以运行程序
void printArray01(int (*a)[3], int size)
{//推荐的写法
    printf("-----------printArray01函数中----------\n");
    printf("sizeof(&a):%d \n", sizeof(&a));
    printf("sizeof(a): %d\n", sizeof(a));
    printf("sizeof(*a): %d\n", sizeof(*a));
    printf("a数组的地址: %d\n", a);

    //printf("*a: %d\n", *a);
    //printf("*a + 1: %d\n", *a + 1);
    for (int i = 0; i < size; ++i)
    {
        for (int j = 0; j < 3; ++j)
        {
            printf("%d ", (*(a + i))[j]);
            //printf("%x\n", (a + i) + j);
        }

    }
    printf("\n");
}
void printArray02(int a[][3], int size)
{//丢失了一部分的信息，3的存在标志了步长，即*a的步长为12
    printf("-----------printArray02函数中----------\n");
    printf("sizeof(&a):%d \n", sizeof(&a));
    printf("sizeof(a): %d\n", sizeof(a));
    printf("sizeof(*a): %d\n", sizeof(*a));
    printf("a数组的地址: %d\n", a);
    for (int i = 0; i < size; i++)
    {
        for (int j = 0; j < 3; ++j)
        printf("%d ", a[i][j]);
    }
    printf("\n");
}

void printArray03(int a[2][3])
{//虽然能用，但却是最低级的用法,即使这样写，a的步长也只不过是4
//换句话说，2没起到什么作用
    printf("-----------printArray03函数中----------\n");
    printf("sizeof(&a):%d \n", sizeof(&a));
    printf("sizeof(a): %d\n", sizeof(a));
    printf("sizeof(*a): %d\n", sizeof(*a));
    printf("a数组的地址: %d\n", a);
    for (int i = 0; i < 2; i++)
    {
        for (int j = 0; j < 3; ++j)
        printf("%d ", a[i][j]);
    }
    printf("\n");
}

int main()
{
    int a[2][3] = { { 1, 2, 3 }, { 4, 5, 6 } };
    char cc[10][30];

    printf("-----------main函数中----------\n");
    printf("sizeof(&a):%d \n", sizeof(&a));
    printf("sizeof(a):%d \n", sizeof(a));
    printf("sizeof(*a):%d \n", sizeof(*a));
    printf("sizeof(&cc):%d \n", sizeof(&cc));
    printf("sizeof(cc):%d \n", sizeof(cc));
    printf("sizeof(*cc):%d \n", sizeof(*cc));

    int *p = (int *)a;
    printArray(p, 6); //即使是用二级指针，也可以输出正确的结果
    printArray01(a, 2);
    printArray02(a, 2);
    printArray03(a);
    getchar();
    return 0;
}

结论倒是挺简单的：

1.C语言中只会以机械式的值拷贝的方式传递参数（实参把值传给形参）

原因有两个:

* 高效

* C语言处理a[n]的时候，它没有办法知道n是几，它只知道&a[0]是多少，因此把它的值作为参数传递进去了，虽然c语言可以做到直接int fun(char a[20])，然后函数能得到20这个数字，但是，C确实没有这么做。当然，这也提高了效率。

2.二维数组参数同样存在退化的问题。

二维数组可以看做是一维数组–>二维数组中的每个元素是一维数组–>二维数组参数中第一维的参数可以省略.

void f(int a[5]); —> void f(int a[]); —> void f(int* a);

void g(int a[3][3]); —> void g(int a[][3]);—> void g(int (*a)[3]);

3. 等价关系。