essai de code (bugger)

Version imprimable

Bonjour,
j'ai écris un morceau de code "idiot":mrgreen: pour comprendre comment alloue des (structures) listes chaines et avec un accès a c'est dernière mais ca bug dans certaine condition des que j'accède a une 4 unité ou + on se retrouve avec un accès violation donc soit j'ai mal alloue la mémoire écrasement de pointeur dans les liste soit c'est l'accès que j'ai mal écris:cry:.
voila le code (il n'y a pas d'erreur a la compilation seulement a l'exécution)

structure2.c

Code:

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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
 
#include<stdio.h>
#include<stdlib.h>
#include<stddef.h>
#include"struct1.h"
 
UNIT* (*select)(void);
 
void cree_unit(void){
 
 
	int instance_unit=0;
 
	printf("combien d'unit ? \n");
	scanf("%i",&nb_unit);
 
	if (nb_unit>=1){
		Tete=NULL;
		Nouveau=(UNIT*)malloc(sizeof(UNIT));
		if (Nouveau==NULL){
			printf("allocation malloc ln25");
			exit(EXIT_FAILURE);
		}
		Nouveau->pSuivant = Tete;
		Tete = Nouveau;
 
		if (Tete != NULL) {
			pCourant = Tete;
			while (pCourant->pSuivant != NULL) pCourant = pCourant->pSuivant;
 
			if (nb_unit>=2){
				for(instance_unit;instance_unit<nb_unit;instance_unit++){
					Nouveau = (UNIT*)malloc(sizeof(UNIT));
					if (Nouveau==NULL){
						printf("allocation malloc ln39");
						exit(EXIT_FAILURE);
					}
					pCourant->pSuivant = Nouveau;
					Nouveau->pSuivant = NULL;
 
				}
 
			}
		}
	}
	if(nb_unit==0){
		printf("vous n'avez cree aucune unité \n");
		return;
	}
}
UNIT*(selection_unit)(void){
	int select_unit=0;
	int tete_unit=2;
 
 
	printf("selectionner une unit ");
	scanf("%i",&select_unit);
	if (select_unit>nb_unit){
		printf ("erreur selection unit > au nb unit\n");
		exit(EXIT_FAILURE);
	}
 
	if (select_unit==0){ 
		base_st=Tete;
		printf("unit %i \n",select_unit);
		return base_st;
	}
	if (select_unit==1){ 
		base_st=Tete;
		base_st=base_st->pSuivant;
		printf("unit %i \n",select_unit);
		return base_st;
	}
	else {
		base_st=Tete;
		for(tete_unit;tete_unit<select_unit;tete_unit++){
			base_st=base_st->pSuivant;
		}
		printf("unit %i \n",select_unit);
		return base_st;
	}
}
void emplacement_unit(UNIT* select){
 
 
	printf("\n indiquer position x ");
	scanf("%i",&(select->x));
 
	printf("\n indiquer position y ");
	scanf("%i",&(select->y));
 
	printf("\n indiquer angle ");
	scanf("%i",&(select->angle));
 
	return;
	}
 
void detruire_allunit(){
	int instance_unit=2;
 
 
 
	if (nb_unit==1){
 
 
		free(Tete);
		return;
		}
 
 
 
 
	if (nb_unit>=2){
		Destruct=Tete;
		Destruct=Tete->pSuivant;
		free(Tete);
		for(instance_unit;instance_unit<nb_unit;instance_unit++){
			Destruct2=Destruct->pSuivant;
			free(Destruct);
 
 
		}
 
 
	}
 
 
 
}
 
 
 
 
void main(){
 
	printf("hello ");
	cree_unit();
	if (nb_unit>=1){
		emplacement_unit(selection_unit());
	}
	detruire_allunit();
	exit(EXIT_SUCCESS);
 
 
}

struct1.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
typedef struct unit UNIT;
struct unit {
		int x;
		int y;
		int angle;
		UNIT *pSuivant;	
	};
	UNIT * pCourant;
	UNIT *Nouveau;
	UNIT *Destruct;
	UNIT *Destruct2;
	UNIT *Tete;
	UNIT *base_st=NULL;
	int nb_unit=0;

voila merci d'avance pour vos reponse.(compiler avec visual 2010 c++ sur winxp )

08/01/2011, 18h20
diogene

Avec cette quantité de variables globales, le programme est difficile à suivre. Elles n'ont aucune raison d'être et tu devrais commencer par les supprimer pour les remplacer par des variables locales et par la transmission de paramètres aux fonctions.

A noter, qu'il ne devrait pas y avoir de définition de variables dans un .h
08/01/2011, 18h30
Fifou625

c'est un code idiot mais par curiosité j'aurai voulu savoir d'où vient le problème:mouarf:

c'est vrai que c'est une horreur :lol:
merci pour le conseil;)
09/01/2011, 00h45
LittleWhite

Bonjour,

Pour voir les causes des crash, il faut debugguer le code. Avec VS c'est plutot facile, car le debuggueur s'enclenche directement et va montrer le bug du crash.
Par la suite on pourra ajouter des point d'arrêts (breakpoint) et regarder le contenu des variables pour suivre ce que fait réellement le programme.

