這兩種內存分配方法有什么區別？

Question

以下是p[10][10]數組的內存分配方法。

//First
char** p;
int i;
p=(char**)malloc(10*sizeof(char*));
for(i=0;i<10;i++)
    p[i]=(char*)malloc(10*sizeof(char));

//Second
char** p;
int i;
p=(char**)malloc(10*sizeof(char*));
*p=(char*)malloc(100*sizeof(char));
for(i=1;i<10;i++)
    p[i]=p[0]+10*i;

兩者有什么區別？

Answer 1

這些都不是C ++。 第一個分配一個10 char*的數組，然后將每個數組分配給一個單獨的動態分配的10 char數組。 每個10的數組是獨立的，因此您無法保證p[0][9]和p[1][0]之間的差異：

  p
+------+
| p[0] |  --> [][][][][][][][][][]
+------+
| p[1] |  --> [][][][][][][][][][]
+------+
|      |  --> [][][][][][][][][][]
+------+
 ...  
+------+
| p[9] |  --> [][][][][][][][][][]
+------+

在第二種情況下，你有一個100個char連續數組，你的10個char*每個指向不同的段：

   0  1  2      10     20
  +--+--+--+   +--+   +--+
  |  |  |  |...|  |...|  |...    <== dynamically allocated array of 100 char
  +--+--+--+   +--+   +--+
    |         /       /
    \        /       /
  +------+------+------+
p | p[0] | p[1] | p[2] |...      <== dynamically allocated array of 10 char*
  +------+------+------+

在這里你可以保證p[0][9]之后的下一個char是p[1][0] 。

雖然這些都不是真正的陣列。 要做到這一點，你需要：

char p[10][10]; 

這將給出第二個塊的等效行為 - 減去10個char*的所有額外開銷和動態內存分配。 在C ++中，我們更願意將其編寫為：

std::array<std::array<char, 10>, 10> p;

Answer 2

您正在動畫片段中動態分配數組。 不同之處在於，第一個代碼段為Zig-zag（取決於內存空間的可用性）方式中的10個char指針中的每一個分配內存。 第二個片段為10個char指針中的每一個分配連續內存。

請參閱圖片以更清楚地了解它

int **array1 = malloc(nrows * sizeof(int *));
    for(i = 0; i < nrows; i++)
        array1[i] = malloc(ncolumns * sizeof(int));    

int **array2 = malloc(nrows * sizeof(int *));
    array2[0] = malloc(nrows * ncolumns * sizeof(int));
    for(i = 1; i < nrows; i++)
        array2[i] = array2[0] + i * ncolumns; 

進一步閱讀： 如何動態分配多維數組？ 。

Answer 3

在此代碼段中

char** p;
int i;
p=(char**)malloc(10*sizeof(char*));
for(i=0;i<10;i++)
    p[i]=(char*)malloc(10*sizeof(char));

為char *類型的10個指針的一維數組分配內存：

p=(char**)malloc(10*sizeof(char*));

每個指針依次由分配的內存地址初始化，用於char類型的10個元素的一維數組：

for(i=0;i<10;i++)
    p[i]=(char*)malloc(10*sizeof(char));

在這個cade片段

char** p;
int i;
p=(char**)malloc(10*sizeof(char*));
*p=(char*)malloc(100*sizeof(char));
for(i=1;i<10;i++)
    p[i]=p[0]+10*i;

首先為第一個代碼片段中的10個char *元素的一維數組分配內存。

p=(char**)malloc(10*sizeof(char*));

然而，對於100個char類型元素的on-dimensional數組，只有數組的第一個元素由已分配內存的地址初始化。

*p=(char*)malloc(100*sizeof(char));

以上陳述相當於

p[0]=(char*)malloc(100*sizeof(char));

然后其他9個指針由整數表達式10*i初始化

for(i=1;i<10;i++)
    p[i]=p[0]+10*i;

很明顯，這沒有意義。 這9個元素的值無效，因為它們不是指向對象的指針。 這是初始化的目的尚不清楚。

考慮到您可以通過以下方式為一個二維數組分配內存

char ( *p )[10] = malloc( 100 * sizeof( char ) );

這種分配的優點是你只需要一次free調用就可以釋放所有分配的內存。 此外，此指針可用作具有參數作為兩個二元數組的函數的參數。

例如

void func( char a[][10] );

您可以將此功能稱為

func( p );

但是，如果p具有char **類型，則可能無法調用該函數，因為此類型與參數類型不兼容。