如何存儲多個數組並指向它們的指針

Question

我對指針沒有太多的經驗，但我想嘗試製作一個指針數組，每個指針指向一個掃描的字符串。 例如，您首先輸入要掃描的字符串數（例如5），然後我想要掃描這些字符串並創建一個指向這些字符串的5個指針數組。

因爲我沒有像這樣的東西有很多的經驗，我先用正常的數組，而不是字符串試了一下，我得到的是這樣的：

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

int **array(int m, int n) {  
int i, j; 
int **array = malloc(n*sizeof(int*)); 

for (j=0; j<m; j++) { 
    for (i=0; i<n; i++) { 
    array[i]=malloc(m * sizeof(int)); 
    scanf("%d", &array[j][i]); 
    printf("array[%d][%d] is scanned and has value %d\n", j, i, array[j][i]); 
    } 
} 
return array; 
} 


int main(int argc, char*argv[]){ 
int m, n, *p, k; 

scanf("%d %d", &m, &n); 

printf("m is %d and n is %d\n", m, n); 

p=*array(m, n); 



printf("the numbers are:\n"); 

for (k=0; k<m*n; k++) { 
printf("%d\n", p[k]); 
} 


return 0; 

} 

但在這裏它已經走錯了，並我不知道爲什麼... 在最後一個printf，我總是得到錯誤的數字，0和17's ... 有人可以解釋我爲什麼這是，我做錯了什麼？我認爲這是與陣列的返回，但我不知道..

如果有人能解釋這對我來說，這將是偉大的。

Answer 1

問題與您的代碼如下：

// m = 3, n = 5 
// array = ptr1, ptr2, ptr3, ptr4, ptr5 
//   |  | 
//   3 ints | 
//     3 ints .. 

int **array(int m, int n) {  
    int i, j; 
    int **array = (int**)malloc(n*sizeof(int*)); 

    for (j=0; j<m; j++) { 
    for (i=0; i<n; i++) { 
     array[i]=(int*)malloc(m * sizeof(int)); 
     scanf("%d", &array[j][i]); 
     printf("array[%d][%d] is scanned and has value %d\n", j, i, array[j][i]); 
    } 
    } 
    return array; 
} 

在上述例子中（M = 3，N = 5）你分配5個指向整數，然後試圖填充它們通過在每個分配存儲器迭代在內部循環（錯誤）。如果你在每次迭代時分配新的內存，你將失去指向先前分配的內存和你存儲的數據的指針！

加上指數似乎是錯誤的內循環和外循環，你的代碼的正確版本是：

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

// 3, 5 
// array = ptr1, ptr2, ptr3, ptr4, ptr5 
//   |  | 
//   3 ints | 
//     3 ints .. 

int **array(int m, int n) {  
    int i, j, index; 
    int **array = (int**)malloc(n*sizeof(int*)); 
    index = 0; 

    for (j=0; j<n; j++) { 
    array[j]=(int*)malloc(m * sizeof(int)); // Allocate once per each j 
    for (i=0; i<m; i++) { 
     array[j][i] = index++; 
     printf("array[%d][%d] is scanned and has value %d\n", j, i, array[j][i]); 
    } 
    } 
    return array; 
} 


int main(int argc, char*argv[]){ 
    int m, n, **p, k, i, j; 

    m = 3; 
    n = 5; 

    printf("m is %d and n is %d\n", m, n); 

    p=array(m, n); 



    printf("the numbers are:\n"); 

    for (j=0; j<n; j++) 
    for(i=0; i<m; i++) 
     printf("%d\n", p[j][i]); 


    return 0; 

} 

和上面的版本是仍然沒有正確：你需要釋放分配記憶！

我會留下這個練習..提示：你不能簡單地做「免費（p）;」 ：]

Answer 2

你確定這個for循環嗎？如果你已經因爲每次你重寫相同的細胞你沒有創建一個矩陣內環內的malloc ...

int i, j; 
int **array = malloc(n*sizeof(int*)); 

for (j=0; j<m; j++) { 
    for (i=0; i<n; i++) { 
    array[i]=malloc(m * sizeof(int)); 
    scanf("%d", &array[j][i]); 
    printf("array[%d][%d] is scanned and has value %d\n", j, i, array[j][i]); 
    } 
} 

它應該是這樣的：

int i, j; 
int **array = malloc(n*sizeof(int*)); 

for (i=0; i<n; i++) { 
    array[i]=malloc(m * sizeof(int)); 
    for (j=0; j<m; j++) { 
     scanf("%d", &array[i][j]); 
     printf("array[%d][%d] is scanned and has value %d\n", i, j, array[i][j]); 
    } 
} 

Answer 3

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

void *array(int m, int n) { 
    int i, j; 
    int (*array)[n] = malloc(sizeof(int [m][n]));//m*n*sizeof(int) 

    for (j=0; j<m; j++) { 
     for (i=0; i<n; i++) { 
      scanf("%d", &array[j][i]); 
      printf("array[%d][%d] is scanned and has value %d\n", j, i, array[j][i]); 
     } 
    } 
    return array; 
} 

int main(int argc, char*argv[]){ 
    int m, n, *p, k; 

    scanf("%d %d", &m, &n); 
    printf("m is %d and n is %d\n", m, n); 

    p=(int*)array(m, n); 

    printf("the numbers are:\n"); 
    for (k=0; k<m*n; k++) { 
     printf("%d\n", p[k]); 
    } 

    return 0; 

} 

---

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

char **array(int m, int n) { 
    int i; 
    char **array = malloc(m*sizeof(char*)); 

    for (i=0; i<m; ++i) { 
     array[i] = malloc(n*sizeof(char));//Fixed length : like char array[m][n] (char *array[m]) 
     scanf("%s", array[i]);//!! There is no length constraints. 
     printf("array[%d] is scanned and has value %s\n", i, array[i]); 
    } 
    return array; 
} 

int main(int argc, char*argv[]){ 
    int m, n, k; 
    char **p; 

    scanf("%d %d", &m, &n); 
    printf("m is %d and n is %d\n", m, n); 

    p=array(m, n); 

    printf("the string are:\n"); 
    for (k=0; k<m; ++k) { 
     printf("%s\n", p[k]); 
    } 

    return 0; 

} 

Answer 4

我不知道如果我這樣做聰明，但我通常分配指針數組，然後分配整個內存塊的第一個項目。然後我得到數據的連續內存。像：

_array = (float**) malloc(n * sizeof (float *)); 
assert (_array != NULL); 

_array[0] = (float*) malloc(n * m * sizeof (float)); 
assert (_array[0] != NULL); 

for (idx = 0; idx < n; idx++) 
    _array[ idx ] = _array[ 0 ] + idx * m; 

（浮動不是int在我的情況下，請不要在malloc鑄造的迴歸發表評論，也沒有對assert()傻用戶。）