Finalement, une écriture simple et structuré (avec des variables locales) permette une meilleure compréhension du code / donc meilleur débugguage / et d'éviter des erreurs.

code remanié

les variables globales ne sont pas en cause :lol:
une partie du code je l'ai repris d'un exemple et je l'ai mal compris il ne corespondait pas a la logique de mon code ....:cry:
donc moralite sois vous comprenez le code que vous copier coller meme en le modifiant ou vous ecriver vous meme :mouarf:
il y a meme pas besoin de debugger le bug etait a vu d'oeil :mouarf:
donc ça a l'air d'être resolu.;)
merci pour les conseils quand meme.;)

le code reste "idiot" il ya pas tout les verifications pour generer des erreurs au cas ou et le code est a remanier histoire d'être plus propre.

struct1.h

Code:

1
2
3
4
5
6
7
typedef struct unit UNIT,*POINTEUR;
typedef struct unit {
		int x;
		int y;
		int angle;
		UNIT *pSuivant;	
	};

structure2.c

Code:

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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
#include<stdio.h>
#include<stdlib.h>
#include<stddef.h>
#include"struct1.h"
 
POINTEUR (*select)(void);
int nb_unit=0;
UNIT *Tete=NULL;
void cree_unit(void){
 
	UNIT * pCourant=NULL;
	UNIT *Nouveau=NULL;
 
	int instance_unit=1;
 
	printf("combien d'unit ? \n");
	scanf("%i",&nb_unit);
 
	if (nb_unit>=1){
		Nouveau=(UNIT*)malloc(sizeof(UNIT));
		if (Nouveau==NULL){
			printf("allocation malloc ");
			exit(EXIT_FAILURE);
		}
		Nouveau->x=0;
		Nouveau->y=0;
		Nouveau->angle=0;
 
		//Nouveau->pSuivant = Tete;
		Tete = Nouveau;
		Tete->pSuivant=NULL;
		if (Tete != NULL) {
			pCourant = Tete;
			//while (pCourant->pSuivant != NULL) pCourant = pCourant->pSuivant;
 
			if (nb_unit>=2){
 
				for(instance_unit;instance_unit<nb_unit;instance_unit++){
					Nouveau = (UNIT*)malloc(sizeof(UNIT));
 
					if (Nouveau==NULL){
						printf("allocation malloc ");
						exit(EXIT_FAILURE);
					}
					Nouveau->x=0;
					Nouveau->y=0;
					Nouveau->angle=0;
					pCourant->pSuivant = Nouveau;
					Nouveau->pSuivant = NULL;
					pCourant=Nouveau;
 
				}
 
			}
		}
	}
	if(nb_unit==0){
		printf("vous n'avez cree aucune unité \n");
		return ;
	}
}
POINTEUR selection_unit(void){
	int select_unit=0;
	int tete_unit=1;
 
	UNIT *pCourant=NULL;
 
	printf("selectionner une unit ");
	scanf("%i",&select_unit);
	if (select_unit>nb_unit){
		printf ("erreur selection unit > au nb unit\n");
		exit(EXIT_FAILURE);
	}
 
	if (select_unit==0){ 
		pCourant=Tete;
		printf("unit %i \n",select_unit);
		return pCourant;
	}
	if (select_unit==1){ 
		pCourant=Tete;
		pCourant=pCourant->pSuivant;
		printf("unit %i \n",select_unit);
		return pCourant;
	}
	else {
		pCourant=Tete;
		for(tete_unit;tete_unit<select_unit;tete_unit++){
			pCourant=pCourant->pSuivant;
		}
		printf("unit %i \n",select_unit);
		return pCourant;
	}
}
void emplacement_unit(POINTEUR select){
 
 
	printf("\n indiquer position x ");
	scanf("%i",&select->x);
 
	printf("\n indiquer position y ");
	scanf("%i",&select->y);
 
	printf("\n indiquer angle ");
	scanf("%i",&select->angle);
 
	return;
	}
 
void detruire_allunit(){
	int instance_unit=2;
 
	UNIT *pCourant=NULL;
	UNIT *Nouveau=NULL;
 
	if (nb_unit==1){
 
 
		free(Tete);
		return;
		}
 
 
 
 
	if (nb_unit>=2){
		Nouveau=Tete;
		Nouveau=Tete->pSuivant;
		free(Tete);
		for(instance_unit;instance_unit<nb_unit;instance_unit++){
			pCourant=Nouveau->pSuivant;
			free(Nouveau);
 
 
		}
 
 
	}
 
 
 
}
 
void montrer_unit(POINTEUR select){
	printf("x vaut %i \n",select->x);
	printf("y vaut %i \n",select->y);
	printf("angle vaut %i \n",select->angle);
}
 
 
void main(){
 
	printf("hello ");
 
	cree_unit();
	if (nb_unit>=1){
		emplacement_unit(selection_unit());
	}
	montrer_unit(selection_unit());
	detruire_allunit();
	exit(EXIT_SUCCESS);
 
 
}

09/01/2011, 19h18
diogene

Citation:

les variables globales ne sont pas en cause

