Problème avec char motSecret[] = ""; Dés lors Qu'il exède les 8 char
25 réponses
clapannac
Bonjour, Voila je commence a coder sous C et j'ai une fonction qui patine sans que j'en trouve l'erreur...
Alors j'espère que vous pourrez me faire par de vos lumière.
Cordialement
Voici le code ...
###################### les fichiers source ###############
Main.c #
########
printf("Longueur du mot secre : ");
Etoile_Secr(motSecret);
printf("Propose une lettre : ");
lettreTap = lireCaractere();
printf("Etat du mot secre : ");
printf("%s",Result_Trouve_Cache_Save(motSecret,lettreTap));
return 0;
}
###########
Fonction.c #
###########
char lireCaractere()
{
char caractere = 0;
caractere = getchar(); // On lit le premier caractère
caractere = toupper(caractere); // On met la lettre en majuscule si elle ne l'est pas déjà
// On lit les autres caractères mémorisés un à un jusqu'à l'\n (pour les effacer)
while (getchar() != '\n') ; // il y a un ";" car c'est une boucle minimaliste "Technique de programmeur"
return caractere; // On retourne le premier caractère qu'on a lu
}
void Etoile_Secr(char* Tab)
{
int i = 0;
for(i=0;i<Tab[i];i++)
{
printf("*");
}
printf("\n");
}
char* Result_Trouve_Cache_Save(char* Tab,char lettre)
{
int i = 0;
char* copieTab = 0;
int longueurChaine = 0;
longueurChaine = strlen(Tab);
copieTab = malloc(longueurChaine);
if (copieTab == 0)
{
exit(0);
}
for (i = 0 ; i < Tab[i] ; i++)
{
if (lettre == Tab[i])
{
copieTab[i] = lettre;
printf("%s\n",copieTab); // J'ai testé pour voir et je comprend pas
}
else
{
copieTab[i] = '*';
printf("%s\n",copieTab); // J'ai testé pour voir et je comprend pas
}
}
// free(copieTab)
return copieTab; // Est-ce que le return suffirait ?
}
pas dit que ce soit la seule erreur, mais celle-là saute aux yeux.
Olivier Miakinen
Bonjour,
Le 06/01/2012 10:15, clapannac a écrit :
Voila je commence a coder sous C et j'ai une fonction qui patine sans que j'en trouve l'erreur...
J'ai l'impression qu'avant toute chose il faudrait que tu comprennes bien la structure d'une chaîne de caractères en C, avec le 0 final qui en marque la fin (et qui ajoute 1 à la longueur nécessaire pour stocker une chaîne d'une longueur donnée).
C'est quoi ce « i < Tab[i] » ? Tu voulais peut-être écrire i < strlen(Tab) ?
char* Result_Trouve_Cache_Save(char* Tab,char lettre) { int i = 0; char* copieTab = 0; int longueurChaine = 0; longueurChaine = strlen(Tab);
copieTab = malloc(longueurChaine);
Il te manque la place pour l'octet nul de fin de chaîne (cf. les liens donnés plus haut) :
copieTab = malloc(longueurChaine + 1);
Bien sûr, il ne faudra pas oublier d'ajouter cet octet nul à la fin de la chaîne copiée.
[...]
for (i = 0 ; i < Tab[i] ; i++)
Encore ce « i < Tab[i] » qui n'a aucune signification et qui fera n'importe quoi.
Bon, je ne lis pas la suite, tu as déjà du grain à moudre.
Cordialement, -- Olivier Miakinen
Bonjour,
Le 06/01/2012 10:15, clapannac a écrit :
Voila je commence a coder sous C et j'ai une fonction qui patine sans
que j'en trouve l'erreur...
J'ai l'impression qu'avant toute chose il faudrait que tu comprennes
bien la structure d'une chaîne de caractères en C, avec le 0 final
qui en marque la fin (et qui ajoute 1 à la longueur nécessaire pour
stocker une chaîne d'une longueur donnée).
Donc :
http://www.google.fr/#sclient=psy-ab&q=cha%C3%AEnes+de+caract%C3%A8res+en+C
Le premier résultat me semble correct :
http://nicolasj.developpez.com/articles/libc/string/
Voici le code ...
[...]
void Etoile_Secr(char* Tab)
{
int i = 0;
for(i=0;i<Tab[i];i++)
{
printf("*");
}
printf("n");
}
C'est quoi ce « i < Tab[i] » ? Tu voulais peut-être écrire
i < strlen(Tab) ?
char* Result_Trouve_Cache_Save(char* Tab,char lettre)
{
int i = 0;
char* copieTab = 0;
int longueurChaine = 0;
longueurChaine = strlen(Tab);
copieTab = malloc(longueurChaine);
Il te manque la place pour l'octet nul de fin de chaîne (cf. les
liens donnés plus haut) :
copieTab = malloc(longueurChaine + 1);
Bien sûr, il ne faudra pas oublier d'ajouter cet octet nul à la fin
de la chaîne copiée.
[...]
for (i = 0 ; i < Tab[i] ; i++)
Encore ce « i < Tab[i] » qui n'a aucune signification et qui fera
n'importe quoi.
Bon, je ne lis pas la suite, tu as déjà du grain à moudre.
Voila je commence a coder sous C et j'ai une fonction qui patine sans que j'en trouve l'erreur...
J'ai l'impression qu'avant toute chose il faudrait que tu comprennes bien la structure d'une chaîne de caractères en C, avec le 0 final qui en marque la fin (et qui ajoute 1 à la longueur nécessaire pour stocker une chaîne d'une longueur donnée).
C'est quoi ce « i < Tab[i] » ? Tu voulais peut-être écrire i < strlen(Tab) ?
... et j'ai oublié de préciser qu'il vaut mieux tester carrément « Tab[i] != 0 ».
espie
In article , clapannac wrote:
Bonjour, Voila je commence a coder sous C et j'ai une fonction qui patine sans que j'en trouve l'erreur... Alors j'espère que vous pourrez me faire par de vos lumière. Cordialement
Voici le code ...
###################### les fichiers source ############### Main.c # ########
printf("Longueur du mot secre : "); Etoile_Secr(motSecret);
printf("Propose une lettre : "); lettreTap = lireCaractere();
printf("Etat du mot secre : "); printf("%s",Result_Trouve_Cache_Save(motSecret,lettreTap));
return 0; }
Pas l'impression que tu aies compris grand chose a la compilation separee. Tu veux utiliser lireCaractere() -> il faut #include "Proto.h" dans Main.c comme dans Fonction.c.
Il faut aussi utiliser les bons entetes systeme au bon endroit: pour Main.c, seul stdio.h m'a l'air necessaire.
########### Fonction.c # ###########
char lireCaractere() { char caractere = 0;
caractere = getchar(); // On lit le premier caractère caractere = toupper(caractere); // On met la lettre en majuscule si elle ne l'est pas déjà
// On lit les autres caractères mémorisés un à un jusqu'à l'n (pour les effacer) while (getchar() != 'n') ; // il y a un ";" car c'est une boucle minimaliste "Technique de programmeur"
return caractere; // On retourne le premier caractère qu'on a lu
}
void Etoile_Secr(char* Tab) { int i = 0;
for(i=0;i<Tab[i];i++) { printf("*"); }
printf("n"); }
char* Result_Trouve_Cache_Save(char* Tab,char lettre) { int i = 0; char* copieTab = 0; int longueurChaine = 0; longueurChaine = strlen(Tab);
copieTab = malloc(longueurChaine); if (copieTab == 0) { exit(0); }
for (i = 0 ; i < Tab[i] ; i++) { if (lettre == Tab[i]) { copieTab[i] = lettre; printf("%sn",copieTab); // J'ai testé pour voir et je comprend pas } else { copieTab[i] = '*'; printf("%sn",copieTab); // J'ai testé pour voir et je comprend pas }
}
// free(copieTab) return copieTab; // Est-ce que le return suffirait ? }
Remarque suivante: ce fichier d'entete n'est visiblement jamais passe a traver un compilateur, il comporte des erreurs majeures.
Je ne sais pas du tout avec quoi tu compiles, mais il faut tres serieusement que tu regardes la doc de ton compilateur: ce code va forcement te sortir au moins des gros avertissements, et sans doute aussi des erreurs des que tu demandes un peu d'aide.
Typiquement, les compilos "font confiance" au programmeur. Si par exemple tu utilises gcc, il faut que tu specifies, au minimum, -W -Wall -O2 pour avoir une chance de t'y retrouver.
Commence par corriger les multiples erreurs de debutant que tu peux avec un peu d'aide de ton compilo, et reviens ensuite ici poser des questions sur ce qui manque.
In article <PZ-dnXVinqggJpvS4p2dnAA@giganews.com>,
clapannac <nospam_kohac_69@hotmail.fr.invalid> wrote:
Bonjour, Voila je commence a coder sous C et j'ai une fonction qui patine sans
que j'en trouve l'erreur...
Alors j'espère que vous pourrez me faire par de vos lumière.
Cordialement
Voici le code ...
###################### les fichiers source ###############
Main.c #
########
printf("Longueur du mot secre : ");
Etoile_Secr(motSecret);
printf("Propose une lettre : ");
lettreTap = lireCaractere();
printf("Etat du mot secre : ");
printf("%s",Result_Trouve_Cache_Save(motSecret,lettreTap));
return 0;
}
Pas l'impression que tu aies compris grand chose a la compilation separee.
Tu veux utiliser lireCaractere() -> il faut #include "Proto.h"
dans Main.c comme dans Fonction.c.
Il faut aussi utiliser les bons entetes systeme au bon endroit: pour Main.c,
seul stdio.h m'a l'air necessaire.
###########
Fonction.c #
###########
char lireCaractere()
{
char caractere = 0;
caractere = getchar(); // On lit le premier caractère
caractere = toupper(caractere); // On met la lettre en majuscule si elle ne
l'est pas déjà
// On lit les autres caractères mémorisés un à un jusqu'à l'n (pour les
effacer)
while (getchar() != 'n') ; // il y a un ";" car c'est une boucle
minimaliste "Technique de programmeur"
return caractere; // On retourne le premier caractère qu'on a lu
}
void Etoile_Secr(char* Tab)
{
int i = 0;
for(i=0;i<Tab[i];i++)
{
printf("*");
}
printf("n");
}
char* Result_Trouve_Cache_Save(char* Tab,char lettre)
{
int i = 0;
char* copieTab = 0;
int longueurChaine = 0;
longueurChaine = strlen(Tab);
copieTab = malloc(longueurChaine);
if (copieTab == 0)
{
exit(0);
}
for (i = 0 ; i < Tab[i] ; i++)
{
if (lettre == Tab[i])
{
copieTab[i] = lettre;
printf("%sn",copieTab); // J'ai
testé pour voir et je comprend pas
}
else
{
copieTab[i] = '*';
printf("%sn",copieTab); // J'ai
testé pour voir et je comprend pas
}
}
// free(copieTab)
return copieTab; //
Est-ce que le return suffirait ?
}
Remarque suivante: ce fichier d'entete n'est visiblement jamais passe
a traver un compilateur, il comporte des erreurs majeures.
Je ne sais pas du tout avec quoi tu compiles, mais il faut tres serieusement
que tu regardes la doc de ton compilateur: ce code va forcement te sortir
au moins des gros avertissements, et sans doute aussi des erreurs des que
tu demandes un peu d'aide.
Typiquement, les compilos "font confiance" au programmeur. Si par exemple
tu utilises gcc, il faut que tu specifies, au minimum, -W -Wall -O2
pour avoir une chance de t'y retrouver.
Commence par corriger les multiples erreurs de debutant que tu peux avec
un peu d'aide de ton compilo, et reviens ensuite ici poser des questions
sur ce qui manque.
Bonjour, Voila je commence a coder sous C et j'ai une fonction qui patine sans que j'en trouve l'erreur... Alors j'espère que vous pourrez me faire par de vos lumière. Cordialement
Voici le code ...
###################### les fichiers source ############### Main.c # ########
printf("Longueur du mot secre : "); Etoile_Secr(motSecret);
printf("Propose une lettre : "); lettreTap = lireCaractere();
printf("Etat du mot secre : "); printf("%s",Result_Trouve_Cache_Save(motSecret,lettreTap));
return 0; }
Pas l'impression que tu aies compris grand chose a la compilation separee. Tu veux utiliser lireCaractere() -> il faut #include "Proto.h" dans Main.c comme dans Fonction.c.
Il faut aussi utiliser les bons entetes systeme au bon endroit: pour Main.c, seul stdio.h m'a l'air necessaire.
########### Fonction.c # ###########
char lireCaractere() { char caractere = 0;
caractere = getchar(); // On lit le premier caractère caractere = toupper(caractere); // On met la lettre en majuscule si elle ne l'est pas déjà
// On lit les autres caractères mémorisés un à un jusqu'à l'n (pour les effacer) while (getchar() != 'n') ; // il y a un ";" car c'est une boucle minimaliste "Technique de programmeur"
return caractere; // On retourne le premier caractère qu'on a lu
}
void Etoile_Secr(char* Tab) { int i = 0;
for(i=0;i<Tab[i];i++) { printf("*"); }
printf("n"); }
char* Result_Trouve_Cache_Save(char* Tab,char lettre) { int i = 0; char* copieTab = 0; int longueurChaine = 0; longueurChaine = strlen(Tab);
copieTab = malloc(longueurChaine); if (copieTab == 0) { exit(0); }
for (i = 0 ; i < Tab[i] ; i++) { if (lettre == Tab[i]) { copieTab[i] = lettre; printf("%sn",copieTab); // J'ai testé pour voir et je comprend pas } else { copieTab[i] = '*'; printf("%sn",copieTab); // J'ai testé pour voir et je comprend pas }
}
// free(copieTab) return copieTab; // Est-ce que le return suffirait ? }
Remarque suivante: ce fichier d'entete n'est visiblement jamais passe a traver un compilateur, il comporte des erreurs majeures.
Je ne sais pas du tout avec quoi tu compiles, mais il faut tres serieusement que tu regardes la doc de ton compilateur: ce code va forcement te sortir au moins des gros avertissements, et sans doute aussi des erreurs des que tu demandes un peu d'aide.
Typiquement, les compilos "font confiance" au programmeur. Si par exemple tu utilises gcc, il faut que tu specifies, au minimum, -W -Wall -O2 pour avoir une chance de t'y retrouver.
Commence par corriger les multiples erreurs de debutant que tu peux avec un peu d'aide de ton compilo, et reviens ensuite ici poser des questions sur ce qui manque.
Manuel Giraud
(Marc Espie) writes:
Typiquement, les compilos "font confiance" au programmeur. Si par exemple tu utilises gcc, il faut que tu specifies, au minimum, -W -Wall -O2 pour avoir une chance de t'y retrouver.
On peut aussi ajouter -Werror pour plus de motivation à corriger les warnings. Mais pourquoi le -O2 ?
-- Manuel Giraud
espie@lain.home (Marc Espie) writes:
Typiquement, les compilos "font confiance" au programmeur. Si par exemple
tu utilises gcc, il faut que tu specifies, au minimum, -W -Wall -O2
pour avoir une chance de t'y retrouver.
On peut aussi ajouter -Werror pour plus de motivation à corriger les
warnings. Mais pourquoi le -O2 ?
Typiquement, les compilos "font confiance" au programmeur. Si par exemple tu utilises gcc, il faut que tu specifies, au minimum, -W -Wall -O2 pour avoir une chance de t'y retrouver.
On peut aussi ajouter -Werror pour plus de motivation à corriger les warnings. Mais pourquoi le -O2 ?
-- Manuel Giraud
Marc
Manuel Giraud wrote:
(Marc Espie) writes:
Typiquement, les compilos "font confiance" au programmeur. Si par exemple tu utilises gcc, il faut que tu specifies, au minimum, -W -Wall -O2 pour avoir une chance de t'y retrouver.
On peut aussi ajouter -Werror pour plus de motivation à corriger les warnings. Mais pourquoi le -O2 ?
Parce que l'optimization déclenche une analyse plus poussée du code qui est utilisée par certains warnings. Ce comportement est plus ou moins considéré comme un bug.
Manuel Giraud wrote:
espie@lain.home (Marc Espie) writes:
Typiquement, les compilos "font confiance" au programmeur. Si par exemple
tu utilises gcc, il faut que tu specifies, au minimum, -W -Wall -O2
pour avoir une chance de t'y retrouver.
On peut aussi ajouter -Werror pour plus de motivation à corriger les
warnings. Mais pourquoi le -O2 ?
Parce que l'optimization déclenche une analyse plus poussée du code
qui est utilisée par certains warnings. Ce comportement est plus ou
moins considéré comme un bug.
Typiquement, les compilos "font confiance" au programmeur. Si par exemple tu utilises gcc, il faut que tu specifies, au minimum, -W -Wall -O2 pour avoir une chance de t'y retrouver.
On peut aussi ajouter -Werror pour plus de motivation à corriger les warnings. Mais pourquoi le -O2 ?
Parce que l'optimization déclenche une analyse plus poussée du code qui est utilisée par certains warnings. Ce comportement est plus ou moins considéré comme un bug.
espie
In article , Manuel Giraud wrote:
(Marc Espie) writes:
Typiquement, les compilos "font confiance" au programmeur. Si par exemple tu utilises gcc, il faut que tu specifies, au minimum, -W -Wall -O2 pour avoir une chance de t'y retrouver.
On peut aussi ajouter -Werror pour plus de motivation à corriger les warnings. Mais pourquoi le -O2 ?
Comme le disait Marc, demander l'optimisation forcera le compilo a regarder declarations et utilisations de variables de facon plus detaillee. Ca te donnera donc des jolis avertissements sur des trucs genre "oh ben, cette variable peut etre utilisee avant d'avoir ete initialisee".
A titre perso, la correction de cet avertissement m'a toujours ete benefique: si le compilo a du mal a determiner dans une foret de tests quelle branche initialise la variable et quelle branche le n'initialise pas, il y a fort a parier qu'il y a un chemin dans le code, generalement une recuperation d'erreur, qui oublie l'initialisation. Et de toutes facons, si le code est incomprehensible pour le compilateur, ca veut dire qu'il est inmaintainable par un etre humain...
Egalement, certaines des versions de gcc ont tendance a initialiser les variables locales a 0 en l'absence d'optimisation, ce qui va evidemment cacher de gros problemes !
Je ne suis pas non plus trop certain que l'analyse des effets de bord de ++ et -- entre deux sequence points soit active sans un -O quelconque (j'accuse mon grand age: pour moi, c'est des fonctionnalites toutes nouvelles de gcc ;) ).
Le -O2, plus specifiquement, est affaire de tradition: pendant de tres longues annees, tous les projets ont utilise gcc -O2 comme mode de compilation standard. Celui-ci est donc, encore aujourd'hui, le mieux teste, et celui qui t'offrira la meilleure qualite de resultats sur tous les systemes.
Cote motivation a corriger les warnings, la meilleure motivation reste toujours de comprendre ces warnings.
Pour un debutant, il faut realiser que le C est, objectivement, un langage hostile au neophyte. Toute aide qu'il peut obtenir est la bienvenue, et tout avertissement DOIT etre considere comme une erreur (en particulier tout avertissement non compris, ou pas forcement compris a 100%). Les compilos modernes sont quand meme plutot bons, et il faut deja un niveau de sophistication raisonnable pour pouvoir ignorer un des avertissements de -W -Wall sans consequence nefaste sur le code considere (le plus benin de ces avertissements te donnera souvent du code non portable ailleurs que sur la plateforme ou tu as ecrit le code).
In article <87zke0kczd.fsf@ledu-giraud.fr>,
Manuel Giraud <manuel@ledu-giraud.fr> wrote:
espie@lain.home (Marc Espie) writes:
Typiquement, les compilos "font confiance" au programmeur. Si par exemple
tu utilises gcc, il faut que tu specifies, au minimum, -W -Wall -O2
pour avoir une chance de t'y retrouver.
On peut aussi ajouter -Werror pour plus de motivation à corriger les
warnings. Mais pourquoi le -O2 ?
Comme le disait Marc, demander l'optimisation forcera le compilo a
regarder declarations et utilisations de variables de facon plus detaillee.
Ca te donnera donc des jolis avertissements sur des trucs genre "oh ben,
cette variable peut etre utilisee avant d'avoir ete initialisee".
A titre perso, la correction de cet avertissement m'a toujours ete
benefique: si le compilo a du mal a determiner dans une foret de tests
quelle branche initialise la variable et quelle branche le n'initialise
pas, il y a fort a parier qu'il y a un chemin dans le code, generalement
une recuperation d'erreur, qui oublie l'initialisation. Et de toutes facons,
si le code est incomprehensible pour le compilateur, ca veut dire qu'il
est inmaintainable par un etre humain...
Egalement, certaines des versions de gcc ont tendance a initialiser les
variables locales a 0 en l'absence d'optimisation, ce qui va evidemment
cacher de gros problemes !
Je ne suis pas non plus trop certain que l'analyse des effets de bord de ++
et -- entre deux sequence points soit active sans un -O quelconque (j'accuse
mon grand age: pour moi, c'est des fonctionnalites toutes nouvelles de gcc
;) ).
Le -O2, plus specifiquement, est affaire de tradition: pendant de tres
longues annees, tous les projets ont utilise gcc -O2 comme mode de
compilation standard. Celui-ci est donc, encore aujourd'hui, le mieux teste,
et celui qui t'offrira la meilleure qualite de resultats sur tous les
systemes.
Cote motivation a corriger les warnings, la meilleure motivation reste
toujours de comprendre ces warnings.
Pour un debutant, il faut realiser que le C est, objectivement, un langage
hostile au neophyte. Toute aide qu'il peut obtenir est la bienvenue, et
tout avertissement DOIT etre considere comme une erreur (en particulier
tout avertissement non compris, ou pas forcement compris a 100%). Les
compilos modernes sont quand meme plutot bons, et il faut deja un
niveau de sophistication raisonnable pour pouvoir ignorer un des
avertissements de -W -Wall sans consequence nefaste sur le code
considere (le plus benin de ces avertissements te donnera souvent du
code non portable ailleurs que sur la plateforme ou tu as ecrit le code).
Typiquement, les compilos "font confiance" au programmeur. Si par exemple tu utilises gcc, il faut que tu specifies, au minimum, -W -Wall -O2 pour avoir une chance de t'y retrouver.
On peut aussi ajouter -Werror pour plus de motivation à corriger les warnings. Mais pourquoi le -O2 ?
Comme le disait Marc, demander l'optimisation forcera le compilo a regarder declarations et utilisations de variables de facon plus detaillee. Ca te donnera donc des jolis avertissements sur des trucs genre "oh ben, cette variable peut etre utilisee avant d'avoir ete initialisee".
A titre perso, la correction de cet avertissement m'a toujours ete benefique: si le compilo a du mal a determiner dans une foret de tests quelle branche initialise la variable et quelle branche le n'initialise pas, il y a fort a parier qu'il y a un chemin dans le code, generalement une recuperation d'erreur, qui oublie l'initialisation. Et de toutes facons, si le code est incomprehensible pour le compilateur, ca veut dire qu'il est inmaintainable par un etre humain...
Egalement, certaines des versions de gcc ont tendance a initialiser les variables locales a 0 en l'absence d'optimisation, ce qui va evidemment cacher de gros problemes !
Je ne suis pas non plus trop certain que l'analyse des effets de bord de ++ et -- entre deux sequence points soit active sans un -O quelconque (j'accuse mon grand age: pour moi, c'est des fonctionnalites toutes nouvelles de gcc ;) ).
Le -O2, plus specifiquement, est affaire de tradition: pendant de tres longues annees, tous les projets ont utilise gcc -O2 comme mode de compilation standard. Celui-ci est donc, encore aujourd'hui, le mieux teste, et celui qui t'offrira la meilleure qualite de resultats sur tous les systemes.
Cote motivation a corriger les warnings, la meilleure motivation reste toujours de comprendre ces warnings.
Pour un debutant, il faut realiser que le C est, objectivement, un langage hostile au neophyte. Toute aide qu'il peut obtenir est la bienvenue, et tout avertissement DOIT etre considere comme une erreur (en particulier tout avertissement non compris, ou pas forcement compris a 100%). Les compilos modernes sont quand meme plutot bons, et il faut deja un niveau de sophistication raisonnable pour pouvoir ignorer un des avertissements de -W -Wall sans consequence nefaste sur le code considere (le plus benin de ces avertissements te donnera souvent du code non portable ailleurs que sur la plateforme ou tu as ecrit le code).
Manuel Pégourié-Gonnard
Marc Espie scripsit :
In article , Manuel Giraud wrote:
(Marc Espie) writes:
Typiquement, les compilos "font confiance" au programmeur. Si par exemple tu utilises gcc, il faut que tu specifies, au minimum, -W -Wall -O2 pour avoir une chance de t'y retrouver.
On peut aussi ajouter -Werror pour plus de motivation à corriger les warnings. Mais pourquoi le -O2 ?
Comme le disait Marc, demander l'optimisation forcera le compilo a regarder declarations et utilisations de variables de facon plus detaillee. Ca te donnera donc des jolis avertissements sur des trucs genre "oh ben, cette variable peut etre utilisee avant d'avoir ete initialisee".
Tiens, je ne savais pas, merci pour l'info et les explications.
Par contre, je remarque que tu ne sembles pas recommander -pedantic ni -ansi ou stdÉ9, pourquoi ?
In article <87zke0kczd.fsf@ledu-giraud.fr>,
Manuel Giraud <manuel@ledu-giraud.fr> wrote:
espie@lain.home (Marc Espie) writes:
Typiquement, les compilos "font confiance" au programmeur. Si par exemple
tu utilises gcc, il faut que tu specifies, au minimum, -W -Wall -O2
pour avoir une chance de t'y retrouver.
On peut aussi ajouter -Werror pour plus de motivation à corriger les
warnings. Mais pourquoi le -O2 ?
Comme le disait Marc, demander l'optimisation forcera le compilo a
regarder declarations et utilisations de variables de facon plus detaillee.
Ca te donnera donc des jolis avertissements sur des trucs genre "oh ben,
cette variable peut etre utilisee avant d'avoir ete initialisee".
Tiens, je ne savais pas, merci pour l'info et les explications.
Par contre, je remarque que tu ne sembles pas recommander -pedantic ni
-ansi ou stdÉ9, pourquoi ?
--
Manuel Pégourié-Gonnard - http://people.math.jussieu.fr/~mpg/
Typiquement, les compilos "font confiance" au programmeur. Si par exemple tu utilises gcc, il faut que tu specifies, au minimum, -W -Wall -O2 pour avoir une chance de t'y retrouver.
On peut aussi ajouter -Werror pour plus de motivation à corriger les warnings. Mais pourquoi le -O2 ?
Comme le disait Marc, demander l'optimisation forcera le compilo a regarder declarations et utilisations de variables de facon plus detaillee. Ca te donnera donc des jolis avertissements sur des trucs genre "oh ben, cette variable peut etre utilisee avant d'avoir ete initialisee".
Tiens, je ne savais pas, merci pour l'info et les explications.
Par contre, je remarque que tu ne sembles pas recommander -pedantic ni -ansi ou stdÉ9, pourquoi ?
In article <je7c6s$e6t$, Manuel Pégourié-Gonnard wrote:
Par contre, je remarque que tu ne sembles pas recommander -pedantic ni -ansi ou stdÉ9, pourquoi ?
Parce que ceux-la sont moins neutres, et vont dependre un peu de ce qu'on veut faire exactement...
espie
In article <je7cc3$12hi$, Marc Espie wrote:
In article <je7c6s$e6t$, Manuel Pégourié-Gonnard wrote:
Par contre, je remarque que tu ne sembles pas recommander -pedantic ni -ansi ou stdÉ9, pourquoi ?
Parce que ceux-la sont moins neutres, et vont dependre un peu de ce qu'on veut faire exactement...
En particulier, je considere qu'on est toujours dans une periode "de transition" (qui s'acheve cependant), ou on peut avoir a ecrire du code qui sera C89/C99 ou autre chose au milieu. Donc si active l'un des standards, ca peut supprimer ou ajouter des avertissements lies a la portabilite (l'absence de return a la fin du main par exemple) et j'avoue ne pas avoir d'opinion trop marquee.
Tout ceci se manifeste par "du bruit" pour le debutant, sous formes de warnings qui sont plus ou moins pertinents, et donc certains qu'il peut etre amene a ignorer... je prefere rester sur des trucs plus purs et moins confusants au debut, histoire de ne pas prendre de sales habitudes trop rapidement.
In article <je7cc3$12hi$1@saria.nerim.net>, Marc Espie <espie@nerim.net> wrote:
In article <je7c6s$e6t$1@thue.elzevir.fr>,
Manuel Pégourié-Gonnard <mpg@elzevir.fr> wrote:
Par contre, je remarque que tu ne sembles pas recommander -pedantic ni
-ansi ou stdÉ9, pourquoi ?
Parce que ceux-la sont moins neutres, et vont dependre un peu de ce qu'on
veut faire exactement...
En particulier, je considere qu'on est toujours dans une periode
"de transition" (qui s'acheve cependant), ou on peut avoir a ecrire du
code qui sera C89/C99 ou autre chose au milieu. Donc si active l'un des
standards, ca peut supprimer ou ajouter des avertissements lies a la
portabilite (l'absence de return a la fin du main par exemple) et j'avoue
ne pas avoir d'opinion trop marquee.
Tout ceci se manifeste par "du bruit" pour le debutant, sous formes
de warnings qui sont plus ou moins pertinents, et donc certains qu'il
peut etre amene a ignorer... je prefere rester sur des trucs plus purs
et moins confusants au debut, histoire de ne pas prendre de sales
habitudes trop rapidement.
In article <je7c6s$e6t$, Manuel Pégourié-Gonnard wrote:
Par contre, je remarque que tu ne sembles pas recommander -pedantic ni -ansi ou stdÉ9, pourquoi ?
Parce que ceux-la sont moins neutres, et vont dependre un peu de ce qu'on veut faire exactement...
En particulier, je considere qu'on est toujours dans une periode "de transition" (qui s'acheve cependant), ou on peut avoir a ecrire du code qui sera C89/C99 ou autre chose au milieu. Donc si active l'un des standards, ca peut supprimer ou ajouter des avertissements lies a la portabilite (l'absence de return a la fin du main par exemple) et j'avoue ne pas avoir d'opinion trop marquee.
Tout ceci se manifeste par "du bruit" pour le debutant, sous formes de warnings qui sont plus ou moins pertinents, et donc certains qu'il peut etre amene a ignorer... je prefere rester sur des trucs plus purs et moins confusants au debut, histoire de ne pas prendre de sales habitudes trop rapidement.
