Problème avec char motSecret[] = ""; Dés lors Qu'il exède les 8 char

Le
clapannac Hors ligne
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 #
########

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>

int main()
{
char motSecret[] = "GRAMMAIRE";
char lettreTap = "";

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' (pour les effacer)
while (getchar() != '') ; // 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("");
}

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",copieTab); // J'ai testé pour voir et je comprend pas
}
else
{
copieTab[i] = '*';
printf("%s",copieTab); // J'ai testé pour voir et je comprend pas
}

}
// free(copieTab)
return copieTab; // Est-ce que le return suffirait ?
}

################ Headers ###############
Proto.h #
########


#ifndef Proto.h
#define Proto.h

char lireCaractere();
void Etoile_Secr((char* Tab));
char* Result_Trouve_Cache_Save(char* Tab,char lettre);

#endif

########################################################################################################################################################################################################################

Voila, c'est surement un petit quelque chose de rien du tout mais qui m'échappe, votre aide est la bienvenue
Vidéos High-Tech et Jeu Vidéo
Téléchargements
Vos réponses Page 1 / 3
Gagnez chaque mois un abonnement Premium avec GNT : Inscrivez-vous !
Trier par : date / pertinence
YBM
Le #24133981
Le 06.01.2012 10:15, clapannac a écrit :
for (i = 0 ; i< Tab[i] ; i++)



i<Tab[i] n'a aucun sens...

c'est (sans doute) i<longueurChaine que tu veux.

pas dit que ce soit la seule erreur, mais celle-là saute aux yeux.
Olivier Miakinen
Le #24134811
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.


Cordialement,
--
Olivier Miakinen
Olivier Miakinen
Le #24134801
Le 06/01/2012 14:45, j'écrivais :

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



... et j'ai oublié de préciser qu'il vaut mieux tester carrément
« Tab[i] != 0 ».
espie
Le #24135001
In article 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 #
########

#include #include #include #include
int main()
{
char motSecret[] = "GRAMMAIRE";
char lettreTap = "";

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



Meme remarque: manque tous les fichiers d'entete.

################ Headers ###############
Proto.h #
########


#ifndef Proto.h
#define Proto.h

char lireCaractere();
void Etoile_Secr((char* Tab));
char* Result_Trouve_Cache_Save(char* Tab,char lettre);

#endif



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
Le #24135431
(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
Marc
Le #24135571
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.
espie
Le #24135661
In article 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 ?



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
Le #24135811
Marc Espie scripsit :

In article 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 ?



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/
espie
Le #24135801
In article Manuel Pégourié-Gonnard
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
Le #24135791
In article
In article Manuel Pégourié-Gonnard
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.
Publicité
Poster une réponse
Anonyme