Discussion :

[kaitlyn]

ça fait trois jours que je cherche, 5 heures par jours.

Quel est ton compilateur, ton éditeur de code ?

[Philcmoi]

Merci j'utilise ECLIPSE et MinGw.

[kaitlyn]

Pourquoi Eclipse ?

[Philcmoi]

C'est l'IDE que j'ai l'habitude d'utiliser.
Pourquoi j'ai tord ?

[kaitlyn]

Tu l'utilises essentiellement pour java alors ?
Je demandais ça parce que pour apprendre le C++ c'est mieux de prendre un EDI plus léger et plus rapide, comme CodeBlocks par exemple.

[kaitlyn]

Ne pouvant pas attendre ta réponse, voici un code simple.
Sur Eclipse, tu cliques Edit -> Set encoding... -> Cp1252"
Si tu dois lire un fichier, il faudra aussi l'enregistrer en Cp1252.
Une liste des codes est disponible sur https://en.wikipedia.org/wiki/Windows-1252

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
#include <iostream>
 
int main() {
    char in[]= {"àbcdéfghù"};
    const size_t array_size= sizeof in;
    char out[array_size]= {};
    for (size_t i= 0; i < array_size; i++) {
        char c_in= in[i];
        int c_code= static_cast<unsigned char>(c_in);
        std::cout<< c_in<< ' ';
        char c_out= c_in;
        if (c_code == 0xE9) {c_out= 'e';}
        else if (c_code == 0xE0) {c_out= 'a';}
        else if (c_code == 0xF9) {c_out= 'u';}
        out[i]= c_out;
    }
 
    std::cout<< '\n';
 
    for (size_t i= 0; i < array_size; i++) {
        char c_out= out[i];
        std::cout<< c_out<< ' ';
    }
}

[bacelar]

Heu, sinon, pourquoi ne pas utiliser des fonctions dans des librairies qui prennent en entrée de l'UNICODE et qui peuvent supprimer les accents selon différentes méthodes de normalisation.
Fait plein de fois en JAVA, je ne comprendrai pas que cela n'existe pas en C++.
Pour les projets en C++, je suis assez finaud pour dire "vous êtes sûr que faire une usine à gaz est bien utile ?".

[Philcmoi]

Merci.
Je n'ai droit qu'au librairies les plus simples

#include <cstdio>
#include <cstdlib>
#include <vector>
#include <string>
#include <iostream>

[bacelar]

C'est pas des librairies mais des fichiers d'en-tête.
Donc le prof. auteur de cet exercice débile ne s'offusquera pas si vous faites des copier-coller des sources d'une librairie, vue que cela ne sera plus une librairie, ni des fichiers d'en-tête.
A exercice débile, on peut jouer sur les mots.

[Philcmoi]

Merci kaitlyn.
Ton code fonctionne très bien.

#include <iostream>

int main() {
char in[]= {"àbcdéfghù"};
const size_t array_size= sizeof in;
char out[array_size]= {};
for (size_t i= 0; i < array_size; i++) {
char c_in= in[i];
int c_code= static_cast<unsigned char>(c_in);
std::cout<< c_in<< ' ';
char c_out= c_in;
if (c_code == 0xE9) {c_out= 'e';}
else if (c_code == 0xE0) {c_out= 'a';}
else if (c_code == 0xF9) {c_out= 'u';}
out[i]= c_out;
}

std::cout<< '\n';

for (size_t i= 0; i < array_size; i++) {
char c_out= out[i];
std::cout<< c_out<< ' ';
}
}

J'essais de le mettre à ma sauce.

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
 
#include<stdio.h>
#include<stdlib.h>
#include <iostream>
using namespace std;
 
int main() {
 
char caractere, caractereMinuscule;
char valeurAsccii;
 
 
FILE* fic = NULL;
fic = fopen("src/presses/texttest.txt","r");
if (fic != NULL) {
do{
	caractere = fgetc(fic);
 
	int C_Code= static_cast<unsigned char>(caractere);
 
 
	if (C_Code == 0xE0) {caractere = 'a';}
 
	if (C_Code == 0xE9) {caractere = 'e';}
 
	if (C_Code == 0xF9) {caractere = 'u';}
 
 
 
if (caractere>='A' && caractere<='Z') {
	caractereMinuscule = caractere + 32;
// cout<<caractMinuscule;
caractere = caractereMinuscule;
 cout<<caractere;}
 
else {cout<<caractere;}
} while (caractere != EOF);
printf("\n");
fclose (fic);
}
return 0;
}

Là ça ne fonctionne pas.

Pourrais tu m'aider encore à voir ce qui ne vas pas dans mon code ???
Merci

[bacelar]

https://www.markcmusic.com/blog/2008...ransliterator/

[Philcmoi]

https://www.markcmusic.com/blog/2008...ransliterator/

Merci beaucoup.
Mais si j'utilise une bibliothèque donnée hors de celles autorisées je passe en conseil .
De plus mon code fonctionne mais les valeurs de comparaison sont mauvaises.
Je ne sais pas utiliser quelle table.

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
 
#include<stdio.h>
#include<stdlib.h>
#include <iostream>
using namespace std;
 
int main() {
 
char caractere, caractereMinuscule;
int valeurAsccii;
 
 
FILE* fic = NULL;
fic = fopen("src/presses/texttest.txt","r");
if (fic != NULL) {
do{
	caractere = fgetc(fic);
 
	valeurAsccii = static_cast<unsigned char>(caractere);
 
	if (valeurAsccii>=192 && valeurAsccii<=197) {caractere = 'a';}
 
if (caractere>='A' && caractere<='Z') {
	caractereMinuscule = caractere + 32;
// cout<<caractMinuscule;
caractere = caractereMinuscule;
 cout<<caractere;
 }
else {cout<<caractere;}
} while (caractere != EOF);
printf("\n");
fclose (fic);
}
return 0;
}

sur texttest.txt

AZERTY

àbcdéfghù

Ca donne sur la console éclipse.

AZERTY

àbcdéfghù

En affichant mon message le parseur donne ce qu'il y a en haut à la place de
azerty

a�bcda�fgha��

Reste à trouver la bonne table.

Messieurs Mesdames à vos stylo.

[ternel]

As-tu demandé au prof/donneur de consigne si le support de l'utf8 est exigé? Si le programme doit tourner dans une console ayant un "code page" déterminé?

J'ai l'impression que la tache est trop complexe pour que l'exercice soit pédagogiquement intéressant.

[Philcmoi]

En changeant le

AZERTY

àbcdéfghù

en ISO-8859-1
ça donne

AZERTY

Ã*bcdéfghÃ

[Philcmoi]

As-tu demandé au prof/donneur de consigne si le support de l'utf8 est exigé? Si le programme doit tourner dans une console ayant un "code page" déterminé?

J'ai l'impression que la tache est trop complexe pour que l'exercice soit pédagogiquement intéressant.

C'est pas un exercice c'est un projet de L2;

[kaitlyn]

Coucou tout le monde,

J'essais de le mettre à ma sauce.
.../...
Là ça ne fonctionne pas.

Oui parce que la majorité des fonctions de la famille fgetc() manipule des int et non des char.
Et comme ça ne suffisait pas, un caractère littéral 'x' est un int en C et un char en C++.
Tout cela t'oblige à jongler continuellement entre int et char.

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
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <clocale>
#include <iostream>
 
 
void set_locale_and_code_page()
{
    //Pour la prise en charge du code page 1252 et l'affichage correct des lettres dans la console.
    char* app_locale= std::setlocale(LC_CTYPE, ".1252");
    if (app_locale == nullptr)
        app_locale= std::setlocale(LC_CTYPE, "");
    std::cout<< "App locale: "<< app_locale<< '\n';
 
    //Si ce n'est pas suffisant, considérez les appels systèmes suivants :
    //    l'api windows SetConsoleOutputCP(1252);
    //    ou dans une moindre mesure et à titre exceptionnel std::system("chcp 1252");
    //et les options de compilation suivantes :
    //    -finput-charset=CP1252
    //    et optionnellement -fexec-charset=CP1252
}
 
 
void build_tmp_file(const char* file_name)
{
    //Construction du fichier d'entrée directement depuis l'application.
    char in[]= {"àâbcdéèêfghù"};
    if (FILE* tmp_file= std::fopen(file_name, "w")) {
        std::fwrite(in, sizeof in[0], std::strlen(in), tmp_file);
        std::fclose(tmp_file);
    }
}
 
 
void initialize_app(const char* file_name)
{
    set_locale_and_code_page();
    build_tmp_file(file_name);
}
 
 
int main() 
{
    const char* file_name= "tmp_file.txt";
    initialize_app(file_name);
    FILE* file= std::fopen(file_name, "r");
    if ( ! file)
        return EXIT_FAILURE;
 
    int ascii_code;
    while ((ascii_code= std::fgetc(file)) != EOF) {
        char char_in= static_cast<unsigned char>(ascii_code);
        char char_out= char_in;
 
        if (ascii_code >= 0xE8 && ascii_code <= 0xEB)
            char_out= 'e';
        else if (ascii_code >= static_cast<unsigned char>('à') && ascii_code <= static_cast<unsigned char>('å'))
            char_out= 'a';
        else if (ascii_code == 0xF9)
            char_out= 'u';
 
        std::cout<< std::hex<< ascii_code<< ": "<< char_in<<  " --> "<< char_out<< '\n';
    }
 
    std::fclose(file);
 
    return EXIT_SUCCESS;
}

