Votre question

|Résolut]Tableau dynamique en C

Tags :
  • Programmation
Dernière réponse : dans Programmation
10 Avril 2008 09:34:53

Bonjour!

Je suis un peu en galère pour crer un tableau dynamique en 2D en C.

Voilà comment je procède:
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3.  
  4. int main(){ //je veut faire un tableau 3*3
  5. int *p;
  6. p=(int*)malloc(3*sizeof(int)); //je met l'adresse de trois bloc dans p
  7. for(int i=0;i<3;i++){ //itération sur chaque bloc
  8. *p[i]=(int*)malloc(3*sizeor(int)); //chaque bloc prend l'adresse de trois autre bloc
  9. }
  10. }


Et là le compilateur me dit:
Citation :
prog2.c: In function âmainâ:
prog2.c:8: erreur: invalid type argument of âunary *â
(désoler il y a un problème d'encodage)

J'ai chercher sur google mais pas trouver grand chose de concluant!
Petite question:
A quoi sert le (int*) avant le malloc ?

Merci de votre aide!

Autres pages sur : resolut tableau dynamique

10 Avril 2008 09:38:44

ligne 8 essaye plutot un sizeof a la place du sizeor
en general ça marche mieux après :) 
10 Avril 2008 09:55:47

Si tu veux faire une matrice, pourquoi tu commence par déclarer 1 tableau à 1 dimension ?

Vermoute a dit :
  1. int *p;
  2. (...)
  3. *p[i]=(int*)malloc(3*sizeor(int)); //chaque bloc prend l'adresse de trois autre bloc


Soit :
  1. int **p;



Pour allouer ta matrice, il faut donc faire :
  1. p = (int**) malloc( 3 * sizeof(int*) );


On rajoute un petit test pour vérifier que la matrice à bien été alloué :
  1. if( p == NULL ) {
  2. fprintf(stderr,"Allocation impossible");
  3. exit(EXIT_FAILURE);
  4. }


On va ensuite allouer le reste de la matrice :
  1. for( int i = 0 ; i < 3 ; i++ ) {
  2. p[i] = (int*) malloc(3, sizeof(int) );
  3.  
  4. if( p[i] == NULL ) {
  5. fprintf(stderr,"Allocation impossible");
  6. exit(EXIT_FAILURE);
  7. }
  8. }


Ensuite, tu peux remplir comme tu le souhaites !


Donc, petit récapitulatif :
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3.  
  4. int main(){
  5. int **p;
  6.  
  7. p = (int**) malloc( 3 * sizeof(int*) );
  8.  
  9. if( p == NULL ) {
  10. fprintf(stderr,"Allocation impossible");
  11. exit(EXIT_FAILURE);
  12. }
  13.  
  14. for( int i = 0 ; i < 3 ; i++ ) {
  15. p[i] = (int*) malloc(3, sizeof(int) );
  16.  
  17. if( p[i] == NULL ) {
  18. fprintf(stderr,"Allocation impossible");
  19. exit(EXIT_FAILURE);
  20. }
  21. }
  22.  
  23. // Remplissages/Traitements de données
  24.  
  25. return 0;
  26. }


Vermoute a dit :
A quoi sert le (int*) avant le malloc ?


T'as appris le C ? C'est un cast ! La fonction malloc retourne le type de base ( void* ) .


totof59 a dit :
ligne 8 essaye plutot un sizeof a la place du sizeor


Petite faute de frappes sans importance, son programme est erroné de toute façon !
Il veut un tableau à deux dimensions, et il initialise le sien en 1 dimension ... Ça marchera jamais !

Vermoute a dit :
un tableau dynamique en 2D en C.


un tableau 2D = matrice !
Contenus similaires
10 Avril 2008 11:14:52

Ok j'ai compris le truc!
En faite s'était juste des problème d'étoile dans mon code.
Comme ça ça marche:
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3.  
  4. int main(){ //je veut faire un tableau 3*3
  5. int **p;
  6. p=(int**)malloc(3*sizeof(int*)); //je met l'adresse de trois bloc dans p
  7. for(int i=0;i<3;i++){ //itération sur chaque bloc
  8. p[i]=(int*)malloc(3*sizeof(int)); //chaque bloc prend l'adresse de trois autre bloc
  9. }
  10. }

Par contre il y a un truc que je n'ai pas compris:
p[j] par exemple, ce n'est pas une adresse ?
Parce qu'un printf me le prend que comme ça, pas d'étoile ?
10 Avril 2008 13:08:21

Si je me trompe pas
p[j] te renvoie un int
donc il faut taper
printf("%d",p[j]);

10 Avril 2008 18:42:43

Oui j'ai constater ça mais je trouve ça bizard!
si on a:
int *p;
p=(int*)malloc(sizeof(int);

p est une adresse et *p un entier !
a b L Programmation
10 Avril 2008 20:55:02

p[ i ] (contenu du ième élément de p) est équivalent à *(p + i) (adresse décalée de i, et on prend le contenu)
donc l'utilisation des opérateur [] prend bien le contenu. Pour ton problème p[ i ][ j ] est équivalent à (*(p + i))[ j ] équivalent à *(*(p + i) + j) p étant en fait ici un tableau de pointeurs pointant sur des tableaux à 1 dimension.
11 Avril 2008 09:05:00

Ok! Merci :)  !
Tom's guide dans le monde
  • Allemagne
  • Italie
  • Irlande
  • Royaume Uni
  • Etats Unis
Suivre Tom's Guide
Inscrivez-vous à la Newsletter
  • ajouter à twitter
  • ajouter à facebook
  • ajouter un flux RSS