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 ... 有人可以解释我为什么这样做以及我做错了什么？我认为这与数组的返回有关，但我不确定..

如果有人能向我解释这一点，那就太好了。

Answer 1

你确定这个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 2

您的代码存在以下问题：

// 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个整数指针，然后尝试通过在内循环（WRONG）的每次迭代中分配内存来填充它们。如果你在每次迭代时分配新的内存，你将失去指向以前分配的内存和你存储的数据的指针！

此外，内部和外部循环的索引似乎都是错误的，代码的正确版本是：

#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 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()的愚蠢用户

如何存储多个数组并为它们制作指针数组

4 个答案: