009-二级指针的三种内存模型

moc

1、模型一
主调函数定义指针数组，如：char *ArrayStr[] = { "ccccc","aaaa", "bbbb", "11111"}；被调函数形参采用二级指针接受，如char **ArrayStr。
注：上面指针数组初始化在Visual C++中会报错。

#include "stdio.h"
#include "stdlib.h"
#include "string.h"

// 打印函数 
int printArray(char **ArrayStr, int iNum)
{
        int i;
        for (i = 0; i < iNum; i++)
        {
                printf("%s \n", ArrayStr[i]);
        }
        return 0;        
}

// 排序函数 
int sortArrayStr(char **ArrayStr, int iNum)
{
        int i = 0, j = 0;
        char *tmp; 
        for (i = 0; i < 4; i++) 
        {
                for (j = i+1; j<4; j++)
                {
                        if (strcmp(ArrayStr[i], ArrayStr[j]) > 0)
                        {
                                tmp = ArrayStr[i];
                                ArrayStr[i] = ArrayStr[j];
                                ArrayStr[j] = tmp;
                        }
                }
         } 
         return 0;
}

int main()
{
        char *ArrayStr[] = { "ccccc","aaaa", "bbbb", "11111"};
        
        printf("排序之前：\n");
        printArray(ArrayStr, 4);
        
        sortArrayStr(ArrayStr, 4);
        
        printf("\n排序之后：\n");
        printArray(ArrayStr, 4);
        
        system("pause");
        return 0;        
}

2、模型二
主调函数定义二维数组，如：char myArray[10][30] = { "ccccc","aaaa", "bbbb", "11111"}；被调函数形参采用二维数组接受，如char **ArrayStr。

//打印
int printfArray(char ArrayStr[10][30], int iNum)
{
        int i;
        for (i = 0; i < iNum; i++)
        {
                printf("%s \n", ArrayStr[i]);
        }
        return 0;
}

// 排序函数 
int sortArrayStr(char myArray[10][30], int iNum)
{
        int i = 0, j = 0;
        char buf[30];
        for (i = 0; i < iNum; i++)
        {
                for (j = i + 1; j<iNum; j++)
                {
                        if (strcmp(myArray[i], myArray[j]) > 0)
                        {
                                strcpy(buf, myArray[i]);
                                strcpy(myArray[i], myArray[j]);
                                strcpy(myArray[j], buf);
                        }
                }
        }
        return 0;
}

int main()
{
        int i = 0, j = 0;
        char buf[30];   //buf数组名代表数组元素首地址 
                                        //下面两种，内存模型不一样 
                                        //         char *ArrayStr[] = { "ccccc","aaaa", "bbbb", "11111"};
        char myArray[10][30] = { "cccc", "aaaa", "dddd", "11111" };   // 二维数组数组名代表什么 

        printf("排序之前：\n");
        printfArray(myArray, 4);

        sortArrayStr(myArray, 4);

        printf("排序之后：\n");
        printfArray(myArray, 4);
        system("pause");
        return 0;
}

3、模型三
        malloc 申请内存空间返回给二级指针，malloc 申请内存空间给数组，再用 二级指针做函数形参。

int printfArr33(char **ArrayStr, int iNum)
{
        int i = 0;
        for (i=0; i<iNum; i++)
        {
                printf("%s \n", ArrayStr[i]);
        }
        return 0;
}

int printfArr2_23(char myArray[10][100], int iNum)
{
        int i = 0;
        for (i=0; i<iNum; i++)
        {
                printf("%s \n", myArray[i]);
        }
        return 0;

}


int sortArrayStr03(char **ArrayStr, int iNum)
{
        int i = 0, j = 0;
        char *tmp = NULL;
        //排序

        for (i=0; i<iNum; i++)
        {
                for (j=i+1; j<iNum; j++)
                {
                        if (strcmp(ArrayStr[i],ArrayStr[j]) < 0)
                        {
                                tmp = ArrayStr[i];
                                ArrayStr[i] = ArrayStr[j];
                                ArrayStr[j] = tmp;
                        }
                }
        }
        return 0;
}

void main()
{
        int i = 0, j = 0;
        char buf[100];
        char **myarray = (char **)malloc(10*sizeof(char*)); //int array[10]
        if (myarray == NULL)
        {
                return;
        }
        for (i=0; i<10; i++)
        {
                myarray[i] = (char *)malloc(100*sizeof(char)); //char buf[100];
                if (myarray[i]  == NULL)
                {
                        printf("ddddde\n");
                        return;
                }
                sprintf(myarray[i],"%d%d%d ", i, i, i);
        }

        //第三种内存模型打印 
        printf("排序之前\n");
        printfArr33(myarray, 10);
        //printfArr2_23(myarray, 10); //第二种打印不适合 err

        sortArrayStr03(myarray, 10);

        //第三种内存模型打印
        printf("排序之后\n");
        printfArr33(myarray, 10);

        for (i=0; i<10; i++)
        {
                free(myarray[i] );
        }
        if (myarray != NULL) 
        {
                free(myarray);
        }

        system("pause");
}

注记：排序中，使用临时数组和临时指针效果是一样的，但含义不一样，使用指针是改变指向的顺序，使用数组是改变指针指向的内容。