Discussion :

[unknoweb]

bonjour,

je bloque pour remplacer une chaîne entre les guillemets j'arrive a lire le fichier a trouver le premier guillemets a trouver la taille de la chaîne et a l'afficher mais je n'arrive pas a la remplacer

voici le fichier txt

Code :

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

1
2
3
4
SELECT_BUTTON = 1
DISABLE_AUTOUPDATE = false
LANGUAGE = 0
THEME_NAME = "Default"

et mon 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
void saveThemeName(){
 
	char buffer[50];
        int ret;
	ret = copyFiles(fichier_source, fichier_destination);
 
	FILE* f2 = fopen(fichier_destination, "r+");
 
	if (f2 == NULL){
		if (f2 != NULL) fclose(f2);
 
	} else {
		while (fscanf(f2, "%s", buffer) != EOF) { 
 
			if( strstr(&buffer[0], "\"") ){
			  //fseek(f2, - sizeof(char)*71 , SEEK_CUR);
 
			  const char *p1 = strstr(&buffer[0], "\"")+1;
			  const char *p2 = strstr(p1, "\"");
			  size_t len = p2-p1;
			  char *res = (char*)malloc(sizeof(char)*(len+1)); 
			  strncpy(res, p1, len);
			  res[len] = '\0';
                          printf("%s", res);
			}
 
		}
		fclose(f2);
	}	
 
}

Merci pour votre aide

[ternel]

On ne peut pas modifier un fichier aussi facilement.
On ne peut qu'écrire à un endroit donné.

Donc, tu as deux situations possibles: soit ta chaine de remplacement fait exactement le même nombre d'octets que la chaine remplacée, soit ce n'est pas le cas.

Si par hasard tu as cette chance immense d'avoir la même taille, il suffit de te placer au début de la chaine, et de remplacer les quelques octets impliqués.
Sinon, la seule solution (qui s'avère donc être la solution générale) est de:

1. copier le début du fichier jusqu'à ta chaine à remplacer
2. avancer dans le fichier initial jusqu'à la fin de la chaine à remplacer
3. écrire dans le fichier final la chaine de remplacement
4. copier le reste du fichier initial

[unknoweb]

Malheureusement non la taille de la chaîne sera variable la chaîne fix c'est réglé en 5mn j'ai chercher un équivalent du regex que j'utilise en java ou C# j'ai rien trouvé car avec le regex peut importe la taille de la chaîne il récupére ce qui est entre les guillemet puis il remplace.

ok c'est ce que je pensé car toute les recherches que j'ai faite la plupart remplace le buffer (chaîne) puis copie le reste. dommage qu'il n'y a pas plus simple en C

ce que tu me dis c'est un peut de ce style ??

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
char * replace(
    char const * const original, 
    char const * const pattern, 
    char const * const replacement
) {
  size_t const replen = strlen(replacement);
  size_t const patlen = strlen(pattern);
  size_t const orilen = strlen(original);
 
  size_t patcnt = 0;
  const char * oriptr;
  const char * patloc;
 
  // find how many times the pattern occurs in the original string
  for (oriptr = original; patloc = strstr(oriptr, pattern); oriptr = patloc + patlen)
  {
    patcnt++;
  }
 
  {
    // allocate memory for the new string
    size_t const retlen = orilen + patcnt * (replen - patlen);
    char * const returned = (char *) malloc( sizeof(char) * (retlen + 1) );
 
    if (returned != NULL)
    {
      // copy the original string, 
      // replacing all the instances of the pattern
      char * retptr = returned;
      for (oriptr = original; patloc = strstr(oriptr, pattern); oriptr = patloc + patlen)
      {
        size_t const skplen = patloc - oriptr;
        // copy the section until the occurence of the pattern
        strncpy(retptr, oriptr, skplen);
        retptr += skplen;
        // copy the replacement 
        strncpy(retptr, replacement, replen);
        retptr += replen;
      }
      // copy the rest of the string.
      strcpy(retptr, oriptr);
    }
    return returned;
  }
}

[ternel]

Pour mes souvenir de C, ca m'a l'air pas mal du tout.

[Matt_Houston]

Je suis d'accord avec ternel, le code est lisible et plutôt élégant. En revanche il y a un gros souci avec ta fonction ligne 22 : size_t const retlen = orilen + patcnt * (replen - patlen); . Je te laisse y réfléchir partant de ce constat : size_t est un type entier non signé.

Et les deux remarques habituelles :

• ne caste pas la valeur de retour de malloc ;
• sizeof(char) vaut toujours 1.

dommage qu'il n'y a pas plus simple en C

C'est encore et toujours la force et la faiblesse du C : il t'expose tout ce qui serait automatisé par un outil de plus haut niveau. Pour un langage qui prétend tout faire, regarde du côté du C++.

[picodev]

Pourquoi des paramètres en char const * const ? En fait la question est surtout pourquoi un pointeur constant ?
Ça ne sert à rien (c'est de toute façon une copie) sauf à ne pas pouvoir modifier le paramètre dans la fonction. C'est comme si tu faisais un :

Code :

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

1
2
3
4
int foo(int const a)
{
  return a+2;
}

Je trouve que ça alourdit inutilement le code pour rien (sans compter que la const correctness en C c'est un peu la merdouille). Ça n'aide pas la lecture ni le compilateur à produire du code plus optimisé.
En revanche ce que tu pourrais ajouter est un restrict si tes paramètres ne pointent jamais vers le même objet.

[ternel]

Notons que l'aspect "const" de la variable déclarée en argument n'entre pas dans les problématique d'édition des liens.

En l'occurence int f(int) et int f(int const) sont la même fonction.

Définir un paramètre comme constant dans la définition de la fonction (par opposé à sa déclaration) peut servir à protéger d'une fausse manipulation.
Cela dit, une fonction étant toujours courte (sinon, il faudrait la diviser), de telles erreurs sont assez difficiles à commettre.