[bacelar]

Où est le problème si tu copies-colles le code source d'une bibliothèque en licence MIT ?

[Philcmoi]

Coucou tout le monde,



Oui parce que la majorité des fonctions de la famille fgetc() manipule des int et non des char.
Et comme ça ne suffisait pas, un caractère littéral 'x' est un int en C et un char en C++.
Tout cela t'oblige à jongler continuellement entre int et char.

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
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <clocale>
#include <iostream>
 
 
void set_locale_and_code_page()
{
    //Pour la prise en charge du code page 1252 et l'affichage correct des lettres dans la console.
    char* app_locale= std::setlocale(LC_CTYPE, ".1252");
    if (app_locale == nullptr)
        app_locale= std::setlocale(LC_CTYPE, "");
    std::cout<< "App locale: "<< app_locale<< '\n';
 
    //Si ce n'est pas suffisant, considérez les appels systèmes suivants :
    //    l'api windows SetConsoleOutputCP(1252);
    //    ou dans une moindre mesure et à titre exceptionnel std::system("chcp 1252");
    //et les options de compilation suivantes :
    //    -finput-charset=CP1252
    //    et optionnellement -fexec-charset=CP1252
}
 
 
void build_tmp_file(const char* file_name)
{
    //Construction du fichier d'entrée directement depuis l'application.
    char in[]= {"àâbcdéèêfghù"};
    if (FILE* tmp_file= std::fopen(file_name, "w")) {
        std::fwrite(in, sizeof in[0], std::strlen(in), tmp_file);
        std::fclose(tmp_file);
    }
}
 
 
void initialize_app(const char* file_name)
{
    set_locale_and_code_page();
    build_tmp_file(file_name);
}
 
 
int main() 
{
    const char* file_name= "tmp_file.txt";
    initialize_app(file_name);
    FILE* file= std::fopen(file_name, "r");
    if ( ! file)
        return EXIT_FAILURE;
 
    int ascii_code;
    while ((ascii_code= std::fgetc(file)) != EOF) {
        char char_in= static_cast<unsigned char>(ascii_code);
        char char_out= char_in;
 
        if (ascii_code >= 0xE8 && ascii_code <= 0xEB)
            char_out= 'e';
        else if (ascii_code >= static_cast<unsigned char>('à') && ascii_code <= static_cast<unsigned char>('å'))
            char_out= 'a';
        else if (ascii_code == 0xF9)
            char_out= 'u';
 
        std::cout<< std::hex<< ascii_code<< ": "<< char_in<<  " --> "<< char_out<< '\n';
    }
 
    std::fclose(file);
 
    return EXIT_SUCCESS;
}

Les a,e et u ne sont pas retranscrite mais elles sont repérées.
quel est la norme ou table utilisée ?
Mais Merci beaucoup.


Voici ce que ça donne.

àâbcdéèêfghù

deviennent

App locale: French_France.1252
c3: � --> �
a0: � --> a
c3: � --> �
a2: � --> a
62: b --> b
63: c --> c
64: d --> d
c3: � --> �
a9: � --> �
c3: � --> �
a8: � --> �
c3: � --> �
aa: � --> �
66: f --> f
67: g --> g
68: h --> h
c3: � --> �
b9: � --> �

[Philcmoi]

Merci pour l'aides de tous et toute.
Voila ça fonctionne même si il reste quelques bugs.

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
 
