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

moc

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

1. #include "stdio.h"
   
2. #include "stdlib.h"
   
3. #include "string.h"
   
4. 
   
5. // 打印函数
   
6. int printArray(char **ArrayStr, int iNum)
   
7. {
   
8.         int i;
   
9.         for (i = 0; i < iNum; i++)
   
10.         {
    
11.                 printf("%s \n", ArrayStr[i]);
    
12.         }
    
13.         return 0;       
    
14. }
    
15. 
    
16. // 排序函数
    
17. int sortArrayStr(char **ArrayStr, int iNum)
    
18. {
    
19.         int i = 0, j = 0;
    
20.         char *tmp;
    
21.         for (i = 0; i < 4; i++)
    
22.         {
    
23.                 for (j = i+1; j<4; j++)
    
24.                 {
    
25.                         if (strcmp(ArrayStr[i], ArrayStr[j]) > 0)
    
26.                         {
    
27.                                 tmp = ArrayStr[i];
    
28.                                 ArrayStr[i] = ArrayStr[j];
    
29.                                 ArrayStr[j] = tmp;
    
30.                         }
    
31.                 }
    
32.          }
    
33.          return 0;
    
34. }
    
35. 
    
36. int main()
    
37. {
    
38.         char *ArrayStr[] = { "ccccc","aaaa", "bbbb", "11111"};
    
39.        
    
40.         printf("排序之前：\n");
    
41.         printArray(ArrayStr, 4);
    
42.        
    
43.         sortArrayStr(ArrayStr, 4);
    
44.        
    
45.         printf("\n排序之后：\n");
    
46.         printArray(ArrayStr, 4);
    
47.        
    
48.         system("pause");
    
49.         return 0;       
    
50. }

复制代码

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

1. //打印
   
2. int printfArray(char ArrayStr[10][30], int iNum)
   
3. {
   
4.         int i;
   
5.         for (i = 0; i < iNum; i++)
   
6.         {
   
7.                 printf("%s \n", ArrayStr[i]);
   
8.         }
   
9.         return 0;
   
10. }
    
11. 
    
12. // 排序函数
    
13. int sortArrayStr(char myArray[10][30], int iNum)
    
14. {
    
15.         int i = 0, j = 0;
    
16.         char buf[30];
    
17.         for (i = 0; i < iNum; i++)
    
18.         {
    
19.                 for (j = i + 1; j<iNum; j++)
    
20.                 {
    
21.                         if (strcmp(myArray[i], myArray[j]) > 0)
    
22.                         {
    
23.                                 strcpy(buf, myArray[i]);
    
24.                                 strcpy(myArray[i], myArray[j]);
    
25.                                 strcpy(myArray[j], buf);
    
26.                         }
    
27.                 }
    
28.         }
    
29.         return 0;
    
30. }
    
31. 
    
32. int main()
    
33. {
    
34.         int i = 0, j = 0;
    
35.         char buf[30];   //buf数组名代表数组元素首地址
    
36.                                         //下面两种，内存模型不一样
    
37.                                         //         char *ArrayStr[] = { "ccccc","aaaa", "bbbb", "11111"};
    
38.         char myArray[10][30] = { "cccc", "aaaa", "dddd", "11111" };   // 二维数组数组名代表什么
    
39. 
    
40.         printf("排序之前：\n");
    
41.         printfArray(myArray, 4);
    
42. 
    
43.         sortArrayStr(myArray, 4);
    
44. 
    
45.         printf("排序之后：\n");
    
46.         printfArray(myArray, 4);
    
47.         system("pause");
    
48.         return 0;
    
49. }

复制代码

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

1. int printfArr33(char **ArrayStr, int iNum)
   
2. {
   
3.         int i = 0;
   
4.         for (i=0; i<iNum; i++)
   
5.         {
   
6.                 printf("%s \n", ArrayStr[i]);
   
7.         }
   
8.         return 0;
   
9. }
   
10. 
    
11. int printfArr2_23(char myArray[10][100], int iNum)
    
12. {
    
13.         int i = 0;
    
14.         for (i=0; i<iNum; i++)
    
15.         {
    
16.                 printf("%s \n", myArray[i]);
    
17.         }
    
18.         return 0;
    
19. 
    
20. }
    
21. 
    
22. 
    
23. int sortArrayStr03(char **ArrayStr, int iNum)
    
24. {
    
25.         int i = 0, j = 0;
    
26.         char *tmp = NULL;
    
27.         //排序
    
28. 
    
29.         for (i=0; i<iNum; i++)
    
30.         {
    
31.                 for (j=i+1; j<iNum; j++)
    
32.                 {
    
33.                         if (strcmp(ArrayStr[i],ArrayStr[j]) < 0)
    
34.                         {
    
35.                                 tmp = ArrayStr[i];
    
36.                                 ArrayStr[i] = ArrayStr[j];
    
37.                                 ArrayStr[j] = tmp;
    
38.                         }
    
39.                 }
    
40.         }
    
41.         return 0;
    
42. }
    
43. 
    
44. void main()
    
45. {
    
46.         int i = 0, j = 0;
    
47.         char buf[100];
    
48.         char **myarray = (char **)malloc(10*sizeof(char*)); //int array[10]
    
49.         if (myarray == NULL)
    
50.         {
    
51.                 return;
    
52.         }
    
53.         for (i=0; i<10; i++)
    
54.         {
    
55.                 myarray[i] = (char *)malloc(100*sizeof(char)); //char buf[100];
    
56.                 if (myarray[i]  == NULL)
    
57.                 {
    
58.                         printf("ddddde\n");
    
59.                         return;
    
60.                 }
    
61.                 sprintf(myarray[i],"%d%d%d ", i, i, i);
    
62.         }
    
63. 
    
64.         //第三种内存模型打印
    
65.         printf("排序之前\n");
    
66.         printfArr33(myarray, 10);
    
67.         //printfArr2_23(myarray, 10); //第二种打印不适合 err
    
68. 
    
69.         sortArrayStr03(myarray, 10);
    
70. 
    
71.         //第三种内存模型打印
    
72.         printf("排序之后\n");
    
73.         printfArr33(myarray, 10);
    
74. 
    
75.         for (i=0; i<10; i++)
    
76.         {
    
77.                 free(myarray[i] );
    
78.         }
    
79.         if (myarray != NULL)
    
80.         {
    
81.                 free(myarray);
    
82.         }
    
83. 
    
84.         system("pause");
    
85. }

复制代码

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