tableau double par des pointeurs en C

Question

Je veux numériser un tableau 2D avec l'aide de pointeurs et ont écrit ce code, pourriez-vous me dire pourquoi le compilateur donne des erreurs?

#include<stdio.h> 
#include<stdlib.h> 
int main(void) { 
    int i,j,n,a,b; 
    int (*(*p)[])[]; 
    printf("\n\tEnter the size of the matrix in the form aXb\t\n"); 
    scanf("%dX%d",&a,&b); 
    p=(int (*(*p)[b])[a])malloc(b*sizeof(int (*p)[a])); 
    for(i=0;i<b;i++) { 
      p[i]=(int (*p)[a])malloc(a*sizeof(int)); 
      printf("\t\bEnter Column %d\t\n"); 
      for(j=0;j<a;j++) 
        scanf("%d",&p[i][j]); 
    } 
    return 0; 
} 

Answer 1

C'est une syntaxe assez déformée. Habituellement, lorsque vous faites un tableau 2D:

• La déclaration est tout simplement int *p;
• L'allocation est tout simplement p = malloc(a*b*sizeof(int));
• Vous ne pouvez pas écrire p[i][j]. Vous devez faire une de plusieurs choses - soit faire un tableau secondaire int **q qui contient des pointeurs de ligne pour pouvoir écrire q[i][j] (meilleures performances et la lisibilité), ou écrire p[b*i + j] (moins d'étapes).

De plus, notez que:

• Votre printf vomira les déchets en raison du paramètre% d manquant.
• Puisque C n'est pas typesafe, en utilisant scanf se cacheront des erreurs dans indirection que vous pouvez faire.

A propos de la chose la plus proche que je pouvais penser à qui ressemble à distance ce que vous essayez de faire:

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

int main() 
{ 
    int i, j; 

    const int a = 3, b = 4; 
    int m[4][3]; 
    int (*p[4])[3]; 

    for (i = 0; i < b; i++) 
    { 
     p[i] = &m[i]; 
     printf("\t\bEnter Column %d\t\n", i); 
     for (j = 0; j < a; j++) 
     { 
      int x; 
      scanf("%d", &x); 
      (*p[i])[j] = x; 
     } 
    } 
    return 0; 
} 

Il compile et fonctionne comme prévu, mais il est compliqué inutilement. p est un tableau de pointeurs vers des tableaux.

Answer 2

Cette déclaration a plusieurs problèmes:

p=(int (*(*p)[b])[a])malloc(b*sizeof(int (*p)[a])); 

D'abord, malloc renvoie une void*. Vous utilisez ce pointeur en utilisant (int (*(*p)[b])[a]) qui génère une valeur et non un type de données. Ce n'est pas une distribution valide, c'est donc une raison pour laquelle le compilateur vous crie dessus. À ce stade, p n'a pas été initialisé, de sorte que le dé-référencement effectué ici peut bloquer votre programme si cette instruction a été exécutée. Dans votre appel malloc, vous utilisez sizeof(int (*p)[a]). L'instruction int (*p)[a] n'est pas une instruction C valide.

Il semble que vous faites cela un peu plus complexe qu'il doit être. Il y a deux façons de construire un tableau 2D. Vous pouvez construire un tableau en utilisant malloc(a * b * sizeof(int)) comme l'explique Reinderien. Vous pouvez également créer un tableau 1D de pointeurs, chacun pointant vers un tableau de type int. De votre code, il semble que vous essayez de faire le dernier.

La plus facile de faire ce serait quelque chose comme ceci:

int **p; 
... get input from user ... 
// Declare an array of int pointers of length b 
p = malloc(b * sizeof(int*)); 

// For each int* in 'p' ... 
for (i = 0; i < b; ++i) { 
    // ... allocate an int array of length 'a' and store a pointer in 'p[i]' .. 
    p[i] = malloc(a * sizeof(int)); 
    // ... and fill in that array using data from the user 
    printf("\t\bEnter Column %d\t\n"); 
    for(j = 0; j < a; j++) 
     scanf("%d", &p[i][j]); 
} 

utilisant cette méthode de construction d'un tableau 2D vous permet d'utiliser la syntaxe p[x][y]. Depuis p est un pointeur à pointeur, p[x] est un pointeur sur un tableau et p[x][y] est un élément du tableau pointé à.