J'ajoute juste que la seconde syntaxe n'est vraiment celle du C++.
int** mon_tableau = (int**)malloc(sizeof(int*)); // Ça ça marche en C et C++, ça serait pour du code à utiliser dans les 2 langages
auto mon_tableau = static_cast<int**>(malloc(sizeof(int*))); // Ça c'est avec un cast C++
int** mon_tableau = malloc(sizeof(int*)); // Ça c'est ce qu'il faut faire en C
J'ajoute juste que la seconde syntaxe n'est vraiment celle du C++.
int** mon_tableau = (int**)malloc(sizeof(int*)); // Ça ça marche en C et C++, ça serait pour du code à utiliser dans les 2 langages
auto mon_tableau = static_cast<int**>(malloc(sizeof(int*))); // Ça c'est avec un cast C++
int** mon_tableau = malloc(sizeof(int*)); // Ça c'est ce qu'il faut faire en C
Alors, celui qui utilise malloc en C++ ancien mérite déjà des coups de fouet.
Mais celui qui utilise du C++ moderne avec des static_cast, des auto, et des malloc, la il mérite un supplice plus important !
Comme ton titre est "Déclaration d'un tableau de pointeurs avec malloc" je pense qu'il est utile de préciser que :
int ** mon_tableau = malloc(sizeof(int *));
ne déclare pas un type tableau de pointeurs, mais un type pointeur sur un pointeur sur int, et que malloc, ici, n'alloue de la mémoire que pour stocker l'adresse d'un seul pointeur sur int, ce qui ne permet pas de s'en servir avec l'opérateur [] pour itérer dans une liste de pointeurs sur int sur une zone contiguë de mémoire comme s'il s'agissait d'un tableau.
C'est vachement intéressant ! Moi qui était entrain de continuer mon programme en me rendant compte que ce dernier plantait lorsque à certains moment l'opérateur"[]" faisait planter mon programme -_-
J'ai du mal à expliquer, mais je compte faire comme dans cet exemple, avec ce fameux tableau de pointeurs qui permet enfait de se "faire passer" pour un tableau à double entrée, car il redirige vers un tableau plus grand qui va stoquer toutes nos valeurs.
Du coup, dans ce cas quelle déclaration est-il préférable de faire pour que tout fonctionne ?
Si tu veux stocker plus d'un pointeur sur int, tu dois réserver autant d'espace que nécessaire pour stocker le nombre de pointeurs sur int que tu veux stocker. par exemple, pour en stocker 10 :
int ** mon_tableau = malloc(sizeof(int *) * 10);
A condition d'y avoir mis des adresses pointant sur quelque chose d'existant, en faisant mon_tableau[4] tu accéderas à un pointeur sur int que tu pourras déréférencer pour accéder un int. Ce tableau sera à une seule dimension, qui permet d'accéder à un pointeur sur int.
Maintenant, ton lien dans ton dernier message suggère que tu recherches une méthode pour créer une sorte de tableau dynamique à deux dimensions de int, alloué dynamiquement avec malloc, est-ce ce que tu veux faire ?
Le problème avec la méthode fournie sur ce lien (les deux) est que le tableau créé ne va pas contenir les éléments dans une zone contiguë de mémoire, car il alloue d'abord la mémoire pour le nombre de lignes du tableau (un malloc pour stocker nb_de_lignes pointeurs), puis le nombre de colonnes (avec un seul malloc ou avec nb_de_lignes appels à malloc pour stocker le nombres de colonnes de int nécessaire). En faisant cela, tu ne pourras pas utiliser le "tableau" avec un memcpy() dessus pour en faire une copie, ni l'initialiser avec memset().
Pour obtenir quelque chose qui ressemble à un tableau, tu peux déclarer :
int (*tableau2D)[colonnes] = malloc(lignes * sizeof(*tableau2D));
Par exemple :
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(void)
{
size_t colonnes = 5;
size_t lignes = 2;
int truc = 0;
int (*tableau2D_dyn)[colonnes] = malloc(lignes * sizeof(*tableau2D_dyn));
for (size_t i = 0; i < lignes; i++)
for (size_t j = 0; j < colonnes; j++)
tableau2D_dyn[i][j] = truc++;
int tableau_statique[2][5];
memcpy(tableau_statique, tableau2D_dyn, lignes * colonnes * sizeof(int));
free(tableau2D_dyn);
for (size_t i = 0; i < lignes; i++) {
for (size_t j = 0; j < colonnes; j++)
printf("%d\t", tableau_statique[i][j]);
printf("\n");
}
return 0;
}
Juste pour information: tu parles de créer une matrice avec seulement deux malloc, mais il y a aussi moyen de le faire avec un seul malloc.... (bon, ça s'utilise aussi un peu différement qu'avec un adressage [x][y])
- Edité par edgarjacobs 3 décembre 2021 à 19:22:14
On écrit "j'ai tort", pas "tord" qui est le verbe "tordre" à la 3ème personne de l'indicatif présent
Si on a nbLignes lignes et nbColonnes, on peut faire: int *tableau = malloc(nbLignes * nbColonnes * sizeof(int)); et on accède à la position [i][j] comme suit: valeur = tableau[nbColonnes * i + j];
Pour un tableau à 4 dimensions dont les dimensions sont d1, d2, d3,d4 Si on veut accéder à la position [i1][i2][i3][i4[: valeur = tableau[d2*d3*d4*i1 + d3*d4*i2 + d4*i3 + i4]; Ça prend moins de mémoire mais ça prend plus de calculs pour accéder à une position.
- Edité par PierrotLeFou 3 décembre 2021 à 20:13:19
Le Tout est souvent plus grand que la somme de ses parties.
Ton exemple est un peu particulier "Allocation avec seulement deux malloc".
Essais déjà de faire un tableau de tableau (tableau à 2 dimensions) d'entier alloué avec malloc "de façon classique" et montre nous le code.
(Si tu veux faire comme l'exemple, il donne la solution, hormis qu'il ne faut pas les casts).
@rouIoude C'est justement ma question, c'est ca que je cherchais à créer. Un tableau à double entrée alloué avec malloc().
C'est à ce moment-là que j'ai trouvé une solution qui se trouvait dans le lien que j'ai envoyé précedemment, et que je vous ai demandé de l'aide.
Dlks a écrit:
@Paresseux121 :
Si tu veux stocker plus d'un pointeur sur int, tu dois réserver autant d'espace que nécessaire pour stocker le nombre de pointeurs sur int que tu veux stocker. par exemple, pour en stocker 10 :
int ** mon_tableau = malloc(sizeof(int *) * 10);
A condition d'y avoir mis des adresses pointant sur quelque chose d'existant, en faisant mon_tableau[4] tu accéderas à un pointeur sur int que tu pourras déréférencer pour accéder un int. Ce tableau sera à une seule dimension, qui permet d'accéder à un pointeur sur int.
Maintenant, ton lien dans ton dernier message suggère que tu recherches une méthode pour créer une sorte de tableau dynamique à deux dimensions de int, alloué dynamiquement avec malloc, est-ce ce que tu veux faire ?
Le problème avec la méthode fournie sur ce lien (les deux) est que le tableau créé ne va pas contenir les éléments dans une zone contiguë de mémoire, car il alloue d'abord la mémoire pour le nombre de lignes du tableau (un malloc pour stocker nb_de_lignes pointeurs), puis le nombre de colonnes (avec un seul malloc ou avec nb_de_lignes appels à malloc pour stocker le nombres de colonnes de int nécessaire). En faisant cela, tu ne pourras pas utiliser le "tableau" avec un memcpy() dessus pour en faire une copie, ni l'initialiser avec memset().
Pour obtenir quelque chose qui ressemble à un tableau, tu peux déclarer :
int (*tableau2D)[colonnes] = malloc(lignes * sizeof(*tableau2D));
@Dlks C'est une méthode qui correspond bien à mon usage d'un tableau à double entrée !
Tes explications sont très utiles, cependant comment fait-on pour passer le tableau alloué avec malloc() dans une fonction ?
(excuse-moi si ca se trouve c'est vachement évient mais je suis passé à côté malgré les tests de mon côté )
PierrotLeFou a écrit:
Si on a nbLignes lignes et nbColonnes, on peut faire: int *tableau = malloc(nbLignes * nbColonnes * sizeof(int)); et on accède à la position [i][j] comme suit: valeur = tableau[nbColonnes * i + j];
Pour un tableau à 4 dimensions dont les dimensions sont d1, d2, d3,d4 Si on veut accéder à la position [i1][i2][i3][i4[: valeur = tableau[d2*d3*d4*i1 + d3*d4*i2 + d4*i3 + i4]; Ça prend moins de mémoire mais ça prend plus de calculs pour accéder à une position.
- Edité par PierrotLeFou il y a environ 18 heures
C'est aussi quelque chose de possible, mais je l'utiliserai pas malheureusement si il existe plus obtimisé aux niveau des instructions processeur
- Edité par Paresseux121 4 décembre 2021 à 15:30:54
Une façon de le faire tout en préservant une certaine flexibilité à ton code et en permettant l'usage de la notation [x][y] dans la fonction est de déclarer ton prototype de fonction avec la notation VLA permise par le C99 :
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void print_array(size_t lignes, size_t colonnes, int array[][colonnes]) {
for (size_t i = 0; i < lignes; i++) {
for (size_t j = 0; j < colonnes; j++)
printf("%d\t", array[i][j]);
printf("\n");
}
}
int main(void)
{
size_t colonnes = 5;
size_t lignes = 2;
int truc = 0;
int (*tableau2D_dyn)[colonnes] = malloc(lignes * sizeof(*tableau2D_dyn));
for (size_t i = 0; i < lignes; i++)
for (size_t j = 0; j < colonnes; j++)
tableau2D_dyn[i][j] = truc++;
printf("Contenu de tableau2D_dyn :\n");
print_array(lignes, colonnes, tableau2D_dyn);
int tableau_statique[2][5];
memcpy(tableau_statique, tableau2D_dyn, lignes * colonnes * sizeof(int));
free(tableau2D_dyn);
printf("Contenu de tableau_statique :\n");
print_array(lignes, colonnes, tableau_statique);
return 0;
}
Ce prototype fonctionne que le tableau 2D soit alloué dynamiquement ou statiquement et quelle que soit la dimension du tableau :
Voici ma petite recette. Je n'ai pas mis la vérification de la réservation avec malloc. int **tableau = malloc(nbLignes * sizeof(int *)); for(int i=0; i < nbLignes; i++) { tableau[i] = malloc(nbColonnes * sizeof(int)); } Tu peux faire ensuite: tableau[i][j] = valeur; Pour passer un tel tableau à une fonction, il doit être déclaré int **tableau dans le prototype. Et tu devras passer les deux dimensions à la fonction.
Pour rendre le code plus lisible, j'utilise une fonction qui appelle malloc: void *getArea(char *name, int size) { // name est une chaîne donnant généralement le nom de la fonction appelante. void *area = malloc(size); if(area) return area; perror(name); // requiere errno.h ou stdlib.h printf("Required: %d\n", size); exit(EXIT_FAILURE); // requière stdlib.h } Ici on pourrait l'appeler comme suit: int **tableau = getArea("main", nbLignes*sizeof(int *));
- Edité par PierrotLeFou 4 décembre 2021 à 16:46:54
Le Tout est souvent plus grand que la somme de ses parties.
Tant qu'on a affaire à des pointeurs on peut tricher le compilateur sur le type véritable du pointeur. Voici un exemple d'une fonction récursive qui permet d'alouer de la mémoire pour un tableau de n'importe quelles dimensions. Ça coûte cher de mémoire mais c'est assez rapide. - #include <stdio.h> #include <stdlib.h> typedef int type; void *getArea(char *name, int size) { void *area = malloc(size); if(area) return area; perror(name); printf("Required: %d\n", size); exit(EXIT_FAILURE); } type **hyperMatrix(int *dimensions, int nDim) { if(nDim <= 1) { type**matrix = getArea("hyperMatrix", *dimensions * sizeof(type)); return matrix; } else { type **matrix = getArea("hyperMatrix", *dimensions * sizeof(type*)); for(int i = 0; i < *dimensions; i++) { matrix[i] = (type*) hyperMatrix(dimensions+1, nDim - 1); } return matrix; } } int main(void) { int adim[4] = {10, 10, 10, 10}; type ****matrice = (type****) hyperMatrix(adim, 4); for(int i = 0; i < adim[0]; i++) { for(int j = 0; j < adim[1]; j++) { for(int k = 0; k < adim[2]; k++) { for(int l = 0; l < adim[3]; l++) { matrice[i][j][k][l] = 0; } // l } // k } // j } // i printf("Initialisation complétée\n"); return 0; }
- Edité par PierrotLeFou 5 décembre 2021 à 3:42:43
Le Tout est souvent plus grand que la somme de ses parties.
Ton exemple est un peu particulier "Allocation avec seulement deux malloc".
Essais déjà de faire un tableau de tableau (tableau à 2 dimensions) d'entier alloué avec malloc "de façon classique" et montre nous le code.
(Si tu veux faire comme l'exemple, il donne la solution, hormis qu'il ne faut pas les casts).
@rouIoude C'est justement ma question, c'est ca que je cherchais à créer. Un tableau à double entrée alloué avec malloc().
C'est à ce moment-là que j'ai trouvé une solution qui se trouvait dans le lien que j'ai envoyé précedemment, et que je vous ai demandé de l'aide.
Bonjour,
Alors première chose : les tableaux «multidimensionnels» n'existent pas en C. Tu auras toujours à faire à des tableaux de tableaux de tableaux de … d'éléments de type T.
Il y a en gros 2 familles de méthodes différentes qui ont chacune leurs avantages et inconvénients. En 2d cela donnerait :
Le classique tableau de tableau.
Ici tu considères un tableau 2D comme un tableau de pointeurs chacun pointant vers un tableau. Le premier tableau contient des pointeurs sur des tableaux qui représentent les lignes, chaque tableau ligne contenant autant d'éléments que de colonnes.
Il y a plusieurs inconvénients : la non localité des données qui pourront se retrouver dispersées en mémoire ce qui va empêcher d'avoir le gain de la mise en cache ; il y a beaucoup de malloc ce qui sur les petites plateformes est rédhibitoire ou ce qui rend les libérations mémoire plus fastidieuses (à chaque malloc son free).
Un avantage est qu'il permet d'avoir des lignes de longueurs différentes. Par exemple un tableau de Pascal sera un peu plus compact. Tu peux également facilement le redimensionner.
Le pointeur sur un tableau
Ici tout est plus simple :
int (*array)[nb_lig][nb_col] = malloc( sizeof *array );
Tu alloues toute la mémoire d'un coup, il y aura localité. Un malloc signifie un free …
Un inconvénient : la lourdeur d'écriture. Comme array est maintenant un pointeur sur un tableau il va toujours falloir le déréférencer :
A présent j'ai compris comment fonctionnais tout ca et j'ai pu l'inclure dans mon programme (n'hésitez pas si vous voulez le voir).
Mon problème est donc résolu.
Encore une fois (je ne le dirai jamais assez lol) merci, de vous êtes donné la peine de rédiger des gros pavés pour m'aider
Déclaration d'un tableau de pointeurs avec malloc.
× Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
× Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
Recueil de code C et C++ http://fvirtman.free.fr/recueil/index.html
En recherche d'emploi.
Recueil de code C et C++ http://fvirtman.free.fr/recueil/index.html
On écrit "j'ai tort", pas "tord" qui est le verbe "tordre" à la 3ème personne de l'indicatif présent
Le Tout est souvent plus grand que la somme de ses parties.
Le Tout est souvent plus grand que la somme de ses parties.
Le Tout est souvent plus grand que la somme de ses parties.