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.

[picodev]

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

Je ne parle pas de l'édition des liens.
Rendre le pointeur constant ne sert à rien sinon à ne pas pouvoir le modifier dans le corps de la fonction. Et même s'il était modifié rien ne serait visible de l'extérieur.

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.

D'une fausse manipulation ? de quelle sorte ? c'est un paramètre. Je ne parle pas de bugs, je parle bien de fausse manipulation qui aurait un impact à l'extérieur de la fonction en ne parlant que du paramètre. Je ne vois pas ce que le const peut apporter, si ce n'est des warnings si on a justement besoin de le manipuler et qu'on le transtype.

[ternel]

Nous sommes bien d'accord.
Ce const n'est que rarement intéressant et n'a aucun effet visible de l'extérieur, au point justement que le compilateur lui-même n'en tient pas compte dans le reste du code.

[picodev]

Il en tient compte car il t'interdit de le modifier directement ensuite dans le corps de la fonction.

Tu dis rarement intéressant, dans quels cas l'est-il ?

[Pyramidev]

dans quels cas l'est-il ?

Quand on récupère du code d'un autre développeur qui contient une fonction horrible de 10 kilomètres et que, au 9e kilomètre, avant de modifier un certain bout de code, on a envie d'être sûr qu'un certain paramètre passé par valeur a toujours la même valeur qu'au début de la fonction, il est peut être intéressant d'essayer d'ajouter un const dans le type du paramètre. Cela peut permettre d'éviter de lire les 9 kilomètres de code.

[picodev]

Quand on récupère du code d'un autre développeur qui contient une fonction horrible de 10 kilomètres et que, au 9e kilomètre, avant de modifier un certain bout de code, on a envie d'être sûr qu'un certain paramètre passé par valeur a toujours la même valeur qu'au début de la fonction, il est peut être intéressant d'essayer d'ajouter un const dans le type du paramètre. Cela peut permettre d'éviter de lire les 9 kilomètres de code.

Il est plus rapide et certain d'utiliser un debuger en plaçant cette variable en watch mode. Un const en C n'a jamais permit de certifier qu'une valeur n'est pas modifiée.

Code :

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

1
2
3
4
5
void foo(const int a) {
  int *ptr=(int *)&a;
  *ptr=!a;
  printf("a=%d\n", a);
}

Il est intéressant de voir les différences entre une compil clang et une compil gcc sur un bout de code comme celui-ci d'ailleurs
Si le code fait 9km de long j'imagine qu'on peut s'attendre au pire. Ici rien n'est détecté à la compilation mais au debug si.

[Pyramidev]

C'est vrai.
Cela dit, le débogeur ne vérifie que le contexte dans lequel la fonction est exécutée.
Le compilateur, par contre, vérifie dans tous les cas, bien que la vérification de la const-correctness peut être annulée par des cast.

[picodev]

Le gros problème avec const est la différence entre ce qu'il fait, ce qu'on croit qu'il fait et ce qu'on aimerait qu'il fasse.
Cette confusion est à l'origine de cette fin de discussion je suppose.

[ternel]

Tout à fait.
Encore qu'il suffise d'apprendre ce qu'il fait précisément.

[picodev]

Ça c'est simple, la norme le résume en une phrase au paragraphe 6 de la section 6.7.3 :

If an attempt is made to modify an object defined with a const-qualified type through use of an lvalue with non-const-qualified type, the behavior is undefined.

L'implémentation n'a pas à s'assurer qu'une variable de type qualifié const ne soit jamais modifié. Cependant si on le fait on s'expose à un comportement indéfini. En gros pour faire simple, const ne signifie rien de plus que «je m'engage en tant que développeur à ne jamais modifier la valeur d'une variable dont le type est qualifié de const sauf éventuellement pour l'initialiser. Dans le cas contraire je rompt le contrat et je sais à quoi je m'expose. Je sais que const ne qualifie pas une variable pour la rendre constante mais qualifie un type. D'ailleurs je sais que la norme définit ce que sont des constantes et les variables de type qualifié de const n'en sont pas.»

Et je passe la merdouille que ça provoque et dans l'esprit des novices et dans la résolution de compatibilité de type. Il y a des propositions pour avoir «de vraies constantes non littérales» pour la prochaine norme, comme par exemple utiliser le mot clé register de concert avec const mais bon faut attendre de voir ce que ça va donner.

[ternel]

Pour le coup, le UB est quand on essaye de modifier une valeur définie constante, en passant par une lvalue non constante.
C'est à dire quand on fait ce genre de choses:

Code :

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

1
2
int const a = 2;
*( (int*) &a ) = 3;

mais le mot clé const signifie justement que a n'est pas modifiable sans passer par un cast explicite, mais qui amène dans un UB.

[picodev]

Donc en sachant ce que const fait réellement et pourquoi on l'a (malheureusement ?) introduit (de cette manière ?) dans le norme, tu comprends aisément qu'un paramètre de type qualifié de const n'est que du bruit, autant pour le lecteur que pour le compilateur.
C'est réellement la fausse bonne idée de C99.

[ternel]

Du bruit pour l'utilisateur, totalement.
C'est même la raison pour laquelle une déclaration de fonction sans le const est reliée à une implémentation avec.

Ainsi, nul besoin de const dans les .h, et si le développeur estime cela utile, un const peut être ajouté au .c.

[picodev]

Dès le départ c'est ce que je demande : «utile à quoi ?».
Si c'est juste pour dire qu'on peut le faire et que ça peut tranquilliser l'esprit d'un dèv qui ne connaît pas trop le C soit. Mais ça ne va pas être utile à quoi que ce soit d'autre.