Pour mon compte, je refuse de même essayer de saisir le fonctionnement de programmes possédant un paquet de globales (injustifiées).
Peut être que celui qui écrit le programme arrive à le maîtriser au moment où il le code (ce n'est pas sûr), mais plus tard, si il a besoin d'y revenir, ce sera une autre affaire. Alors pour quelqu'un d'autre....
C'est d'ailleurs le plus souvent une question de paresse à traiter les arguments des fonctions (alors, pourquoi serait-ce à moi de faire son travail ?) ou le fait d'un débutant qui est en train de prendre de très néfastes habitudes (ce qu'il vaut mieux combattre au plus tôt).

exact:mouarf:

mais l"erreur vient du fait que j'ai copié une portion de code, j'ai mal lue son fonctionnement donc peu importe comment j'aurai utilisé les variable locales etc... code propre -> il faut lire le code venant d'autrui et comprendre ce qu'il fait sinon ca marchera jamais.(ou faire soit meme):mouarf: Par contre pour autrui oui c'est plus compréhensible si bien écrit.
sinon c'est un exemple "idiot" ,je vais essaye de réécrire d'une façon propre .

code remanié mais degeulasse :lol:

struct1.h

Code:

1
2
3
4
5
6
7
typedef struct unit UNIT,*POINTEUR;
typedef struct unit {
		int x;
		int y;
		int angle;
		UNIT *pSuivant;	
	};

structure2.c

Code:

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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
#include<stdio.h>
#include<stdlib.h>
#include<stddef.h>
#include"struct1.h"
 
POINTEUR (*select)(void);
int nb_unit=0;
UNIT *Tete=NULL;
void cree_unit(void){
 
	UNIT * pCourant=NULL;
	UNIT *Nouveau=NULL;
 
	int instance_unit=1;
 
	printf("combien d'unit ? \n");
	scanf("%i",&nb_unit);
 
	if (nb_unit>=1){
		Nouveau=(UNIT*)malloc(sizeof(UNIT));
		if (Nouveau==NULL){
			printf("allocation malloc ");
			exit(EXIT_FAILURE);
		}
		Nouveau->x=0;
		Nouveau->y=0;
		Nouveau->angle=0;
 
 
		Tete = Nouveau;
		Tete->pSuivant=NULL;
		if (Tete != NULL) {
			pCourant = Tete;
 
 
			if (nb_unit>=2){
 
				for(instance_unit;instance_unit<nb_unit;instance_unit++){
					Nouveau = (UNIT*)malloc(sizeof(UNIT));
 
					if (Nouveau==NULL){
						printf("allocation malloc ");
						exit(EXIT_FAILURE);
					}
					Nouveau->x=0;
					Nouveau->y=0;
					Nouveau->angle=0;
					pCourant->pSuivant = Nouveau;
					Nouveau->pSuivant = NULL;
					pCourant=Nouveau;
 
				}
 
			}
		}
	}
	if(nb_unit==0){
		printf("vous n'avez cree aucune unité \n");
		return ;
	}
}
POINTEUR selection_unit(void){
	int select_unit=0;
	int tete_unit=1;
 
	UNIT *pCourant=NULL;
 
	printf("selectionner une unit de 1ou+ ");
	scanf("%i",&select_unit);
	if (select_unit>nb_unit){
		printf ("erreur selection unit > au nb unit\n");
		exit(EXIT_FAILURE);
	}
	if (select_unit==0) {
		printf("erreur de selection");
		exit(EXIT_FAILURE);
	}
	if (select_unit==1){ 
		pCourant=Tete;
		printf("unit %i \n",select_unit);
		return pCourant;
	}
	if (select_unit==2){ 
		pCourant=Tete;
		pCourant=pCourant->pSuivant;
		printf("unit %i \n",select_unit);
		return pCourant;
	}
	else {
		pCourant=Tete;
		for(tete_unit;tete_unit<select_unit;tete_unit++){
			pCourant=pCourant->pSuivant;
		}
		printf("unit %i \n",select_unit);
		return pCourant;
	}
}
void emplacement_unit(POINTEUR select){
 
 
	printf("\n indiquer position x ");
	scanf("%i",&select->x);
 
	printf("\n indiquer position y ");
	scanf("%i",&select->y);
 
	printf("\n indiquer angle ");
	scanf("%i",&select->angle);
 
	return;
	}
 
void detruire_allunit(){
	int instance_unit=0;
 
	UNIT *pCourant=NULL;
	UNIT *Destructor=NULL;
 
	Destructor=Tete;	
	while(instance_unit<nb_unit){
		pCourant=Destructor->pSuivant;
		free(Destructor);
		Destructor=pCourant;
		instance_unit++;
	}
	return;													
}
 
void montrer_unit(POINTEUR select){
	printf("x vaut %i \n",select->x);
	printf("y vaut %i \n",select->y);
	printf("angle vaut %i \n",select->angle);
}
 
void main(){
 
	printf("hello ");
 
	cree_unit();
	if (nb_unit>=1){
		emplacement_unit(selection_unit());
		montrer_unit(selection_unit());
		detruire_allunit();
	}
 
	exit(EXIT_SUCCESS);
}