erreur avec les pointeurs (je sais pas d'où ça vient)

**EpiTouille** · 30/12/2011, 14h34

Bonjour,

J'essaie de créer un petit casse brique en c, et je manipule des

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

int***

mais j'ai jamais fais ça avant, donc, c'est ça qui doit merder.

J'ai corriger tout les warning, mais quand je lance mon programme, il se ferme tout seul avec une erreur de windows du genre "le programme à cesser de fonctionner. Donc pas trop d'indication. Je pense que ça vient des mallocs mais pas sur

bon voici mon code

La fonction uptadePalet() est bien car ça marchait avant, ça vient soit de afficheBrique, de loadBrique ou du main

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
 
 
#include <stdio.h>
#include <sdl.h>
#include <stdlib.h>
 
 
 
 
SDL_Rect updatePalet(SDL_Surface* screen, SDL_Surface* palet, SDL_Event event)
{
  //On actualise la position du palet
  SDL_Rect newPosition;
 
  newPosition.x = event.motion.x;
  newPosition.y = 450;
  SDL_BlitSurface(palet,NULL,screen,&newPosition);
 
  return newPosition; 
 
}
 
int*** loadBrique() //Charge les briques à partir d'un fichier
{
  int ***tabBrique;
 
  //On construit la tableau
  //Allocation dynamique
  tabBrique = malloc(sizeof(int)*110);
 
  *tabBrique[0][0] = 1;  //On chargera dans un fichier après
  *tabBrique[0][1] = 1;
  *tabBrique[0][2] = 1;
  *tabBrique[0][3] = 1;
  *tabBrique[0][4] = 1;
  *tabBrique[0][5] = 1;
  *tabBrique[0][6] = 1;
  *tabBrique[0][7] = 1;
  *tabBrique[0][8] = 1;
  *tabBrique[0][9] = 1; 
 
 
  return tabBrique;
}
 
 
void afficheBrique(int*** tabBrique, SDL_Surface* ecran, SDL_Surface* brique) //Affiche les brique a partir d'un tableau
{
  int i,j;
  SDL_Rect positionBrique;
 
  int TAILLE_BRIQUE = 31;
 
  for (i=1;i<=10;i++) //Les colonnes 
  {
    for (j=1;j<=10;j++) //Les lignes
	 {
	   if (*tabBrique[0][j] == 1) //Si on a une brique
		{
		  positionBrique.x = j * TAILLE_BRIQUE;
		  positionBrique.y = 0;
		  SDL_BlitSurface(brique,NULL,ecran,&positionBrique);
		}
	 }
 
  }
}
 
 
 
 
int main(int argc, char* argv[])
{
  SDL_Surface* ecran;
  ecran = SDL_SetVideoMode(640,480,32,SDL_DOUBLEBUF | SDL_HWSURFACE);
  SDL_Event event;
  SDL_WM_SetCaption("Mine Breaker",NULL);
 
  SDL_ShowCursor(0);
 
  SDL_Surface* palet = SDL_LoadBMP("palet.bmp");
  SDL_Rect positionPalet;
  SDL_Surface* brique = SDL_LoadBMP("brique.bmp");
 
  int ***tabBrique;
  tabBrique = malloc(sizeof(int)*110); 
  tabBrique = loadBrique();
 
  //Boucle des évenements
 
  while (1)
  {
 
	 SDL_PollEvent(&event);
 
	 SDL_FillRect(ecran,NULL,SDL_MapRGB(ecran->format,0,0,0)); //Efface l'écran
	 afficheBrique(tabBrique,ecran,brique);
 
 
	 if (event.type == SDL_QUIT) 
	 {
	   break;
	 }
	 if (event.type == SDL_MOUSEMOTION)
	 {
	   positionPalet = updatePalet(ecran,palet,event);
	 }
 
	 SDL_Flip(ecran);
 
  }
 
  SDL_FreeSurface(ecran);
  SDL_Quit();
 
  return 0;
 
}

Bonne lecture et merci d'avance

**Kirilenko** · 30/12/2011, 14h47

Là, tu n'alloues que la première dimension. Forcément, dès que tu essayes de lire une case précise de ton tableau ça râle.

Envoyé par valgrind

==3011== Use of uninitialised value of size 4
==3011== at 0x804878C: loadBrique (main.c:28)
==3011== by 0x8048963: main (main.c:84)

Tu sais comment allouer dynamiquement un tableau à plusieurs dimensions ? Tu as déjà un exemple d'allocation dynamique de tableau à deux dimensions dans la FAQ, je te laisse en prendre connaissance.

Bonne journée.

**jeroman** · 30/12/2011, 21h12

Il y a aussi un soucis au niveau de boucles "for" : elles provoquent un débordement du tableau (1 à 10 inclus, au lieu de 0 à 9 inclus).

**YannPeniguel** · 31/12/2011, 02h20

Dans updatePalet, tu déclares une variable locale newPosition que tu retournes.

Une règle de base du C est que les variables locales sont désallouées à l'accolade fermante de leur position, ce qui signifie que tu retournes une variable potentiellement désallouée.

Toute ~~variable~~ structure que tu retournes doit être allouée avec malloc, et désallouée avec free lorsque tu n'en a plus besoin.

Comme Kirilenko l'a indiqué, tu n'alloue pas correctement ton tableau multi-dimensionnel.

Par contre, dans loadBrique, je vois un point positif, c'est que tu retournes le tableau alloué avec malloc. C'est comme ça que je te disais plus haut qu'on doit renvoyer des variables depuis une fonction.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

int TAILLE_BRIQUE = 31;

Les constantes sont à déclarer avec le mot clé const, c'est meilleur pour les performances et ça empêche de les altérer.

**EpiTouille** · 31/12/2011, 14h39

Ah oui, je n'avais pas vue l'erreur sur la boucle for.

Après j'ai regarder comment allouer des tableaux multi-dimensionnelles sur la fac
mais le problèmes c'est que les exemples sont pour

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

int ** tab[10];

ou

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

int * tab;

moi j'utilise des

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

int ***

mais après, je ne sais pas si c'est la bonne solution. J'ai mis ça par dépit parce que n'arrivais pas à renvoyé un

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

int[10][0];

Après quand vous parlez de variable désallouer dans la procédure updatePalet(), je ne comprend pas pourquoi car j'ai cette ligne là :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

SDL_Rect newPosition;

qui alloue statiquement un variable. Après, j'aurais très bien put la mettre dans le main et l'envoyé par paramètre mais ça fais toujours un paramètre en plus. De plus, tu dit que je doit l'allouer avec un malloc et la libéré avec free, mais cette variable n'est pas de type pointer. donc c'est comme si on faisait :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

int i = malloc(sizeof(i));

Après pour ce qui est de la constante, j'aurais dû mettre const. Mais dans mon cas, mieux vaut mettre une constante ou un define ? Car si je met une constante, je devrait la mettre où, car elle va surement servir pour plusieurs fonctions.

merci de vos réponses

**Kirilenko** · 31/12/2011, 15h16

Après j'ai regarder comment allouer des tableaux multi-dimensionnelles sur la fac [...]

Oui, c'est pour ça que je t'ai dit d'en « prendre connaissance », c'était pour te donner la méthode.
Dans ton cas précis, tu peux suivre le schéma suivant :

Allocation de la première dimension (cF exemple de la FAQ)
Allocation de la deuxième dimension (cF exemple de la FAQ)
Allocation de la troisième dimension (là, c'est à toi d'y réfléchir, je verrais bien deux belles boucles imbriquées qui permettent d'accéder à toutes les cases contenues dans la deuxième dimension).

Après pour ce qui est de la constante, j'aurais dû mettre const. Mais dans mon cas, mieux vaut mettre une constante ou un define ? Car si je met une constante, je devrait la mettre où, car elle va surement servir pour plusieurs fonctions.

S'il faut l'utiliser dans plusieurs fonctions, tu peux la déclarer globalement, mais je te conseillerai plutôt d'utiliser un #define dans ton cas. Après, il ne faut pas être allergique au préprocesseur.

**Kirilenko** · 31/12/2011, 15h43

Dans updatePalet, tu déclares une variable locale newPosition que tu retournes.

Une règle de base du C est que les variables locales sont désallouées à l'accolade fermante de leur position, ce qui signifie que tu retournes une variable potentiellement désallouée.

A moins que j'ai raté quelque chose, SDL_Rect est une structure, et dans son code titeee ne fait que retourner la valeur de sa structure. Comme avec toutes les variables que l'on retourne d'une fonction, quand on stocke le retour de sa fonction on a une copie qui se crée. Donc pas besoin de se soucier de la désallocation de la variable de sa fonction updatePalet().
Mes excuses si je suis hors sujet.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <stdio.h>
#include <stdlib.h>
#include <SDL/SDL.h>
 
SDL_Rect f(void) {
  SDL_Rect p = {5,6};
  fprintf(stdout,"{%d,%d} @%p\n",p.x,p.y,&p);
  return p;
}
 
int main(void) {
  SDL_Rect p = f();
  fprintf(stdout,"{%d,%d} @%p\n",p.x,p.y,&p);
  return EXIT_SUCCESS;
}

Envoyé par ./a.out

{5,6} @0xbfba4348
{5,6} @0xbfba4398

**Sve@r** · 31/12/2011, 15h50

Envoyé par titeeee

J'essaie de créer un petit casse brique en c, et je manipule des

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

int***

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
int*** loadBrique() //Charge les briques à partir d'un fichier
{
  int ***tabBrique;
 
  //On construit la tableau
  //Allocation dynamique
  tabBrique = malloc(sizeof(int)*110);
 
  *tabBrique[0][0] = 1;  //On chargera dans un fichier après
  *tabBrique[0][1] = 1;
  *tabBrique[0][2] = 1;
  *tabBrique[0][3] = 1;
  *tabBrique[0][4] = 1;
  *tabBrique[0][5] = 1;
  *tabBrique[0][6] = 1;
  *tabBrique[0][7] = 1;
  *tabBrique[0][8] = 1;
  *tabBrique[0][9] = 1; 
 
 
  return tabBrique;
}

Salut
Je ne pige pas trop pourquoi tu as besoin de 3 dimensions pour gérer un bête tableau de briques. Un tableau de X choses n'a besoin que d'une dimension. Pourquoi par exemple ne pas utiliser un tableau de structures s_briques avec chaque s_brique contenant sa position (x,y) dans le jeu ???

Envoyé par titeeee

Après quand vous parlez de variable désallouer dans la procédure updatePalet(), je ne comprend pas pourquoi car j'ai cette ligne là :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

SDL_Rect newPosition;

qui alloue statiquement un variable. Après, j'aurais très bien put la mettre dans le main et l'envoyé par paramètre mais ça fais toujours un paramètre en plus. De plus, tu dit que je doit l'allouer avec un malloc et la libéré avec free, mais cette variable n'est pas de type pointer.

Tu n'as pas le droit de renvoyer une variable de type non basique (variable qui n'est pas int ou char ou short ou ...). Car un return renvoie une copie de la valeur. Et si la variable est très grosse, la copie prend du temps (et ça c'est dans le meilleur des cas car dans le pire tu renvoies un truc qui a déjà été libéré).

Envoyé par titeeee

donc c'est comme si on faisait :

Code c :

Sélectionner tout - Visualiser dans une fenêtre à part

int i = malloc(sizeof(i));

Rien ne t'empêche de faire

Code c :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
int *i;
i = malloc(sizeof(*i));
 
SDL_Rect *newPosition;
newPosition=malloc(sizeof(*newPosition));

Là, tu renvoies un simple pointeur (donc un simple nombre en fait) et en plus t'es certain que son contenu n'est pas libéré (parce que ce sera à toi de le faire via free() quand tu n'en auras plus besoin)

Envoyé par titeeee

Après pour ce qui est de la constante, j'aurais dû mettre const. Mais dans mon cas, mieux vaut mettre une constante ou un define ? Car si je met une constante, je devrait la mettre où, car elle va surement servir pour plusieurs fonctions.

Les globales c'est le mal. Si tu as juste un simple nombre (comme TAILLE_BRIQUE) alors le define c'est ce qu'il y a de plus simple.
Maintenant si ton souci est que tu as trop de variables à transmettre, tu as une solution possible
1) tu crées une structure destinée à embarquer ton environnement de jeu. Cette structure aura par exemple la taille d'une brique, le nombre de briques, bref tout ce dont tu penses avoir besoin
2) tu envoies l'adresse de cette structure à tes autres fonctions. Tu n'envoies donc qu'un seul paramètre et toutes tes autres fonctions ont accès à tous les paramètres du jeu...

Envoyé par Kirilenko

A moins que j'ai raté quelque chose, SDL_Rect est une structure, et dans son code titeee ne fait que retourner la valeur de sa structure. Comme avec toutes les variables que l'on retourne d'une fonction, quand on stocke le retour de sa fonction on a une copie qui se crée. Donc pas besoin de se soucier de la désallocation de la variable de sa fonction updatePalet().

Tu as tout à fait raison. Mais imagine que SDL_Rect contienne 300Mo ? Tu voies un peu les ressources monopolisées pour la recopie ??? Et si la fonction est appelée dans une boucle ??? Et si SDL_Rect contient des adresses vers des variables locales (bon j'imagine mal comment on pourrait faire ça mais c'est une possibilité)...

**diogene** · 31/12/2011, 15h56

Tout dépend si la taille de tes tableaux est fixée au moment de la compilation ou déterminée au moment de l'exécution.

*** Dans le premier cas, pour un tableau NxM on aura une déclaration

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
#define N ...
#define M ...
int tab[N][M];

Pour passer un tel tableau à une fonction, il faut comme argument l'adresse du premier élément du tableau (comme pour tous les tableaux). Ici, on a un tableau dont les N éléments sont des tableaux de M int. Le type de l'argument doit donc être "adresse d'un tableau de M int" soit int (*)[M] (avec les parenthèses)
Par exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
void loadBrique(int (*tabBrique)[M])
{
   for(i=0; i<N;i++)
     for(j=0; j<M,j++)  
       tabBrique[i][j] = ...
   ...
}
void afficheBrique(int (*tabBrique)[M], SDL_Surface* ecran, SDL_Surface* brique)
{
 ....
  for (i=0;i<N;i++) //Les colonnes 
  {
    for (j=0;j<M;j++) //Les lignes
	 {
	   if (tabBrique[i][j] == 1) //Si on a une brique
 ....
}
int main(void)
{
  int tab[N][M];
  loadBrique(tab);
...
  afficheBrique(tab,ecran,brique);

*** Dans le deuxième cas, il faut passer par l'allocation dynamique. Il y a plusieurs possibilités. Voir la FAQ citée par Kirilenko.

**Kirilenko** · 31/12/2011, 16h47

Envoyé par Sve@r

Tu as tout à fait raison. Mais imagine que SDL_Rect contienne 300Mo ? Tu voies un peu les ressources monopolisées pour la recopie ??? Et si la fonction est appelée dans une boucle ??? Et si SDL_Rect contient des adresses vers des variables locales (bon j'imagine mal comment on pourrait faire ça mais c'est une possibilité)...

Tout à fait, c'est simplement le ton de la phrase suivante qui m'a surpris.

Toute variable que tu retournes doit être allouée avec malloc, et désallouée avec free lorsque tu n'en a plus besoin.

**YannPeniguel** · 31/12/2011, 19h25

Envoyé par Kirilenko

A moins que j'ai raté quelque chose, SDL_Rect est une structure, et dans son code titeee ne fait que retourner la valeur de sa structure. Comme avec toutes les variables que l'on retourne d'une fonction, quand on stocke le retour de sa fonction on a une copie qui se crée. Donc pas besoin de se soucier de la désallocation de la variable de sa fonction updatePalet().
Mes excuses si je suis hors sujet.

J'ai dû dire une sottise sur ce point. Effectivement si le retour des structures est par valeur, c'est ok sur le principe qu'on va récupérer les valeurs.

Mais je ne retourne pas de structures allouées statiquement, pour moi elles se manipulent toujours par pointeur, comme le souligne Sve@r. Il en est de même pour les types opaques d'ailleurs.

J'ai édité le message pour être plus clair.

**EpiTouille** · 01/01/2012, 13h16

Bonne année !

merci de toute vos réponses, je vais corriger mon code en conséquence. Je savais pas qu'il fallait envoyé le première élément du tableau pour le paramètre.
Est-ce que ça marche pour le return aussi ?? logiquement oui

Pour info :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
CWtypedef struct{
  Sint16 x, y;
  Uint16 w, h;
} SDL_Rect;

donc cette structure ne fait pas 300mo puisque elle est composé de 4 entiers sur 16bits. Je ne pense pas que le fait de recréer une variable à chaque appel puisse altérer les performances de mon petit jeux

merci encore

edit -
je viens de corriger mon code et ça marche

par contre y'a un ou 2 trucs que je ne comprends pas

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
int** loadBrique() //Charge les briques à partir d'un fichier
{
  int *tabBrique = malloc(sizeof(int) * 10 * 10); 
 
 
 
  tabBrique[10*0+0] = 1;  //On chargera dans un fichier après
  tabBrique[10*0+1] = 1;
  tabBrique[10*0+2] = 1;
  tabBrique[10*0+3] = 1;
  tabBrique[10*0+4] = 1;
  tabBrique[10*0+5] = 1;
  tabBrique[10*0+6] = 1;
  tabBrique[10*0+7] = 1;
  tabBrique[10*0+8] = 1;
  tabBrique[10*0+9] = 1;
 
  //Deuxieme ligne
  tabBrique[10*1+0] = 1;
  tabBrique[10*1+1] = 1;
  tabBrique[10*1+2] = 1;
  tabBrique[10*1+3] = 1;
  tabBrique[10*1+4] = 1;
  tabBrique[10*1+5] = 1;
  tabBrique[10*1+6] = 1;
  tabBrique[10*1+7] = 1;
  tabBrique[10*1+8] = 1;
  tabBrique[10*1+9] = 1;
 
 
 
  return tabBrique;
}

tabBrique ici est un pointeur, comment c'est possible de l'affecter comme je l'ai fais ? On aurait pas du mettre une '*' devant ?

2eme question, pourquoi on tabBrique est un int* et la valeurs de retour est un int** ? Comment ce passe la conversion entre les 2 ?

Merci

**jeroman** · 01/01/2012, 15h56

tabBrique ici est un pointeur, comment c'est possible de l'affecter comme je l'ai fais ? On aurait pas du mettre une '*' devant ?

Tu veux dire ce genre de chose :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

tabBrique[10*0+0] = 1;

?

En C,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

pointeur [ index ]

correspond à la même chose que

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

* (pointeur + index )

Par contre, il "faut" optimiser l'initialisation de ton tableau. Avec une boucle, ça tient en deux lignes seulement !

Par contre, avant de commencer à remplir le tableau, il faut absolument vérifier la valeur retour de malloc. Il y a crash potentiel.

Pour finir, ta fonction doit retourner int * et non int **.

**EpiTouille** · 01/01/2012, 16h37

ok merci !!!

La condition c'est

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
 
if (tabBrique != NULL)
{
  //C'est bon
 
}

ou

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
if (tabBrique == (sizeof(int) * 100))
{
  //C'est bon
}

?

**Kirilenko** · 01/01/2012, 16h44

tabBrique est un pointeur vers l'adresse de départ de la zone allouée. Tu peux également utiliser les pages de documentation.
A toi de déterminer une préférence entre les deux réponses que tu proposes.

**jeroman** · 01/01/2012, 16h48

malloc renvoit NULL en cas d'échec. Donc...

erreur avec les pointeurs (je sais pas d'où ça vient)

C

Discussions similaires

Partager

Partager