繁体   English   中英

如何在一个函数中动态分配2D数组并在C中以另一个函数打印它?

[英]How to dynamically allocate a 2D array in one function and print it in another in C?

我想在一个函数中动态分配一个2D数组,然后在另一个函数中打印它,但是createMapBoard()函数的返回值必须是指向该数组地址的指针。 下面是我的代码。 它编译并打印出来,但仅从creatMapBoard()函数中输出。 它不会在数组中读取到printMapBoard(** char)函数,我不确定为什么。

#include <stdio.h>

char **createMapBoard(void);
void printMapBoard(char **board);
char **destroyMapBoard(char **board);

int main(){
    char **board = createMapBoard();
    printMapBoard(board);
    destroyMapBoard(board);
    printMapBoard(board);

    return 0;
}

char **createMapBoard(void){
    char **ptr[8][8];
    int i,j;
    char F = 'F';
    char K = 'K';
    char C = 'C';
    char D = 'D';
    char B = 'B';
    int n = 8;
    int m = 8;

    for(j=0; j<8; j++){
        for(i=0;i<8;i++){
            ptr[j][i] = ' ';
        }
    }

    ptr[0][0] = F;
    ptr[0][1] = F;
    ptr[1][1] = F;
    ptr[2][1] = F;
    ptr[2][2] = F;
    ptr[3][2] = F;
    ptr[4][2] = K;
    ptr[5][0] = C;
    ptr[5][3] = B;
    ptr[6][1] = C;
    ptr[6][2] = C;
    ptr[6][4] = D;
    ptr[7][2] = C;
    ptr[7][5] = D;
    ptr[7][6] = D;

    printf("========\n");

    for(j=0;j<8;j++){
        for(i=0;i<8;i++){
            printf("%c",ptr[j][i]);
        }
        printf("\n");
    }

    printf("========\n");
    printf("\n");

    return **ptr;
}

void printMapBoard(char **board){
    int j, i;
    printf("========\n");
    for(j=0;j<8;j++){
        for(i=0;i<8;i++){
            printf("%c", board[j][i]);
        }
        printf("\n");
    }
    printf("========\n");
    printf("\n");
}

char **destroyMapBoard(char **board){
    free(**board);
    free(board);

    return 0;
}

有一些方法可以在C中创建2D数组。我选择了指向指针方法的指针。

  1 #include <stdio.h>                                                                    
  2 #include <stdlib.h>                                                                   
  3                                                                                       
  4 const int row = 8;                                                                    
  5 const int col = 8;                                                                    
  6                                                                                       
  7 char **createMapBoard(void);                                                          
  8 void printMapBoard(char **board);                                                     
  9 int destroyMapBoard(char **board);                                                    
 10                                                                                       
 11 int main()                                                                            
 12 {                                                                                     
 13    char **board = createMapBoard();                                                   
 14                                                                                       
 15    printMapBoard(board);                                                              
 16    destroyMapBoard(board);                                                            
 17                                                                                       
 18    return 0;                                                                          
 19 }                                                                                     
 20                                                                                       
 21 char **createMapBoard(void)                                                           
 22 {                                                                                     
 23                                                                                       
 24    char **ptr;                                                                        
 25                                                                                       
 26    int i, j;                                                                          
 27                                                                                       
 28    char F = 'F';                                                                      
 29    char K = 'K';                                                                      
 30    char C = 'C';                                                                      
 31    char D = 'D';                                                                      
 32    char B = 'B';                                                                      
 33                                                                                       
 34    int n = 8; // rows                                                                 
 35    int m = 8; // columns                                                              
 36                                                                                       
 37    ptr = (char **)malloc( row * sizeof(char *) );                                     
 38    for (i = 0; i < row; ++i) {                                                        
 39       ptr[i] = (char *)malloc( col * sizeof(char *) );                                
 40    }                                                                                  
 41                                                                                       
 42    for (j = 0; j < row; j++){                                                         
 43       for (i = 0; i < col; i++) {                                                     
 44          ptr[j][i] = ' ';                                                             
 45       }                                                                               
 46    }                                                                                  
 47                                       
 48    ptr[0][0] = F;                                                                     
 49    ptr[0][1] = F;                                                                     
 50    ptr[1][1] = F;                                                                     
 51    ptr[2][1] = F;                                                                     
 52    ptr[2][2] = F;                                                                     
 53    ptr[3][2] = F;                                                                     
 54    ptr[4][2] = K;                                                                     
 55    ptr[5][0] = C;                                                                     
 56    ptr[5][3] = B;                                                                     
 57    ptr[6][1] = C;                                                                     
 58    ptr[6][2] = C;                                                                     
 59    ptr[6][4] = D;                                                                     
 60    ptr[7][2] = C;                                                                     
 61    ptr[7][5] = D;                                                                     
 62    ptr[7][6] = D;                                                                     
 63                                                                                       
 64    printf("========\n");                                                              
 65                                                                                       
 66    for (j = 0; j < row; j++) {                                                        
 67       for (i = 0; i < col; i++) {                                                     
 68         printf("%c",ptr[j][i]);                                                       
 69       }                                                                               
 70       printf("\n");                                                                   
 71    }                                                                                  
 72                                                                                       
 73    printf("========\n");                                                              
 74    printf("\n");                                                                      
 75                                                                                       
 76    return ptr;                                                                        
 77 }                                                                                     
 78                                                                                       
 79 void printMapBoard(char **board)                                                      
 80 {                                                                                     
 81    int j, i;                                                                          
 82    printf("========\n");                                                              
 83    for ( j = 0; j < row; j++) {                                                       
 84       for ( i = 0; i < col; i++) {                                                    
 85          printf("%c", board[j][i]);                                                   
 86       }                                                                               
 87       printf("\n");                                                                   
 88    }                                                                                  
 89    printf("========\n");                                                              
 90    printf("\n");                                                                      
 91 }                                                                                     
 92    
 93 int destroyMapBoard(char **board)                                                     
 94 {                                                                                     
 95    int i;                                                                             
 96    for (i = 0; i < col; ++i)                                                          
 97       free( board[i] );                                                               
 98                                                                                       
 99    free( board );                                                                     
100                                                                                       
101    return 0;                                                                          
102 }
#include <stdio.h>
#include <stdlib.h>

