Je suis débutant en programmation c et je suis les cours de Jason Champagne sur utube: .https://www.youtube.com/watch?v=71QV6fFl_bk&list=PLrSOXFDHBtfEh6PCE39HERGgbbaIHhy4j&index=15
J'en suis à l'allocation dynamique je connais maintenant les fonctions malloc realloc calloc et sizeof.
Ce que je voudrai faire c'est alloué dynamiquement un tableau à deux dimensions.
J'ai faits le code suivant :
23 // Allocation dynamique à deux dimensions
24 int nombre_ligne = 3;
25 int nombre_colonne = 2;
26 int** tableau = NULL;
27 for (int i = 0; i < nombre_ligne ; i++)
28 {
29 tableau = malloc(sizeof(int*) * nombre_ligne);
30
31 for (int j = 0; j < nombre_colonne; j++)
32 {
33 tableau[i] = malloc(sizeof(int) * nombre_colonne);
34 tableau[i][j] = 1;
35 printf("%d", tableau[i][j]);
36
37 }
38 }
39
40 free(tableau);
Mais j'ai une erreur de segmentation et le compilateur ne me donne aucun indice je compile parfaitement donc je ne sais pas quoi faire pour résoudre le problème.
drx je ne te comprends pas c'est exactement ce que je faits.
J'ai mis des commentaires pour qu'on soit bien claire.
1 #include <stdio.h>
2 #include <stdlib.h>
3
4 int main(void)
5 {
6 int nombre_ligne = 3;
7 int nombre_colonne = 2;
8 int **tableau = NULL;
9 tableau = malloc(sizeof(*tableau) * nombre_ligne); // Allocation du nombre de ligne
10 for (int i = 0; i < nombre_ligne; i++)
11 {
12 for (int k = 0; k < nombre_colonne; k++)
13 {
14 tableau[i] = malloc(sizeof(**tableau) * nombre_colonne); // Pour une ligne j'associe une colonne
15 tableau[i][k] = 1; // Je donne une valeur ligne colonne à mon tableau
16 printf("%d", tableau[i][k]);
17 }
18 }
19 free(tableau); // je libere mon pointeur pour éviter les fuites mémoires
20
21 return 0;
22 }
ha d'accord merci rouloude c'est plus clair comme ça
Je vais essayer d'allouer de la mémoire dynamiquement à un tableau à trois dimension
Je ne clos pas encore le sujet je vais vous montrer un bout de code sur un tableau à trois dimension.
Pour alloué dynamiquement un tableau à trois dimension j'ai fait ça je ne suis pas du tout sur de moi mais ça compile et j'ai un affichage qui semble correct.
Es ce que cela vous semble juste.
Merci encore pour votre aide.
1 #include <stdio.h>
2 #include <stdlib.h>
3
4 int main(void)
5 {
6 // int nombre_ligne = 3;
7 // int nombre_colonne = 2;
8 // int **tableau = NULL;
9 // tableau = malloc(sizeof(*tableau) * nombre_ligne); // Allocation du nombre de ligne
10 // for (int i = 0; i < nombre_ligne; i++)
11 // {
12 // tableau[i] = malloc(sizeof(**tableau) * nombre_colonne); // Pour une ligne j'associe une colonne
13 // for (int k = 0; k < nombre_colonne; k++)
14 // {
15 // tableau[i][k] = 1; // Je donne une valeur ligne colonne à mon tableau
16 // printf("%d", tableau[i][k]);
17 // }
18 // }
19 // free(tableau); // je libere mon pointeur pour éviter les fuites mémoires
20
21 int premiere_dimension = 3;
22 int deuxieme_dimension = 2;
23 int troisieme_dimension = 1;
24
25 int*** tableau = NULL;
26 tableau = malloc(sizeof(*tableau) * premiere_dimension); // allocation mémoire de la premiere dimension
27 for (int i = 0; i < premiere_dimension; i++)
28 {
29 tableau[i] = malloc(sizeof(**tableau) * deuxieme_dimension); // allocation mémoire de la deuxieme dimension
30 for (int j = 0; j < deuxieme_dimension; j++)
31 {
32 tableau[i][j] = malloc(sizeof(***tableau) * troisieme_dimension);
33
34 for (int k=0; k < troisieme_dimension; k++)
35 {
36 tableau[i][j][k] = 1;
37 printf("%d", tableau[i][j][k]);
38 }
39
40 }
41 }
42 free(tableau);
43
44 return 0;
45 }
ça y ressemble. Sauf que tu ne vérifies pas ton allocation. Il faut donc l'ajouter. à titre d'exercice, je te propose de la mettre en place et de coder la libération mémoire en cas d'erreur.
Il y a une méthode beaucoup plus simple pour un tableau à 2 dimensions:
Soit ARRAY_WIDTH et ARRAY_HEIGHT deux constantes (ou bien utiliser des variables à la place si on ne connaît pas la taille du tableau à l'avance).
Il suffit d'allouer ARRAY_WIDTH * ARRAY_HEIGHT en un seul coup , ce qui fait que l'on a à vérifier une seule allocation et on accède aux case du tableau avec la code suivant: array_ptr[x * ARRAY_HEIGHT + x] et en plus c'est cache friendly donc c'est optimisé. Exemple:
Bien sur la fonction ci-dessus peut -être codée différemment, par exemple elle peut renvoyer un malloc (via return) et on traite l'erreur à l'extérieur, le C étant multi paradigme.
P.S. : hônnetement vérifier les sous allocations une à une et élaborer des mécanismes pour sortir de toutes ces allocations tiens plus de la prise de tête que d'une solution simple.
Re P.S: avec une structure on peut enregistrer les infos de la matrice pour les transporter dans les différentes fonctions assez simplement, par exemple:
Je dirais qu'il existe au moins trois formes possibles. Je prend l'exemple de 3 dimensions : - le tableau de tableaux de tableaux : Type*** tableau1 qui va demander de nombreuses allocations. - le tableau linéarisé : Type* tableau2 qui ne demande qu'une seule allocation. Si les dimensions sont des constantes il a un équivalent Typetableau3[NB_COL*NB_LIG*NB_PROF]. - le tableau à 3 dimensions : Type* tableau4[NB_LIG][NB_COL] qui lui aussi ne demande qu'une allocation mais exige que les 2 premières dimensions soient des constantes compilation. Si les 3 sont constantes, son équivalent est Type tableau5[NB_COL][NB_LIG][NB_PROF].
tableau1, tableau4 et tableau5 s'utilisent de la même manière : tableau[k][j][i]. tableau2 et tableau3 nécessitent une formule pour accéder aux éléments : tableau[k*nb_col*nb_lig + j*nb_col + i].
@PierreBoutier1 : dans ton code ci-dessus tu ne fais qu'un seul free() (tout à la fin) alors que tu as plusieurs malloc() . Il faut faire autant de free qu'il y a de malloc() .
Ce n'est pas parce que les OS modernes font automatiquement le ménage à la fin de ton programme qu'il faut coder comme des cochons. (dit sur le ton de la plaisanterie, hein ).
@PierreBoutier1 : pense à subdiviser ton code en fonctions, c'est une bonne pratique à prendre (idéalement une fonction doit faire une seul chose (que l'on peut deviner à son nom), mais le faire bien) .
C'est ce que l'on appelle le S.R.P : Single Responsability Principle
Je dirais qu'il existe au moins trois formes possibles. Je prend l'exemple de 3 dimensions : - le tableau de tableaux de tableaux : Type*** tableau1 qui va demander de nombreuses allocations. - le tableau linéarisé : Type* tableau2 qui ne demande qu'une seule allocation. Si les dimensions sont des constantes il a un équivalent Typetableau3[NB_COL*NB_LIG*NB_PROF]. - le tableau à 3 dimensions : Type* tableau4[NB_LIG][NB_COL] qui lui aussi ne demande qu'une allocation mais exige que les 2 premières dimensions soient des constantes compilation.
On peut aussi avoir fromage et dessert, avec une seule allocation par dimension.
Exemple, pour un tableau 2d de NBR x NBC entiers
int * data = malloc (NBR * NBC * sizeof(int)) pour les éléments
int ** array = malloc (NBR * sizeof (int *)) pour les pointeurs de ligne
Et boucle pour remplir array:
for (int r=0; r<NBR; r++) {
array[r] = data + r * NBC;
}
Ce qui permet d'utiliser la notation array[r][c], tout en conservant la localité des données et en évitant l'overhead d'une allocation par ligne.
En fait, par rapport à la linearisation ça revient à précalculer les positions de début des lignes, et à échanger une multiplication contre une indexation.
Allocation dynamique d'un tableau à deux dimensios
× 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.
Bonhomme !! | Jeu de plateforme : Prototype.
Bonhomme !! | Jeu de plateforme : Prototype.
Bonhomme !! | Jeu de plateforme : Prototype.
Mon site web de jeux SDL2 entre autres : https://www.ant01.fr
En recherche d'emploi.
Mon site web de jeux SDL2 entre autres : https://www.ant01.fr
On écrit "j'ai tort", pas "tord" qui est le verbe "tordre" à la 3ème personne de l'indicatif présent
En recherche d'emploi.
Mon site web de jeux SDL2 entre autres : https://www.ant01.fr