#include <cstdio>
#include <cstdlib>
#include <vector>
#include <string>
#include <iostream>
using namespace std;
int main() {
 
char caractere, caractereMinuscule;
int ascii_code;
 
 
FILE* fic = NULL;
fic = fopen("src/presses/texttest.txt","r"); 
if (fic != NULL) {
do{
	ascii_code= std::fgetc(fic);
 
		caractere = static_cast<unsigned char>(ascii_code);
 
 
	 if (ascii_code >= static_cast<unsigned char>('à') && ascii_code <= static_cast<unsigned char>('à'))
		 caractere= 'a';
	        else if (ascii_code >= static_cast<unsigned char>('è') && ascii_code <= static_cast<unsigned char>('ë'))
	        	caractere= 'e';
	        else if (ascii_code == static_cast<unsigned char>('ù') && ascii_code <= static_cast<unsigned char>('ü'))
	        	caractere= 'u';
 
 
 
if (ascii_code>='A' && ascii_code<='Z') {
	caractereMinuscule = caractere + 32;
// cout<<caractMinuscule;
caractere = caractereMinuscule;
 cout<<caractere;
 }
else {cout<<caractere;}
} while (caractere != EOF);
printf("\n");
fclose (fic);
}
return 0;
}

texttest.txt

AZERTY

àbcdéfghù

Cela donne:


azerty

�abcd�efgh�u�


Tout ça en UTF8.

[kaitlyn]

Le fichier doit être enregistré au format Windows 1252, au pire enregistre-le avec notepad, encodage ANSI.
Voici le code modifié pour t'obliger à enregistrer ton fichier source dans le bon encodage, plus un extra.
Il n'est pas impossible que le terminal intégré à eclipse pose problème. Le mieux étant de faire exécuter l'application dans une console native.

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
81
82
83
84
85
86
87
#undef NDEBUG
#include <cassert>
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <clocale>
#include <cctype>
#include <iostream>
 
 
void set_locale_and_code_page()
{
    //Vérification que le fichier source est bien enregistré au format Windows-1252
    #if __cpp_static_assert
    static_assert(('€' == '\x80'), "this source code is not encoded in Windows-1252.");
    #else
    assert(('€' == '\x80') && "this source code is not encoded in Windows-1252.");
    #endif
 
    //Activation de la prise en charge du code page 1252 et de l'affichage correct des lettres dans la console.
    const char* app_locale= "something's going wrong!";
    if ( ! (app_locale= std::setlocale(LC_CTYPE, ".1252")))
    if ( ! (app_locale= std::setlocale(LC_CTYPE, ".CP1252")))
        app_locale= "error!";
    std::cout<< "App locale: "<< app_locale<< '\n';
 
    //Si ce n'est pas suffisant, considérez les appels systèmes suivants :
    //    l'api windows SetConsoleOutputCP(1252);
    //    ou dans une moindre mesure et à titre exceptionnel std::system("chcp 1252");
    //et les options de compilation suivantes :
    //    -finput-charset=CP1252
    //    et optionnellement -fexec-charset=CP1252
}
 
 
void build_tmp_file(const char* file_name)
{
    //Construction du fichier d'entrée directement depuis l'application.
    char in[]= {"àâAbcdéèêÉfghù"};
    if (FILE* tmp_file= std::fopen(file_name, "w")) {
        std::fwrite(in, sizeof in[0], std::strlen(in), tmp_file);
        std::fclose(tmp_file);
    }
}
 
 
void initialize_app(const char* file_name)
{
    set_locale_and_code_page();
    build_tmp_file(file_name);
}
 
 
int main()
{
    const char* file_name= "tmp_file.txt";
    initialize_app(file_name);
 
    FILE* file= std::fopen(file_name, "r");
    if ( ! file)
        return EXIT_FAILURE;
 
    int ascii_code;
    while ((ascii_code= std::fgetc(file)) != EOF) {
 
        int ascii_code_in= ascii_code;
        char char_in= static_cast<unsigned char>(ascii_code);
 
        if (std::isupper(ascii_code))
            ascii_code= tolower(ascii_code);
 
        char char_out= static_cast<unsigned char>(ascii_code);;
 
        if (ascii_code >= 0xE8 && ascii_code <= 0xEB)
            char_out= 'e';
        else if (ascii_code >= static_cast<unsigned char>('à') && ascii_code <= static_cast<unsigned char>('å'))
            char_out= 'a';
        else if (ascii_code == 0xF9)
            char_out= 'u';
 
        std::cout<< std::hex<< ascii_code_in<< ": "<< char_in<<  " --> "<< char_out<< '\n';
    }
 
    std::fclose(file);
 
    return EXIT_SUCCESS;
}

EDIT:

Il faut t'inspirer des codes que l'on te fournit. Si tu persistes avec genre des do {} while {caractere != EOF} ça ne va pas le faire, dans cet exemple, ton test sur EOF, en plus d'être erroné, arrive beaucoup trop tard.