char * createMapBoard(void);
void printMapBoard(char board[8][8]);
char **destroyMapBoard(char board[8][8]);

int main(){
    char (*board)[8] = (char (*)[8])createMapBoard();
    printMapBoard(board);
    destroyMapBoard(board);
    //printMapBoard(board);

    return 0;
}    

char *createMapBoard(void){
    char (*ptr)[8] = (char (*)[8])malloc(sizeof(char) * 8 * 8);
    int i,j;
    char F = 'F';
    char K = 'K';
    char C = 'C';
    char D = 'D';
    char B = 'B';
    int n = 8;
    int m = 8;

    for(j=0; j<8; j++){
        for(i=0;i<8;i++){
            ptr[j][i] = ' ';
        }
    }

    ptr[0][0] = F;
    ptr[0][1] = F;
    ptr[1][1] = F;
    ptr[2][1] = F;
    ptr[2][2] = F;
    ptr[3][2] = F;
    ptr[4][2] = K;
    ptr[5][0] = C;
    ptr[5][3] = B;
    ptr[6][1] = C;
    ptr[6][2] = C;
    ptr[6][4] = D;
    ptr[7][2] = C;
    ptr[7][5] = D;
    ptr[7][6] = D;

    printf("========\n");

    for(j=0;j<8;j++){
        for(i=0;i<8;i++){
            printf("%c",ptr[j][i]);
        }
        printf("\n");
    }

    printf("========\n");
    printf("\n");

    return (char *)ptr;
}    

void printMapBoard(char board[8][8]){
    int j, i;
    printf("========\n");
    for(j=0;j<8;j++){
        for(i=0;i<8;i++){
            printf("%c", board[j][i]);
        }
        printf("\n");
    }
    printf("========\n");
    printf("\n");
}

char **destroyMapBoard(char board[8][8]){
    free(board);

    return 0;
}

在开始有关如何分配2D数组并将其传递给另一个数组的原始问题之前,您的代码已经以多种方式被破坏,这使得谈论原始点变得很困难。 让我们先解决它们,然后再进行讨论。

首先,通过使用类似ptr [j] [i] =''的语句,您大概想拥有一个二维字符数组,在这种情况下,您应该这样声明ptr。

char ptr[8][8]; // 2D array of chars

char** ptr[8][8];  // 2D array of pointers to pointers to chars

其次,如果要返回在createMapBorad内部创建的数组(ptr),则需要返回ptr,而不是** ptr。

return ptr;

return ** ptr;

表达式** ptr两次取消对ptr的引用,在这种情况下等效于ptr [0] [0],它将伪装成仿佛指向chars的指针(char **)的方式返回'F'(0x46)。 。 然后,您的printMapBoard访问地址0x46,这将导致segfault。 几乎可以肯定这不是您的本意。

修复它们之后,如果要返回“二维字符数组”而不是指针数组,则需要让createMapBoard返回char *而不是char **。 char **是指针(指向chars)的数组(指针)。

到目前为止,您至少需要将createMapBoard修复为:

char * createMapBoard(void) {
    char ptr[8][8];
    ...
    return (char *)ptr;
}

(我们尚未完成。敬请期待)。

顺便说一句,如果您可以说一个函数返回一个2D数组,而不是char *(本质上是1D数组,那么您不能做a [i] [j]之类的事情)会很好,但是AFAIK C不允许我们这样做去做这个。 以下(假设)代码是语法错误。

char[8][8] createMapBoard(void) {
    char ptr[8][8];
    ...
    return ptr;
}

因此,您需要假装返回一个常规一维数组(char *)。 您可以稍后将其投射到真实的2D数组中(我们很快就会使用它)。

用这种方法修复了createMapBoard之后,您仍然在返回本地数组作为返回值时出错。 这是错误的,因为本地数组的生存期仅限于函数调用的结束。 所以代码

char * createMapBoard(void) {
    char ptr[8][8];
    ...
    return (char *)ptr;
}

语法上可以,但是会输出错误的结果。

您需要调用malloc来创建一个从函数返回后仍处于活动状态的数组,例如:

char * createMapBoard(void) {
    char * ptr = (char *)malloc(sizeof(char) * 8 * 8);
    ...
    return ptr;
}

但是然后ptr本质上变成了createMapBoard函数内部的一维数组,这使得分配像

ptr[i][j] = ' '

不再有效。

使ptr成为2D数组的方式是这样的:

char (*ptr)[8] = (char (*)[8])malloc(sizeof(char) * 8 * 8);

C99标准支持。

这样,编译器将ptr理解为指向2D数组的指针,该数组的每行元素数为8(因此它可以正确计算a [i] [j]的地址)。

您可以让printMapBorad像这样简单地接受char [8] [8]的参数:

void printMapBorad(char board[8][8]) {
   ...
}

摘要:

  • 函数参数可以直接声明为2D数组(例如char a [8] [8])
  • char(* a)[8]可以将局部变量声明为2D数组。 (以及(char(*)[8])强制转换的普通指针)ordinary_ptr;
  • 函数返回类型不能声明为2D数组AFAIK,因此您需要假装它们是1D数组(并根据需要将其强制转换为适当的类型)

暂无
暂无

声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.

 
粤ICP备18138465号  © 2020-2024 STACKOOM.COM