Remplacement de caractères

**sulli7086** · 26/04/2010, 06h46

Bonjour à tous

Voilà, je vous explique le problème:

Je souhaiterais que mon interface, dès qu'elle voit le mot "H5" dans le fichier C, remplace ce mot par "H11 "dans le fichier D

Voici le fichier C.txt :

(SQCE 9 O T5 FRAISAGE GORGE INTERIEURE DIAM 6 L7.25)
G54G806T5X0Y0Z15B90H5C0D5S2000P[#610]R0
M8
F300
M70(DESERRAGE AXE B)
M72(DESERRAGE AXE C)
()

et moi, grâce à mon code, j’obtiens ceci :

(SQCE 9 O T5 FRAISAGE GORGE INTERIEURE DIAM 6 L7.25)
G54G806T5X0Y0Z15B90H110D5S2000P[#610]R0
M8
F300
M70(DESERRAGE AXE B)
M72(DESERRAGE AXE C)
()

Comme vous pouvez le constater, le dernier "1" du "H11" remplace le "C" dans la ligne.

Voici donc ce que je souhaiterais obtenir dans le fichier D.txt (je voudrais garder le "C") :

(SQCE 9 O T5 FRAISAGE GORGE INTERIEURE DIAM 6 L7.25)
G54G806T5X0Y0Z15B90H11C0D5S2000P[#610]R0
M8
F300
M70(DESERRAGE AXE B)
M72(DESERRAGE AXE C)
()

Je travail avec code::blocks et son langage C.

Vous trouverez en pièce jointe mon code source (Interface GO.c) et au cas où, vous trouverez également le fichier C à traiter (Fichier C.txt) et ce que je souhaiterais obtenir dans mon fichier D (Fichier D.txt).

Merci d'avance pour votre aide.

**jeroman** · 26/04/2010, 07h27

Salut

Code :

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

1
2
3
4
5
6
7
8
for (i = 0 ; i < (z - 2) ; i++)
{
	if (tableau[i] == 'H' && tableau[i+1] == '5' )
	{
		tableau [i+1] = '1' ;
		tableau [i+2] = '1' ;
	}
}

C'est normal que cela ne fonctionne pas. Dès qu'on a trouvé "H5", on écrase les deux caractères qui suivent H. Du coup, si on a "H5C0", cela se transforme en "H110".

Comme tu es obligé d'insérer un caractère en plus à chaque fois, il faut décaler la chaine d'un cran vers la droite à partir du caractère suivant H, puis écraser les deux caractères suivant H par "11".
Si on a "(...)90H5C0(...)", on décale ce qui suit H d'un cran à droite, ce qui donne : "(...)90H55C0(...)". Puis on écrase les deux caractères qui suivent H par "11", ce qui donne : "(...)90H11C0(...)".
Mais il faut bien sûr être certain que ton tableau soit suffisamment gros pour qu'il n'y ait pas de débordement sinon y a un risque de crash. Une alternative est d'allouer de la mémoire dynamique, et de l'agrandir au fur et à mesure si nécessaire.

Attention, ici :

Code :

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

1
2
3
4
5
6
7
8
9
do
{
	tableau[z] = fgetc( fichier_A);
	if (tableau[z] == 24) {
		printf("Aïe !!! Il va falloir trouver un autre caractère de remplacement !");
		exit(2);
	}
	z++;
} while ( tableau[z-1] != EOF);

Tu compares un char avec la constante EOF !

**sulli7086** · 26/04/2010, 08h07

D'accord, mais sachant que je suis débutant en programmation C, aurais tu directement la solution à mon problème car j'ai déjà passé beaucoup de temps sans aboutir à mon problème.

Merci d'avance.

**ironzorg** · 26/04/2010, 08h55

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
int             rep(char *s)
{
  char          *b;
 
  b = 0;
  while (*s)
    {
      if (*s == 'H' && *(s + 1) == '5')
        {
          *(s + 1) = '1';
          if (!(b = malloc(strlen(s + 1) * sizeof(char))))
            return (0);
          strcpy(b, s + 2);
          *(s + 2) = '1';
          strcpy(s + 3, b);
          free(b);
        }
      ++s;
    }
 
  return (1);
}
 
int main()
{
  char buffer[512];
 
  memset(buffer, 0, 512);
  strcat(buffer, "G54G806T5X0Y0Z15B90H5C0D5S2000P[#610]R0");
  if (!rep(buffer))
    return (1);
 
  printf("%s\b", buffer);
 
  return (0);
}

J'ai fait ce code rapidement, il remplace la premiere occurence de "H5" par "H11".

A toi de le comprendre et de le modifier pour remplacer toutes les occurences

PS: Je ne sais pas si le code fonctionne, j'ai fait ca a la va vite.

**sulli7086** · 26/04/2010, 09h54

Je suis désolé Ironzorg mais ca n'a pas l'air de fonctionner. J'ai essayé en collant ton code dans le mien et j'ai aussi essayer de créer un nouveau code en ajoutant que le tien mais idem, ca ne fonctionne également pas...

Help me please!!!!

**jeroman** · 26/04/2010, 10h16

Un exemple, à adapter selon tes besoins :

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
#include <stdio.h>
#include <string.h>
 
int main (void)
{
	char chaine[1024] = "G54G806T5X0Y0Z15B90H5C0D5S2000P[#610]R0" ;
	char * occurence ;
 
	printf ( "Chaine d'origine : %s\n" , chaine ) ;
 
	occurence = chaine ;
	while ( ( occurence = strstr ( occurence , "H5" ) ) != NULL )
	{
		memmove ( occurence + 1 , occurence , strlen ( occurence ) + 1 ) ;
		* ( occurence + 1 ) = '1' ;
		* ( occurence + 2 ) = '1' ;
		occurence = occurence + 3 ;
	}
 
	printf ( "Chaine modifiee  : %s\n" , chaine ) ;
 
	return 0;
}

**sulli7086** · 26/04/2010, 11h54

Dis jeroman, saurais-tu l'adapter à ce code

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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
#define TAILLE_MAX  100000            // la taille maximum d'un fichier ( aproximatif, si tu doit faire ca avec un + gros prgm, agrandit et tout le reste te suivra)
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
 
//La fonction remplace effectue un remplacement, dans une chaine, d'une sous-chaine par une autre.
//Il faut que la sous-chaine de remplacement soit de même longueur que la sous-chaine à remplacer.
//Les tailles des chaînes doivent être indiqué (cela évite d'avoir à inclure string.h)
void remplace(char* chaine, const int tailleChaine, const char* from, const char* to, const int tailleRemplacement) {
 
	int i = 0, j = 0, ok = 0;
 
	while (i < tailleChaine - tailleRemplacement) {
 
		if (chaine[i] == from[0]) {
 
			ok = 1;
 
			j = 0;
			while (ok && j < tailleRemplacement) {
				if (chaine[i+j] != from[j]) {
					ok = 0;
				}
				j++;
			}
 
			if (ok) {
				for (j = 0; j < tailleRemplacement; j++) {
					chaine[i+j] = to[j];
				}
				i += tailleRemplacement - 1;
			}
		}
		i++;
	}
 
}
 
void clean(const char *buffer, FILE *fp)
{
       char *p = strchr(buffer,'\n');
       if (p != NULL)
              *p = 0;
       else
       {
              int c;
              while ((c = fgetc(fp)) != '\n' && c != EOF);
       }
}
 
int main(int argc, char* argv[])
{
	char tableau[TAILLE_MAX] = {0};      // voila le tableau initialisé !
	char sRemplacement[25] = {0};
	int i =0,z =0 ,y = 0;      // des variables (je mets souvent des noms de variable completement stupides lors que j'y stock un nombre
	char nom_fichier_A[255] = {0};
	char nom_fichier_B[255] = {0};
	FILE* fichier_A = NULL;        // On a 2 fichiers a ouvrir / créer
	FILE* fichier_B = NULL;
	        //  il faut mettre un tiret bas et pas un espace (Google est ton ami si tu veut vraiment garder ton espace dans ton nom fichier)...
 
	if (argc > 1)
	{
		for (i = 1; i < argc; i++)
		{
			//le premier argument donne le nom de fichier_A
			//le second, le nom de fichier_B
 
			//a moins qu'on est reçu un argument -h, --help, help, -?, /?, /h, /help
			if (argv[i][0] == '-' || argv[i][0] == '/' || argv[i][0] == 'h')
			{
				if (strcmp(argv[i], "-h") 		== 0 ||
					strcmp(argv[i], "--help") 	== 0 ||
					strcmp(argv[i], "help") 	== 0 ||
					strcmp(argv[i], "-?") 		== 0 ||
					strcmp(argv[i], "/?") 		== 0 ||
					strcmp(argv[i], "/h") 		== 0 ||
					strcmp(argv[i], "/help") 	== 0 )
				{
					printf ("\nUsage: Interface.exe [source [destination]] [help]\n\n    source:      nom du fichier source\n    destination: nom du fichier de destination\n    help:        affiche ce message d'aide (-h, /h, -?, /?, /help, --help)\n\nExemple: Interface.exe WM408.txt WM508.txt\n         Interface.exe WM408.txt\n         Interface.exe\n\n");
					exit(0);
				}
			}
 
			if (strcmp(nom_fichier_A, "") == 0) {
				strcpy(nom_fichier_A, argv[i]);
			} else if (strcmp(nom_fichier_B, "") == 0) {
				strcpy(nom_fichier_B, argv[i]);
			}
 
		}
	}
 
	//Ok, on a récupéré nos arguments.
	//Maintenant, on demande à l'user les infos éventuellement manquantes
	if (strcmp(nom_fichier_A, "") == 0) {
		//On a besoin d'un nom_fichier_A
		printf("Veuillez indiquer le nom du fichier source: ");
		fgets(nom_fichier_A, sizeof(nom_fichier_A), stdin);
		clean(nom_fichier_A, stdin);
	}
	printf("Nom du fichier source: %s\n", nom_fichier_A);
 
	if (strcmp(nom_fichier_B, "") == 0) {
		//On a besoin d'un nom_fichier_A
		printf("Veuillez indiquer le nom du fichier de destination: ");
		fgets(nom_fichier_B, sizeof(nom_fichier_B), stdin);
		clean(nom_fichier_B, stdin);
	}
	printf("Nom du fichier de destination: %s\n", nom_fichier_B);
 
	//On ouvre les fichiers
	printf("\nOuverture des fichiers:\n  Fichier source: ........... ");
	fichier_A = fopen(nom_fichier_A, "r");
	if (!fichier_A) {
		printf("echec\n\nLe fichier '%s' est inexistant ou inaccessible, veuillez verifier le nom du fichier avant de continuer.\n", nom_fichier_A);
		exit(1);
	} else {
		printf("ok\n  Fichier de destination: ... ");
	}
 
	fichier_B = fopen(nom_fichier_B, "w");
	if (!fichier_B) {
		printf("echec\n\nImpossible d'ouvrir ou de creer le fichier '%s', veuillez verifier que le disque n'est pas plein ou proteger en ecriture.\n", nom_fichier_B);
		exit(1);
	} else {
		printf("ok\n\n");
	}
 
	printf("Traitement en cours, veuillez patienter ... ");
 
	//Chargement du fichier dans tableau
	do
	{
		tableau[z] = fgetc( fichier_A);                     // On lit le caractère qu'on stocke dans tableau[z]
		if (tableau[z] == 24) {
			printf("Aïe !!! Il va falloir trouver un autre caractère de remplacement !");
			exit(2);
		}
		z++;                                                           // le prochain caractère s'écrira dans la prochaine case du tableau
	} while ( tableau[z-1] != EOF );                                                                       // On aurait pu lire ligne par ligne avec fgets mais on aurait pas pu savoir le nombre de caractère du texte.( il aurait du faire une boucle avec tableau[], alors je préfère remplacer un s par un c :D)
 
	z--;
 
	//Remplacements :
	//Pour ne pas être embêter avec l'ordre des remplacements,
	//Je ne remplace pas directement Pxx par Pyy. Je vais
	//bien remplacer xx par yy, mais P sera remplacé par
	//un caractère qui ne devrait, a priori, jamais être présent
	//dans tableau.
	//Le caractère SUB (subsititu, code = 26) se prêtera très bien pour ça
	sprintf(sRemplacement, "%c%s", 24, "16"); remplace(tableau, z, "P01", sRemplacement, 3);
	sprintf(sRemplacement, "%c%s", 24, "17"); remplace(tableau, z, "P02", sRemplacement, 3);
	sprintf(sRemplacement, "%c%s", 24, "18"); remplace(tableau, z, "P03", sRemplacement, 3);
	sprintf(sRemplacement, "%c%s", 24, "19"); remplace(tableau, z, "P04", sRemplacement, 3);
	sprintf(sRemplacement, "%c%s", 24, "20"); remplace(tableau, z, "P05", sRemplacement, 3);
	sprintf(sRemplacement, "%c%s", 24, "21"); remplace(tableau, z, "P06", sRemplacement, 3);
	sprintf(sRemplacement, "%c%s", 24, "22"); remplace(tableau, z, "P07", sRemplacement, 3);
	sprintf(sRemplacement, "%c%s", 24, "23"); remplace(tableau, z, "P08", sRemplacement, 3);
	sprintf(sRemplacement, "%c%s", 24, "24"); remplace(tableau, z, "P09", sRemplacement, 3);
	sprintf(sRemplacement, "%c%s", 24, "25"); remplace(tableau, z, "P10", sRemplacement, 3);
	sprintf(sRemplacement, "%c%s", 24, "26"); remplace(tableau, z, "P11", sRemplacement, 3);
	sprintf(sRemplacement, "%c%s", 24, "27"); remplace(tableau, z, "P12", sRemplacement, 3);
	sprintf(sRemplacement, "%c%s", 24, "07"); remplace(tableau, z, "P13", sRemplacement, 3);
	sprintf(sRemplacement, "%c%s", 24, "12"); remplace(tableau, z, "P14", sRemplacement, 3);
	sprintf(sRemplacement, "%c%s", 24, "04"); remplace(tableau, z, "P15", sRemplacement, 3);
	sprintf(sRemplacement, "%c%s", 24, "10"); remplace(tableau, z, "P16", sRemplacement, 3);
	sprintf(sRemplacement, "%c%s", 24, "11"); remplace(tableau, z, "P17", sRemplacement, 3);
	sprintf(sRemplacement, "%c%s", 24, "06"); remplace(tableau, z, "P18", sRemplacement, 3);
	sprintf(sRemplacement, "%c%s", 24, "08"); remplace(tableau, z, "P19", sRemplacement, 3);
	sprintf(sRemplacement, "%c%s", 24, "01"); remplace(tableau, z, "P20", sRemplacement, 3);
	sprintf(sRemplacement, "%c%s", 24, "02"); remplace(tableau, z, "P21", sRemplacement, 3);
	sprintf(sRemplacement, "%c%s", 24, "05"); remplace(tableau, z, "P22", sRemplacement, 3);
	sprintf(sRemplacement, "%c%s", 24, "03"); remplace(tableau, z, "P23", sRemplacement, 3);
	sprintf(sRemplacement, "%c%s", 24, "09"); remplace(tableau, z, "P24", sRemplacement, 3);
 
	//Voilà, tous les remplacements ont été effectués. Il ne nous reste plus qu'à
	//remplacé notre caractère SUB par P pour retrouver notre chaîne correcte
	sprintf(sRemplacement, "%c", 24);
	remplace(tableau, z, sRemplacement, "P", 1);
 
    sprintf(sRemplacement, "TOOL POSITION NUMBER %c %s", 24, "25"); remplace(tableau, z, "TOOL POSITION NUMBER : 10", sRemplacement, 25);
	sprintf(sRemplacement, "TOOL POSITION NUMBER %c %s", 24, "26"); remplace(tableau, z, "TOOL POSITION NUMBER : 11", sRemplacement, 25);
	sprintf(sRemplacement, "TOOL POSITION NUMBER %c %s", 24, "27"); remplace(tableau, z, "TOOL POSITION NUMBER : 12", sRemplacement, 25);
	sprintf(sRemplacement, "TOOL POSITION NUMBER %c %s", 24, "7 "); remplace(tableau, z, "TOOL POSITION NUMBER : 13", sRemplacement, 25);
	sprintf(sRemplacement, "TOOL POSITION NUMBER %c %s", 24, "12"); remplace(tableau, z, "TOOL POSITION NUMBER : 14", sRemplacement, 25);
	sprintf(sRemplacement, "TOOL POSITION NUMBER %c %s", 24, "4 "); remplace(tableau, z, "TOOL POSITION NUMBER : 15", sRemplacement, 25);
	sprintf(sRemplacement, "TOOL POSITION NUMBER %c %s", 24, "10"); remplace(tableau, z, "TOOL POSITION NUMBER : 16", sRemplacement, 25);
	sprintf(sRemplacement, "TOOL POSITION NUMBER %c %s", 24, "11"); remplace(tableau, z, "TOOL POSITION NUMBER : 17", sRemplacement, 25);
	sprintf(sRemplacement, "TOOL POSITION NUMBER %c %s", 24, "6 "); remplace(tableau, z, "TOOL POSITION NUMBER : 18", sRemplacement, 25);
	sprintf(sRemplacement, "TOOL POSITION NUMBER %c %s", 24, "8 "); remplace(tableau, z, "TOOL POSITION NUMBER : 19", sRemplacement, 25);
	sprintf(sRemplacement, "TOOL POSITION NUMBER %c %s", 24, "1 "); remplace(tableau, z, "TOOL POSITION NUMBER : 20", sRemplacement, 25);
	sprintf(sRemplacement, "TOOL POSITION NUMBER %c %s", 24, "2 "); remplace(tableau, z, "TOOL POSITION NUMBER : 21", sRemplacement, 25);
	sprintf(sRemplacement, "TOOL POSITION NUMBER %c %s", 24, "5 "); remplace(tableau, z, "TOOL POSITION NUMBER : 22", sRemplacement, 25);
	sprintf(sRemplacement, "TOOL POSITION NUMBER %c %s", 24, "3 "); remplace(tableau, z, "TOOL POSITION NUMBER : 23", sRemplacement, 25);
	sprintf(sRemplacement, "TOOL POSITION NUMBER %c %s", 24, "9 "); remplace(tableau, z, "TOOL POSITION NUMBER : 24", sRemplacement, 25);
    sprintf(sRemplacement, "TOOL POSITION NUMBER %c%s", 24, "16"); remplace(tableau, z, "TOOL POSITION NUMBER : 1", sRemplacement, 24);
	sprintf(sRemplacement, "TOOL POSITION NUMBER %c%s", 24, "17"); remplace(tableau, z, "TOOL POSITION NUMBER : 2", sRemplacement, 24);
	sprintf(sRemplacement, "TOOL POSITION NUMBER %c%s", 24, "18"); remplace(tableau, z, "TOOL POSITION NUMBER : 3", sRemplacement, 24);
	sprintf(sRemplacement, "TOOL POSITION NUMBER %c%s", 24, "19"); remplace(tableau, z, "TOOL POSITION NUMBER : 4", sRemplacement, 24);
	sprintf(sRemplacement, "TOOL POSITION NUMBER %c%s", 24, "20"); remplace(tableau, z, "TOOL POSITION NUMBER : 5", sRemplacement, 24);
	sprintf(sRemplacement, "TOOL POSITION NUMBER %c%s", 24, "21"); remplace(tableau, z, "TOOL POSITION NUMBER : 6", sRemplacement, 24);
	sprintf(sRemplacement, "TOOL POSITION NUMBER %c%s", 24, "22"); remplace(tableau, z, "TOOL POSITION NUMBER : 7", sRemplacement, 24);
	sprintf(sRemplacement, "TOOL POSITION NUMBER %c%s", 24, "23"); remplace(tableau, z, "TOOL POSITION NUMBER : 8", sRemplacement, 24);
	sprintf(sRemplacement, "TOOL POSITION NUMBER %c%s", 24, "24"); remplace(tableau, z, "TOOL POSITION NUMBER : 9", sRemplacement, 24);
 
 
 
	sprintf(sRemplacement, "%c", 24);
	remplace(tableau, z, sRemplacement, ":", 1);
 
	//Remplacements :
	//Pour ne pas être embêter avec l'ordre des remplacements,
	//Je ne remplace pas directement Pxx par Pyy. Je vais
	//bien remplacer xx par yy, mais P sera remplacé par
	//un caractère qui ne devrait, a priori, jamais être présent
	//dans tableau.
	//Le caractère SUB (subsititu, code = 22) se prêtera très bien pour ça
	sprintf(sRemplacement, "%c%s", 24, "16"); remplace(tableau, z, "T01", sRemplacement, 3);
	sprintf(sRemplacement, "%c%s", 24, "17"); remplace(tableau, z, "T02", sRemplacement, 3);
	sprintf(sRemplacement, "%c%s", 24, "18"); remplace(tableau, z, "T03", sRemplacement, 3);
	sprintf(sRemplacement, "%c%s", 24, "19"); remplace(tableau, z, "T04", sRemplacement, 3);
	sprintf(sRemplacement, "%c%s", 24, "20"); remplace(tableau, z, "T05", sRemplacement, 3);
	sprintf(sRemplacement, "%c%s", 24, "21"); remplace(tableau, z, "T06", sRemplacement, 3);
	sprintf(sRemplacement, "%c%s", 24, "22"); remplace(tableau, z, "T07", sRemplacement, 3);
	sprintf(sRemplacement, "%c%s", 24, "23"); remplace(tableau, z, "T08", sRemplacement, 3);
	sprintf(sRemplacement, "%c%s", 24, "24"); remplace(tableau, z, "T09", sRemplacement, 3);
	sprintf(sRemplacement, "%c%s", 24, "25"); remplace(tableau, z, "T10", sRemplacement, 3);
	sprintf(sRemplacement, "%c%s", 24, "26"); remplace(tableau, z, "T11", sRemplacement, 3);
	sprintf(sRemplacement, "%c%s", 24, "27"); remplace(tableau, z, "T12", sRemplacement, 3);
	sprintf(sRemplacement, "%c%s", 24, "07"); remplace(tableau, z, "T13", sRemplacement, 3);
	sprintf(sRemplacement, "%c%s", 24, "12"); remplace(tableau, z, "T14", sRemplacement, 3);
	sprintf(sRemplacement, "%c%s", 24, "04"); remplace(tableau, z, "T15", sRemplacement, 3);
	sprintf(sRemplacement, "%c%s", 24, "10"); remplace(tableau, z, "T16", sRemplacement, 3);
	sprintf(sRemplacement, "%c%s", 24, "11"); remplace(tableau, z, "T17", sRemplacement, 3);
	sprintf(sRemplacement, "%c%s", 24, "06"); remplace(tableau, z, "T18", sRemplacement, 3);
	sprintf(sRemplacement, "%c%s", 24, "08"); remplace(tableau, z, "T19", sRemplacement, 3);
	sprintf(sRemplacement, "%c%s", 24, "01"); remplace(tableau, z, "T20", sRemplacement, 3);
	sprintf(sRemplacement, "%c%s", 24, "02"); remplace(tableau, z, "T21", sRemplacement, 3);
	sprintf(sRemplacement, "%c%s", 24, "05"); remplace(tableau, z, "T22", sRemplacement, 3);
	sprintf(sRemplacement, "%c%s", 24, "03"); remplace(tableau, z, "T23", sRemplacement, 3);
	sprintf(sRemplacement, "%c%s", 24, "09"); remplace(tableau, z, "T24", sRemplacement, 3);
 
	//Voilà, tous les remplacements ont été effectués. Il ne nous reste plus qu'à
	//remplacé notre caractère SUB par P pour retrouver notre chaîne correcte
	sprintf(sRemplacement, "%c", 24);
	remplace(tableau, z, sRemplacement, "T", 1);
 
 
 
	sprintf(sRemplacement, "%c%s", 24, "M518"); remplace(tableau, z, "WM408", sRemplacement, 5);
 
 
	//Voilà, tous les remplacements ont été effectués. Il ne nous reste plus qu'à
	//remplacé notre caractère SUB par P pour retrouver notre chaîne correcte
	sprintf(sRemplacement, "%c", 24);
	remplace(tableau, z, sRemplacement, "W", 1);
 
	//Maintenant, il ne reste plus qu'à faire la même chose avec d'autres types de remplacements (Txx => Tyy)
	//mais je vais pas me taper tout le boulot :o
 
 
 
 
 
 
 
 
 
 
 
	//On peut ensuite sauvegarder notre fichier dans fichier_B
	sRemplacement[0] = ' ';
	while(y != z)                                                                                      // y est une variable qui définit l'avancement dans le texte et donc dans la chaine donc tans qu'on est pas au bout (z) on continue à lire la chaine
	{
		if (sRemplacement[0] == ':' && tableau[y] != ' ') {
			fputc(' ', fichier_B);
		}
		sRemplacement[0] = tableau[y];
		fputc(tableau[y], fichier_B) ;                                                        // on ecrit le signe de tableau[y] dans le fichier_B
		y++;                                                                                            //et on lira ensuite le caractère suivant [y+1]
	}
 
	fclose(fichier_A);                                                                               // et on ferme les fichiers
	fclose(fichier_B);                                                                               //et on ferme les fichiers ( moi un adepte du copier coller? Jamais! enfin peut etre..)
 
    return 0;                       // c'est la fin
}                                       //c'est la fin ( moi un adepte du copier coller? Jamais! enfin peut etre..)
 
 
// si tu viens si bas dans les contrées perdu  de la programmation c'est peut etre pour savoir le -1:
// si on continue c'est seulement si le caractère qu'on viens de lire ne vaut pas EOF. or , on viens de modifier z (z++;)
//alors le caractère est stocké dans z-1 et plus dans z c'est donc z-1 qu'on veut tester

Parceque j'ai trop du mal. Merci

**Obsidian** · 26/04/2010, 19h32

Je n'ai pas exploré ton code en détails mais y a-t-il une raison particulière à vouloir faire cela en C ? Parce que s'il s'agit simplement de remplacer toutes les occurrences de H5 par H11 dans un fichier, sous Unixoïde, tu fais ça en une commande avec sed -i "/s/H5/H11/g" fichier …

**sulli7086** · 27/04/2010, 04h59

Je ne connais pas Unixoide, qu'est ce que c'est?? Sinon, on peux peut être utiliser cette commande en créant simplemant un .bat (commande dos), mais comment pouvons nous gérer le fichier que l'on souhaite traiter avec cette commande??

**Obsidian** · 27/04/2010, 14h21

« Unixoïdes » est un terme non-officiel pour parler des systèmes d'exploitation apparentés à UNIX. Donc, Linux, Tous les BSD, Solaris, etc.

Toi, visiblement, tu es sous Windows. Tu as beaucoup de fichiers de la sorte à traiter ? Sinon, le premier éditeur de texte te permet de faire un chercher-remplacer qui te fera ça très vite et sans erreur. Toujours dans l'hypothèse, bien sûr, où ton but final est de faire ces remplacements.

Remplacement de caractères

C

Discussions similaires

Partager

Partager