Bonjour ! Tu es sous Windows ? J'ai fait du C sous Windows 7, et à l'époque la console n'utilisait pas le même encodage que les éditeurs. Pour afficher les lettres accentuées, j'utilisais cette correspondance :
c = getchar() ;
switch (c)
{
case 224 : printf("\\205" ) ; break ; // a accent grave
case 226 : printf("\\203" ) ; break ; // circonflexe
case 228 : printf("\\204" ) ; break ; // trêma
case 233 : printf("\\202" ) ; break ; // e accent aigu
case 232 : printf("\\212" ) ; break ; // grave
case 234 : printf("\\210" ) ; break ; // circonflexe
case 235 : printf("\\211" ) ; break ; // trêma
case 238 : printf("\\214" ) ; break ; // i accent circonflexe
case 239 : printf("\\213" ) ; break ; // trêma
case 244 : printf("\\223" ) ; break ; // o accent circonflexe
case 246 : printf("\\224" ) ; break ; // trêma
case 249 : printf("\\227" ) ; break ; // u accent grave
case 251 : printf("\\226" ) ; break ; // accent circonflexe
case 252 : printf("\\201" ) ; break ; // trêma
case 255 : printf("\\230" ) ; break ; // y trêma
case 230 : printf("\\221" ) ; break ; // ae collés
case 231 : printf("\\207" ) ; break ; // c cédille
case 241 : printf("\\244" ) ; break ; // n de canyon
case 192 : printf("\\267" ) ; break ; // A accent grave
case 194 : printf("\\266" ) ; break ; // accent circonflexe
case 196 : printf("\\216" ) ; break ; // trêma
case 201 : printf("\\220" ) ; break ; // E accent aigu
case 200 : printf("\\324" ) ; break ; // accent grave
case 202 : printf("\\322" ) ; break ; // accent circonflexe
case 203 : printf("\\323" ) ; break ; // trêma
case 206 : printf("\\327" ) ; break ; // I accent circonflexe
case 207 : printf("Iš" ) ; break ; // pas trouvé...
case 212 : printf("O^" ) ; break ; // pas trouvé...
case 214 : printf("\\231" ) ; break ; // O trêma
case 217 : printf("\\353" ) ; break ; // U accent grave
case 219 : printf("\\352" ) ; break ; // accent circonflexe
case 220 : printf("\\232" ) ; break ; // trêma
case 221 : printf("\\330" ) ; break ; // Y trêma
case 198 : printf("\\222" ) ; break ; // AE collés
case 199 : printf("\\200" ) ; break ; // C cédille
case 209 : printf("\\245" ) ; break ; // N de canyon
case 171 : printf("\\256" ) ; break ; // guillemets ouvrants
case 187 : printf("\\257" ) ; break ; // guillemets fermants
case 215 : printf("\\236" ) ; break ; // fois
case 247 : printf("\\366" ) ; break ; // divisé
// case 126 : printf("" ) ; break ; // pas trouvé ...
case 177 : printf("\\361" ) ; break ; // plus ou moins
case 186 : printf("\\247" ) ; break ; // degrés
case 216 : printf("\\235" ) ; break ; // ensemble vide
default : printf("%c", c ) ;
}
Si je me souviens bien :
− On tape une lettre, qui est lue par 'getchar' sous forme d'un n° ASCII étendu.
− Mais pour l'afficher avec 'printf' il faut utiliser l'encodage de la console, qui est différent.
(Si je me souviens bien. Mais c'est vieux, j'ai retrouvé ça dans un fichier datant de 2012. Je ne sais pas si les Windows récents ont toujours cet inconvénient.)
Encore une idée: en console, tape "chcp 1252" (sans les guillemets). Tu peux aussi (solution de dépannage) mettre system("chcp 1252"); en ligne 4bis (nécéssite stdlib.h)
Edit: main() renvoie un int. Il manque un return(qqchose).
- Edité par edgarjacobs 25 juin 2023 à 19:11:41
On écrit "j'ai tort", pas "tord" qui est le verbe "tordre" à la 3ème personne de l'indicatif présent
En C il y a une bizarrerie sur les constantes censées contenir un caractére. On peut - pour des raisons historiques - écrire
char c = 'xyz';
Et alors c contiendra le premier octet 'x'
C a été conçu en confondant caractère et octet, avec l'hypothèse qu'un caractère tenait dans un "byte" qui tenait dans un octet
Comme on se sert des octets pour toutes les zones tampon (exemple pour un read), il devrait y avoir un type "byte", ça serait plus logique. Mais bon, y a déjà char, dont on ne sait pas si il est signé ou pas, who cares ?
De nos jours, on utilise souvent l'encodage utf8 pour unicode. Il se trouve que c'est un codage "multibyte", dans lequel seul les 128 caractères Ascii 7 bits sont codés sur un octet. Les autres, c'est sur 2, 3,... en particulier c'est le cas du 'é'.
Alors on a un problème quand on compile un texte source utf8 pour produire un exécutable qui tournera sur un console avec le codage cp 1252 ou autre isolatin 8 bits.
PS: Faut se rappeler que le langage C, c'est un langage bricolé pour remplacer l'assembleur pour la programmation du noyau et des utilitaires de base d'unix, avec comme contrainte initiale forte de devoir tourner en mémoire sur quelques kilo-octets. A l'époque, on faisait mieux en matière de conception de langages de programmation (PL/I était sorti en 64, par exemple). Le succès de C, c'est venu en grande partie à cause de la compatibilité Unix d'un côté et parce que ça compilait sur des micros de l'autre dans les années 80. Du coup ça c'est développé sauvagement, chaque compilateur avec ses extensions et variantes, avant que le langage soit réellement standardisé (1989....) : beaucoup trop tard pour rectifier les erreurs de tir....
Je traduis/résume 6.4.4.4 character constants (page 65)
Une constante caractère, c'est
un préfixe d'encodage, optionnel, qui peut être u8 (utf_8), u (utf-16) , U (utf-32) ou L (wchar_t)
une séquence non vide de caractères-C, entre "quotes"
Le caractère C, c'est
n'importe quel caractères sauf ', \ ou saut de ligne
ou une séquence avec préfixe \, genre \n, \', etc
Semantique (11)
si un seul caractère : la valeur numérique de celui-ci
si plusieurs, ça dépend
The value of an integer character constant containing more than one character (e.g.,’ab’), or containing a character or escape sequence that does not map to a single value in the literal encoding, is implementation-defined.
(*) enfin, c'est historiquement IBM un truc d'IBM (rappelez vous, le PC...) qui date d'avant ISO-LATIN (années 90). Le problème, c'est de distribuer des systèmes d'exploitation avec des consoles qui fonctionnent avec ce standard antique.
Et même plus qu'un peu. Un des objectifs de C était d'avoir des programmes sources portables, avec les histoires d'encodage, c'est un peu raté pour y arriver en C.
Voilà pourquoi, il y a dix ans, j'ai écrit un petit programme qui affiche toutes les possibilités (sur ma console). Il faut tester, expérimenter... et essayer de comprendre un jour.
L'éditeur utilisait l'extension ISO-Latin 1, mais la console utilisait une autre extension (la page de code 850 si j'ai bien compris vos messages), d'où les codes différents. Ce n'est pas de l'ASCII mais des extensions de l'ASCII. Je ne sais pas comment ça marche sur les Windows récents.
Je ne sais pas comment ça marche sur les Windows récents.
Ça n'a pas beaucoup changé, en interne et pour les application graphique c'est de l' UTF-16 LE (avant que l'UTF-8 existe).
Les code source peuvent être en CP 1252 , ISO 8859-1 (Latin-1) et consœurs... et en UTF-8 si compilation en UNICODE. (Les compilateurs n'apprécie pas l'UTF-16)
Il y a un truc (a trick) (of the tail <-- excellent album!) qui permet de mettre la console dans le code page souhaité: il suffit de modifier le champ "cible" dans le raccourci:
Notez l'ajout de /K chcp 1252 dans le champ "cible"
Edit: et pour être transparent, on peut écrire /K chcp 1252 > NUL
- Edité par edgarjacobs 1 juillet 2023 à 0:49:42
On écrit "j'ai tort", pas "tord" qui est le verbe "tordre" à la 3ème personne de l'indicatif présent
Problème d'encodage
× Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
× Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
On écrit "j'ai tort", pas "tord" qui est le verbe "tordre" à la 3ème personne de l'indicatif présent
Le Tout est souvent plus grand que la somme de ses parties.
On écrit "j'ai tort", pas "tord" qui est le verbe "tordre" à la 3ème personne de l'indicatif présent
Le Tout est souvent plus grand que la somme de ses parties.
On écrit "j'ai tort", pas "tord" qui est le verbe "tordre" à la 3ème personne de l'indicatif présent