Allocation dynamique tableau 2D

[Janosch]

Salut à tous!
J'ai une question: je vois souvent des déclarations faites comme ceci:

int ligne, colonne;
int **tab;

tab = (int**)malloc(ligne * sizeof(int*));

for (int i=0; i<ligne; i++)
    tab[i] = (int*)malloc(colonne * sizeof(int));

for (int i=0; i<ligne; i++)
    free(tab[i]);
free(tab);

Je ne comprends pas à quoi sert le "(int**)" de la ligne

tab = (int**)malloc(ligne * sizeof(int*));

le (int**) c'est pour faire une conversion, nan? ducoup on convertit un malloc en tableau 2D?
Y'a des choses qui m'échappent...
-----

[umfred]

tab c'est bien un int** non ? donc il faut bien réserver un espace pour un tableau 2D

[Janosch]

C'est vrai qu'en y réfléchissant mieux, ce n'est pas plus bizarre ça, que de faire

int *tab;
int nbElements = 10;
tab = (int*)malloc(nbElements * sizeof(int));

Dans les cours que j'ai eu, on faisait pas comme ça pourtant...
On m'a jamais dit de mettre un cast devant un malloc (on en parle pas dans les cours d'openclassroom non plus),
d'ailleurs ça compile et marche bien sans.
Alors quoi? il doit y'avoir une raison quand même, personne n'a envie de taper du code en plus sans raison...

[umfred]

il faut aussi voir si c'est du C ou du C++, en C, le cast n'est pas utile; en C++ il faut le mettre (les cours de CC++ sur openclassroom ne sont plus forcément au top, même la communauté d'OC recommande les cours de zestedesavoir)

[A voir en vidéo sur Futura]

[pm42]

Alors quoi? il doit y'avoir une raison quand même, personne n'a envie de taper du code en plus sans raison...

Le C permettait historiquement de faire pas mal de choses parce qu'il a été conçu pour être très concis et destiné à des programmeurs système pointus.
Notamment, on pouvait en gros affecter n'importe quoi dans n'importe quoi sans grosse vérification de type, des entiers dans des pointeurs, etc.

Cela a fait le bonheur des gens qui voulaient écrire du code illisible et indirectement des hackers en tout genre parce que cela fait partie des choses qui augmentent la vulnérabilité des programmes (un peu mais quand même).

Donc même si ce n'est pas nécessaire, on essaie maintenant de prendre l'habitude de dire ce qu'on attend de malloc. Cela facilite le travail de ceux qui reviennent lire le code derrière et quand on programme professionnellement, une ligne est lue 20 à 100 fois plus souvent qu'elle n'est écrite et rarement par l'auteur original.

[Janosch]

Je comprends mieux, merci beaucoup pour vos réponses.
ça donnerait quoi avec des structures?
Quelque chose comme ça?

struct Coord
{
    int x;
    int y;
};

struct Coord *point = NULL;
point = (struct Coord*)malloc(sizeof(point));
free(point);

[umfred]

presque, point n'est un type contrairement à Coord

struct Coord
{
    int x;
    int y;
};

struct Coord *point = NULL;
point = (struct Coord*)malloc(sizeof(struct Coord));
free(point);

avec un typdef devant la définition de la structure, on pourra se passer de remettre struct dans les déclarations et le malloc

[Janosch]

Oui, c'est une erreur d'inattention de ma part.
Merci beaucoup!

[Paraboloide_Hyperbolique]

Bonsoir,

En fait, je pense qu'il y a un petite subtilité dans les codes écrit précédemment.

En C, il est légal de demander la taille d'une instance d'une structure et de la passer dans un malloc. Ainsi, le code suivant fonctionne parfaitement:

 struct Coord
{
    int x;
    int y;
};

struct Coord point; // Plain object, not a pointer.
point = (struct Coord*)malloc(sizeof(point));
free(point);

Tout comme le code suggéré par umfred:

 struct Coord
{
    int x;
    int y;
};

struct Coord *point = NULL;
point = (struct Coord*)malloc(sizeof(struct Coord));
free(point);

Tandis que le code écrit par Janosh est effectivement incorrect:

struct Coord
{
    int x;
    int y;
};

struct Coord *point = NULL; // A pointer to struct.
point = (struct Coord*)malloc(sizeof(point));
free(point);

Sauf que... celui-ci fonctionnera la plupart du temps (cela fonctionne sur ma machine et valgrind n'y trouve rien à redire).

Pourquoi ? Parce que sur les machines fonctionnant sur 64 bits, un pointeur fait 8 octets... et que cela se trouve être la taille de la structure Coord.

Par contre, si on met à jour la structure (pour passer de la 2D à la 3D par exemple), celle-ci est d'une taille différente de celle d'un pointeur. Et là cela plante. Comme par exemple:

struct Coord
{
    int x;
    int y;
    int z;
};

struct Coord *point = NULL;
point = (struct Coord*)malloc(sizeof(point));
free(point);

Bref, le code de Janosh est fonctionnel, mais contient un !@/$#% de bug en puissance qui peut être ensuite difficile à débusquer*. Je pense que cela valait la peine d'être mentionné.

*Pas dans un code aussi simple qu'ici, mais bien dans un code plus complexe.

[pm42]

B
En C, il est légal de demander la taille d'une instance d'une structure et de la passer dans un malloc. Ainsi, le code suivant fonctionne parfaitement:

 struct Coord
{
    int x;
    int y;
};

struct Coord point; // Plain object, not a pointer.
point = (struct Coord*)malloc(sizeof(point));
free(point);

Tu as essayé de passer ça dans un compilo ? Parce que pour quelque chose qui fonctionne parfaitement, on a 2 erreurs même en corrigeant le fait qu'il n'y pas de fonction autour des instructions. Chez moi, il chope que le cast d'un (struct Coord*) pour le mettre dans un Struct Cord ne colle pas. Et ensuite, le free(point) est naturellement incorrect aussi.

[Paraboloide_Hyperbolique]

Tu as essayé de passer ça dans un compilo ? Parce que pour quelque chose qui fonctionne parfaitement, on a 2 erreurs même en corrigeant le fait qu'il n'y pas de fonction autour des instructions. Chez moi, il chope que le cast d'un (struct Coord*) pour le mettre dans un Struct Cord ne colle pas. Et ensuite, le free(point) est naturellement incorrect aussi.

Zut. Ce code est en effet faux. Et évidemment, c'est celui que je n'ai pas fait passer par le compilo... Voici une version corrigée*:

*En supposant que l'on mette tout ça correctement dans une fonction qui va bien. (Je ne l'ai pas fait, car je l'ai supposé implicitement, tout comme les intervenants avec leurs codes avant moi).

struct Coord
{
    int x;
    int y;
};

struct Coord point; // Plain object, not a pointer.
struct Coord* point_ptr = NULL; // A pointer.
point_ptr = (struct Coord*)malloc(sizeof(point));
free(point_ptr);