variables locales ou globales?

Version imprimable

Voir 40 message(s) de cette discussion en une page

20/10/2005, 16h01
molesqualeux

variables locales ou globales?
Bonjour ,
Imaginez un tableau de N cases avec dans chacune des cases trois possibilités , bleu , rouge ou blanc que j'appelerais par leur première lettre en anglais

b : blue
w : white
r : red

Par exemple : le tableau est

b b r w r b w w b ...

Je voudrais classer dans un ordre bleu blanc rouge (drapeau tricolore) .
Pour cela j'invente une fonction échanger .
Code:

1 2 3 4 5 6 void Echanger(int y,int j,char x) { x = DRAPEAU[y]; DRAPEAU[y] = DRAPEAU[j]; DRAPEAU[j] = x; }
Dans mon programme principal je rappelle cette fonction .
Je veux juste pour l'exemple echanger la première boule et la deuxieme.
Code:

1 2 3 4 5 6 7 8 9 10 main() { int w;int b;int r; char x; b=1; w=2; Echanger(w,b,x); }
Le problème c'est quand je réaffiche le tableau bah il n'a rien échanger... :-(
Pourquoi?
20/10/2005, 16h19
Strab

Deux remarques sur ton programme :
- ta fonction main échange les 2e et 3e éléments du tableau, et non les 1er et 2e, car l'indexation des tableaux commence à 0.
- le paramètre char x ne sert à rien dans la fonction échanger : il est écrasé à la première instruction. Il a le rôle d'une variable locale à Echanger, déclare le donc comme tel.

Pourrais-tu donner le code complet du programme, avec déclaration de DRAPEAU ?

De toute façon, je te conseille de passer le tableau en paramètre de Echanger. En procédant ainsi, tu pourras réutiliser ta fonction dans d'autres programmes.

Code:

1
2
3
4
5
6
 
void Echanger(char* array, int x, int y) {
    char x = array[y];
    array[y] = array[j];
    array[j] = x;
}

devrait peut etre mieux marcher...

20/10/2005, 20h16
afrikha
Citation:
Envoyé par bibi.skuk

Code:

1 2 3 4 5 6 void Echanger(char* array, int j, int y) { char x = array[y]; array[y] = array[j]; array[j] = x; }
devrait peut etre mieux marcher... :wink:
(j'ai remplacé x par j dans la declaration,juste une petite correction)
21/10/2005, 00h01
Invité

oups... pas fait gaffe... j'ai juste vu le y, et j'ai assimilé à des coordonnés...

Me revoilou . En fait ça marche toujours pas , mais je ne comprends pas aussi votre solution :

Citation:

void Echanger(char* array, int j, int y) {
char x = array[y];
array[y] = array[j];
array[j] = x;
}

que signifie char* ?
Et array ne définit rien ?

Il faut montrer qu'on utilise le tableau DRAPEAU .
Je vous mets un peu plus de code de mon programme
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 #include<stdio.h> #define N 10 char DRAPEAU[N]; int i; char Blanc(){ return DRAPEAU[i] == 'w'; } char Bleu(){ return DRAPEAU[i] == 'b'; } void Echanger(int j, int y) { char x; x = DRAPEAU[y]; DRAPEAU[y] = DRAPEAU[j]; DRAPEAU[j] = x; } main() { int w;int b;int r; char x; char DRAPEAU[] = {'b','r','r','w','w','b','r','w','b','w'}; //1° affichage du tableau for (i=0;i<10;i=i+1) { printf("%c",DRAPEAU[i]); printf(" - "); } printf("\n"); b=0; w=0; r=N; // 1 echange Echanger(0,1); //2° affichage du tableau for (i=0;i<10;i=i+1) { printf("%c",DRAPEAU[i]); printf(" - "); } }
Et là il ne change rien .

Si j'utilise votre méthode je dois mettre 3 arguments quand j'appelle Echanger?
Echanger(x,0,1) par exemple?

Merci de votre aide

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
 
#include<stdio.h> 
#define N 10 //a remplacer par const int SIZE = 10;
 
char DRAPEAU[N]; // tu declare ce tableau dans main()
int i;  //a eviter ! passe plutot cette variable en parametre de tes fonctions
 
//attention : tu declare Blanc et Bleu comme retournant des char...
// en realité, ces fonctions retournent des booleens (declare le type de
//retour en int ou en incluant bool.h, _Bool). 
char Blanc(){ //ajoute un parametre i
   return DRAPEAU[i] == 'w'; 
} 
 
 
char Bleu(){ //meme remarque que pour Blanc()
   return DRAPEAU[i] == 'b'; 
} 
 
void Echanger(int j, int y) { //passe ton tableau en parametre...
char x; 
     x = DRAPEAU[y]; 
     DRAPEAU[y] = DRAPEAU[j]; 
     DRAPEAU[j] = x; 
 } 
 
main() // attention : la signature de main est :
//int main()
//ou int main(int argc, char **argv)
// donc ici utilise "int main()".
{ 
int w;int b;int r; // inutiles, tu ne les utilise pas !
char x; tu n'utilise pas cette variable ; ne la declare donc pas...
char DRAPEAU[] = {'b','r','r','w','w','b','r','w','b','w'}; //oui
 
//1° affichage du tableau 
for (i=0;i<10;i=i+1) { //remarque de style : changer i=i+1 en ++i
   printf("%c",DRAPEAU[i]); 
   printf(" - "); 
   } 
 
printf("\n"); 
 
b=0; //idem : tu ne te sert pas de ces variables...
w=0; 
r=N; 
 
 
// 1 echange 
Echanger(0,1); 
 
//2° affichage du tableau 
for (i=0;i<10;i=i+1) { 
   printf("%c",DRAPEAU[i]); 
   printf(" - "); 
   } 
//return EXIT_SUCCESS; pour dire que c'est fini avec succes ;)
}

Voila. regarde les commentaires et change tout ca:)

05/11/2005, 18h19
David.Schris
Citation:

Envoyé par Patriarch24

Code:

#define N 10 //a remplacer par const int SIZE = 10;

Quel est l'intérêt ? Et c'est une double question : pourquoi un "const int" plutôt qu'un "#define" et pourquoi définir "N" alors qu'il ne sert pas ?
Citation:
Envoyé par Patriarch24

Code:

1 2 3 4 main() // attention : la signature de main est : //int main() //ou int main(int argc, char **argv) // donc ici utilise "int main()".
Je dirai plutôt

Code:

int main(void)

Citation:

Envoyé par Patriarch24

Code:

for (i=0;i<10;i=i+1) { //remarque de style : changer i=i+1 en ++i

Il y a peut-être plus important que le style...

Code:

for(i=0;i<(sizeof(DRAPEAU)/sizeof(char));i++) {

Citation:

Envoyé par Patriarch24

Code:

//return EXIT_SUCCESS; pour dire que c'est fini avec succes ;)

Mais pour ça il faut faire un

Code:

#include <stdlib.h>
07/11/2005, 00h54
David.Schris

Citation:

Envoyé par Patriarch24

Citation:

Quel est l'intérêt ? Et c'est une double question : pourquoi un "const int" plutôt qu'un "#define" et pourquoi définir "N" alors qu'il ne sert pas ?

En effet. Cependant cher ami, lit donc la norme C99 et dit moi s'il vaut mieux faire #define ou const int, on en reparlera.

Ca me ferait gagner du temps si tu me citais le passage concerné. Ca serait plus "productif" aussi : les autres pourraient en profiter. Si tu n'es pas en mesure de citer le passage correspondant, inutile de nous faire attendre : parles-nous en tout de suite. Ma question était : "quel est l'intérêt ?". Ma question n'était pas "où as-tu lu un truc pareil ?"

Citation:

Envoyé par Patriarch24

Citation:

Je dirai plutôt
int main(void)

Meme remarque. On ne met plus de void entre parenthèses...

Moi si. Et j'encourage à en mettre. Ca oblige celui qui écrit à être conscient qu'il est bien en train d'écrire une fonction qui ne prend aucun paramètre. Donc tu n'en mets peut-être plus mais tout le monde n'est pas obligé de faire comme toi, donc une phrase du type "C'est inutile d'en mettre parce que <insérer une raison ici>, donc je n'en mets plus, mais si tu préfères..." me conviendrait mieux.

Citation:

Envoyé par Patriarch24

Citation:

for(i=0;i<(sizeof(DRAPEAU)/sizeof(char));i++) {

Tu recalcules a chaque tour de boucle...

Ah!Ah!Ah!
Elle est bien bonne. C'est la norme qui dit ça aussi ?
Tu crois franchement qu'un compilateur oserait générer du code pour ce calcul ?
"sizeof(DRAPEAU)" est une constante.
"sizeof(char)" est une constante.
"sizeof(DRAPEAU)/sizeof(char)" est une expression dont la valeur est constante.
Et que fait un compilateur normal quand il rencontre une telle expression ? Il la remplace par sa valeur. Etonnant, non ? On n'arrête pas le progrès décidément...
Je reconnais que la blague était bonne :) .
07/11/2005, 08h20
Patriarch24

Je sais pas qui est le guignol qui m'a pris mon compte mais s'il recommence, il va passer un mauvais quart d'heure. (jvais changer de mot de passe tiens...)

Citation:

Ca me ferait gagner du temps si tu me citais le passage concerné. Ca serait plus "productif" aussi : les autres pourraient en profiter. Si tu n'es pas en mesure de citer le passage correspondant, inutile de nous faire attendre : parles-nous en tout de suite. Ma question était : "quel est l'intérêt ?". Ma question n'était pas "où as-tu lu un truc pareil ?"

C'est pas marqué dans la norme qu'il faut faire ca. D'ailleurs, il y est ecrit explicitement qu'on peut définir une constante avec #define... (me demande pas la page je la connais pas par coeur moi !)
Cependant, moi perso, j'évite les #define pour déclarer des constantes :)

Concernant le f(void), je vois pas en quoi c'est interdit d'en mettre, meme si pour moi ca ne veut rien dire !

Enfin concernant le sizeof/sizeof, tu as tout a fait raison, un compilateur digne de ce nom ne va pas s'amuser a calculer des trucs deja calculés (ca, seul l'homme sait le faire :lol: )

Bon j'espere que j'ai retabli mon honneur (bafoué il faut le dire, par un gentil plaisantin... qui n'a surement pas lu la norme !!!)

merci . J'ai pas pris en compte chéaque remarque mais ça marche .

Tri dans l'ordre d'un tableau bleu , blanc , rouge

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
#include<stdio.h>
 
 
#define N 10
char DRAPEAU[N];
 
 
int i;
 
 
char Blanc(){
	return DRAPEAU[i] == 'w';
}
 
 
char Bleu(){
	return DRAPEAU[i] == 'b';
}
 
void Echanger(int j, int y, char tableau[N]) { 
char x;
     x = tableau[y]; 
     tableau[y] = tableau[j]; 
     tableau[j] = x; 
 }
 
main()
{
int w;int b;int r;
char DRAPEAU[] = {'b','r','r','w','w','b','r','w','b','w'};
 
 
 
printf("\n");
 
b=0;
w=0;
r=N-1;
 
 
 
 
 
while(w<=r) {
 
 
for (i=0;i<10;i=i+1) {
	printf("%c",DRAPEAU[i]);
	printf(" - ");
	}
 
printf("\n");
 
 
		if(DRAPEAU[w] == 'w')
		{	printf("drapeau blanc\n");
		w=w+1;
		} else{
			if (DRAPEAU[w] == 'b') {printf("drapeau bleu\n");
			Echanger(b,w,DRAPEAU);
			b=b+1;
			w=w+1;
			} else{printf("drapeau rouge\n");
			Echanger(w,r,DRAPEAU);
			r=r-1;
		      	}
	       }
	    }
 
 
 
 
 
 
for (i=0;i<10;i=i+1) {
	printf("%c",DRAPEAU[i]);
	printf(" - ");
	}
 
}

En fait j'avais omis du code c'est pour ça que certaines variables n'étaient pas utilisées .

07/11/2005, 18h50
Emmanuel Delahaye

Citation:

Envoyé par Patriarch24

C'est pas marqué dans la norme qu'il faut faire ca. D'ailleurs, il y est ecrit explicitement qu'on peut définir une constante avec #define... (me demande pas la page je la connais pas par coeur moi !)
Cependant, moi perso, j'évite les #define pour déclarer des constantes :)

Certes, mais dans ce cas, l'alternative est enum, et non const. Tu confonds expression constante et objet à lecture seule.

Ceci dit, il y a des cas où on ne sait pas faire autrement que #define pour définir une expression constante.
07/11/2005, 19h25
Médinoc

Aussi, il faut reconnaitre que const a l'avantage sur enum d'être typé (pas forcément des int) ce qui peut avoir des avantages quand il est question de taille de variable etc.
07/11/2005, 19h38
Emmanuel Delahaye

Citation:

Envoyé par Médinoc

Aussi, il faut reconnaitre que const a l'avantage sur enum d'être typé (pas forcément des int) ce qui peut avoir des avantages quand il est question de taille de variable etc.

enum est typé automatiquement char ou int (voire unsigned int) selon la valeur. De toutes façons, les appels de fonctions font la promotion en int ou unsigned int.
Mais contrairement à enum, const ne fabrique pas d'expression constante.
07/11/2005, 23h56
David.Schris
Bonsoir,

Citation:

Envoyé par Patriarch24

Je sais pas qui est le guignol qui m'a pris mon compte mais s'il recommence, il va passer un mauvais quart d'heure. (jvais changer de mot de passe tiens...)

???

Citation:

Envoyé par Patriarch24

Citation:

Ca me ferait gagner du temps si tu me citais le passage concerné. Ca serait plus "productif" aussi : les autres pourraient en profiter. Si tu n'es pas en mesure de citer le passage correspondant, inutile de nous faire attendre : parles-nous en tout de suite. Ma question était : "quel est l'intérêt ?". Ma question n'était pas "où as-tu lu un truc pareil ?"

C'est pas marqué dans la norme qu'il faut faire ca. D'ailleurs, il y est ecrit explicitement qu'on peut définir une constante avec #define... (me demande pas la page je la connais pas par coeur moi !)
Cependant, moi perso, j'évite les #define pour déclarer des constantes :)

Pourquoi ? Il y a bien une raison, non ? Cela serait étonnant que tu fasses cela sans savoir pourquoi, tu ne trouves pas ? Alors puisque tu sais pourquoi tu évites d'utiliser des #define, dis-nous pourquoi ! Le but du forum est aussi de partager des connaissances. Apprends-nous ! Ma question est toujours "quel est l'intérêt ?".
En attendant que tu argumentes, je vais te donner mes arguments en faveur du #define.
Imagine un programme ou tu as, parmi d'autres choses (attention, ce qui suit est simplifié) :
Code:

1 2 3 4 5 6 #define CHAR_PAR_DEFAUT 'A' [...] register char c; [...] c=CHAR_PAR_DEFAUT; [...]
Le pré-processeur va transformer ça en (là aussi, je simplifie) :
Code:

1 2 3 4 5 [...] register char c; [...] c='A'; [...]
Ensuite, afin qu'un fichier objet soit produit, du code en assembleur va être produit (là encore, je simplifie et j'utilise en plus la notation "intel") :
Code:

1 2 3 4 5 [...] .CODE [...] mov al,65 [...]
On voit que la valeur de 'A' a été directement utilisée dans le code.
Maintenant, imagine un programme où tu as (idem pour les simplifications et je ne le mentionnerai plus) :
Code:

1 2 3 4 5 6 const char charParDefaut='A'; [...] register char c; [...] c=charParDefaut; [...]
Le pré-processeur, ne va, dans cet exemple, rien faire puisqu'il n'y a pas de #define. Donc, on passe à l'étape suivante :
Code:

1 2 3 4 5 6 7 8 9 10 [...] .DATA [...] charParDefaut db 'A' [...] .CODE [...] mov esi, offset charParDefaut mov al,byte ptr [esi] [...]
Tu vois la différence ?
Dans le premier cas, il n'y a pas de zone de mémoire réservée avec une valeur initialisée et la valeur du caractère est directement utilisée dans le code.
Dans le second, une zone de mémoire initialisée est utilisée ET on récupère l'adresse de cette zone ET on va lire à cette adresse.
Quel est le plus efficace ?
NEANMOINS, si le compilateur est suffisamment "intelligent" ET qu'à aucun moment l'adresse de "charParDefaut" n'est utilisée dans le programme (i.e. : aucun "&charParDefaut"), alors il simplifiera et produira du code identique au cas "#define".
C'est là qu'intervient l'avantage d'un "const" par rapport à un "#define" : tu peux utiliser l'adresse de la constante.
Tu remarqueras que c'est un besoin relativement rare que d'utiliser l'adresse d'une constante puisqu'on utilise plutôt une adresse quand les données vers lesquelles elle pointe doivent être modifiées (ce qui est en théorie [1] impossible avec une constante).
C'est avec joie que j'entendrai tes arguments car c'est avec joie que j'apprends, quitte à me remettre en question.

Citation:

Envoyé par Patriarch24

Enfin concernant le sizeof/sizeof, tu as tout a fait raison, un compilateur digne de ce nom ne va pas s'amuser a calculer des trucs deja calculés (ca, seul l'homme sait le faire :lol: )

Ben là, tu m'as fait gagner du temps. J'étais sur le point de compiler deux programmes (un avec calcul(s) avec "sizeof", l'autre sans) et de les désassembler pour poster ce que ça donne... Je laisserai ça comme exercice aux curieux (et je ne changerai pas d'avis).

Citation:

Envoyé par Patriarch24

Bon j'espere que j'ai retabli mon honneur (bafoué il faut le dire, par un gentil plaisantin... qui n'a surement pas lu la norme !!!)

Je ne suis pas certain que ton honneur ait été bafoué : tout le monde peut se tromper. Si tant est qu'il l'ait été, le fait que tu reconnaisses ton tort concernant le "sizeof/sizeof" te rend, à mes yeux en tous cas, tout à fait honorable.
Pour ce qui est de l'emploi du terme "plaisantin", j'avoue ne pas comprendre : j'écris avec tout le sérieux du monde.
Enfin, si tant est que je puisse te donner un conseil : utiliser "sûrement" quand, justement, on en est pas sûr me paraît "dangereux". J'appelle cela "prendre une hypothèse pour un fait".

Cordialement (car nous ne sommes pas des sauvages),
DS.

[1] : "en théorie" car dans la pratique c'est parfois possible. Un programme écrit en C sous MSDOS en mode réel (avec un compilateur de l'époque tant qu'à faire) peut modifier la valeur d'un "const" (via un pointeur) car il n'y a pas de notion de protection de page en mode réel (par opposition au mode protégé utilisé sous Win32).
09/11/2005, 09h41
Patriarch24

Les avantages principaux d'utiliser const sont :

-- la valeur est typée
-- on peut définir des constantes locales (à portée réduite)
exemple :
struct tab{
const int size = 256;
int toto[size];
};
Evidemment, l'exemple est bidon, mais tu vois ce que je veux dire...

Citation:

NEANMOINS, si le compilateur est suffisamment "intelligent"

Comme tu le dis, le code est le meme. Optimisation = 0.

Citation:

register char c;

register ? Cela fait bien longtemps que les processeurs snt suffisamment rapides pour n'avoir pas à utiliser ce mot clé.

Citation:

Dans le second (cas), une zone de mémoire initialisée est utilisée ET on récupère l'adresse de cette zone ET on va lire à cette adresse.

Je te le rappelle qu'une constante a une adresse définie à la compilation, et n'est pas stockée sur la pile, donc le compilateur peut directement connaitre la valeur contenue dans la case mémoire associée. Seule perte : l'instruction correspondant au chargement de la valeur dans un registre !

Citation:

car nous ne sommes pas des sauvages

Certes.

Bien cordialement ! :P

Citation:

Envoyé par Patriarch24

Les avantages principaux d'utiliser const sont :

-- la valeur est typée
-- on peut définir des constantes locales (à portée réduite)
exemple :
struct tab{
const int size = 256;
int toto[size];
};
Evidemment, l'exemple est bidon, mais tu vois ce que je veux dire...

Il est plus que bidon. Il est faux et ne compile pas.
Code:

1 2 3 4 5 6 7 8 9 10 int main (void) { struct tab { const int size = 256; int toto[size]; }; return 0; }
Code:

1 2 3 4 5 6 7 8 9 10 11 ../main.c: In function `main_': ../main.c:5: warning: no semicolon at end of struct or union ../main.c:5: error: syntax error before '=' token ../main.c:6: error: `size' undeclared (first use in this function) ../main.c:6: error: (Each undeclared identifier is reported only once ../main.c:6: error: for each function it appears in.) ../main.c:6: warning: unused variable `toto' ../main.c: At top level: ../main.c:8: error: syntax error before "return" Exécution terminée
Citation:

Citation:

Dans le second (cas), une zone de mémoire initialisée est utilisée ET on récupère l'adresse de cette zone ET on va lire à cette adresse.

Je te le rappelle qu'une constante a une adresse définie à la compilation,

Ben non. Une constante n'a pas d'adresse. Tu confonds avec une variable qualifiée const qui est une donnée à lecture seule.

09/11/2005, 19h46
gl

Citation:

Envoyé par Emmanuel Delahaye

Citation:

Envoyé par Patriarch24

Les avantages principaux d'utiliser const sont :

-- la valeur est typée
-- on peut définir des constantes locales (à portée réduite)
exemple :
struct tab{
const int size = 256;
int toto[size];
};
Evidemment, l'exemple est bidon, mais tu vois ce que je veux dire...

Il est plus que bidon. Il est faux et ne compile pas.

Sauf erreur de ma part, il doit etre correct avec les compilateurs implementant les VLA.
09/11/2005, 20h00
Emmanuel Delahaye

Citation:

Envoyé par gl

Citation:

Envoyé par Emmanuel Delahaye

Citation:

Envoyé par Patriarch24

Les avantages principaux d'utiliser const sont :

-- la valeur est typée
-- on peut définir des constantes locales (à portée réduite)
exemple :
struct tab{
const int size = 256;
int toto[size];
};
Evidemment, l'exemple est bidon, mais tu vois ce que je veux dire...

Il est plus que bidon. Il est faux et ne compile pas.

Sauf erreur de ma part, il doit etre correct avec les compilateurs implementant les VLA.

On ne peut pas définir une structure en mettant une valeur dans un de ses éléments de cette façon.

Quand aux VLA, size n'étant pas défini, ça m'étonnerais que ça fonctionne... Les VLA, c'est pas fait pour ça.
09/11/2005, 20h07
gl

Citation:

Envoyé par Emmanuel Delahaye

Citation:

Envoyé par gl

Citation:

Envoyé par Emmanuel Delahaye

Citation:

Envoyé par Patriarch24

Les avantages principaux d'utiliser const sont :

-- la valeur est typée
-- on peut définir des constantes locales (à portée réduite)
exemple :
struct tab{
const int size = 256;
int toto[size];
};
Evidemment, l'exemple est bidon, mais tu vois ce que je veux dire...

Il est plus que bidon. Il est faux et ne compile pas.

Sauf erreur de ma part, il doit etre correct avec les compilateurs implementant les VLA.

On ne peut pas définir une structure en mettant une valeur dans un de ses éléments de cette façon.

Oui effectivement, il faut vraiment que je me repose moi.

Voir 40 message(s) de cette discussion en une page