Discussion :

[molesqualeux]

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 :

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

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 :

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

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?

[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.

[Invité]

Code :

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

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...

[afrikha]

Code :

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

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...
(j'ai remplacé x par j dans la declaration,juste une petite correction)

[Invité]

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

[molesqualeux]

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

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 :

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
#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

[Patriarch24]

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
 
#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

[David.Schris]

Code :

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

#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 ?

Code :

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

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 :

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

int main(void)

Code :

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

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 :

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

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

Code :

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

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

Mais pour ça il faut faire un

Code :

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

#include <stdlib.h>

[David.Schris]

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 ?"

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.

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 .

[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...)

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 )

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 !!!)

[molesqualeux]

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


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

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
#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 .

[Emmanuel Delahaye]

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.

[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.

[Emmanuel Delahaye]

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.

[David.Schris]

Bonsoir,

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...)

???

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 :

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

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 :

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

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 :

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

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 :

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

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 :

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

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.

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 )

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).

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).

[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...

NEANMOINS, si le compilateur est suffisamment "intelligent"

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

register char c;

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

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 !

car nous ne sommes pas des sauvages

Certes.

Bien cordialement !

[Emmanuel Delahaye]

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 :

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

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 :

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

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

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.

[gl]

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.

[Emmanuel Delahaye]

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.

[gl]

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.