Discussion :

[cirdan_elf]

Bonjour,

j'ai écrit une fonction qui prend en paramètre un pointeur constant, parce que je veux dire que cette fonction ne modifie pas le contenu du pointeur :

Code :

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

void foo(const char *pointeur);

Le problème c'est qu'à l'intérieur de cette fonction, j'utilise une autre fonction qui ne modifie pas non plus le contenu, mais dont le prototype ne contient pas 'const'. Je suis obligé de faire un cast :

void bar(char *pointeur);

Code :

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

1
2
3
4
void foo(const char *pointeur)
{
    bar((char *) pointeur);
}

Est-ce que c'est bon ?

Par contre, si jamais bar() a un bug et modifie quand même le contenu du pointeur, il se passe quoi ? Ca peut planter non ?

[Le Mérovingien]

Bonjour,

Le problème que tu évoques est fréquent, et je ne suis pas sur de t'apporter la réponse parfaite, cependant, voici quelques considérations :

Tout d'abord, les informations que je donne fonctionnent avec gcc 4.2.4 pour linux.

1) Le 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
#include <stdio.h>
#include <stdlib.h>
 
void bar(char *p)
{
  printf("%s\n",p);
}
 
void foo(const char *pointeur)
{
  bar(pointeur);
}
 
int main(void)
{
  foo("toto");
 
  return 0;
}

compile, fonctionne, mais génère un warning, c'est logique.

2) Le 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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
void bar(char *p)
{
  p[0] = 'b';
  printf("%s\n",p);
}
 
void foo(const char *pointeur)
{
  bar(pointeur);
}
 
int main(void)
{
  char *s = strdup("toto");
  foo(s);
  free(s);
 
  return 0;
}

compile, génère un warning, et fonctionne, c'est logique, puisque le pointeur passé à bar est en réalité un pointeur sur une zone du tas, qui peut être modifiée. Le comportement serait le même si p pointait sur une zone de la pile.

3) Le 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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
void bar(char *p)
{
  p[0] = 'b';
  printf("%s\n",p);
}
 
void foo(const char *pointeur)
{
  bar(pointeur);
}
 
int main(void)
{
  foo("toto");
 
  return 0;
}

compile, génère un warning et plante (erreur de segmentation), c'est logique car dans bar p pointe vers une chaine constante, qui fait partie des constantes du programme (elle est écrite telle quelle dans l'exécutable, on peut le voir avec un grep), et le code du programme n'est pas modifiable.

Le fait de rajouter le cast explicite supprime le warning, mais pas le problème, évidemment .

Pour moi, la meilleure solution est de recopier la chaine constante dans foo, passer la copie à bar, et la supprimer ensuite, comme ceci :

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 <stdlib.h>
#include <string.h>
 
void bar(char *p)
{
  p[0] = 'b';
  printf("%s\n",p);
}
 
void foo(const char *pointeur)
{
  char *s = strdup(pointeur);
  bar(s);
  free(s);
}
 
int main(void)
{
  foo("toto");
 
  return 0;
}

Il n'y a plus aucun soucis avec ce code. Cependant, il existe peut être de meilleures solutions.

J'ajoute que ce qui n'est qu'un warning avec gcc devient une erreur avec g++, mais le cast arrive encore à masquer le problème.

[Médinoc]

La façon "idéale", c'est de faire une copie, car en effet, si la fonction a un bug et modifie quand même la chaîne, ça peut causer un plantage (par exemple, il y a une fonction de Windows qui est mal déclarée et qui plante si on lui passe une chaîne littérale).

Mais si tu es sûr de la fonction, le cast dans le wrappeur peut être mieux. Ça dépend si les performances sont importantes sur cette partie-là du code...

[cirdan_elf]

Le problème c'est que je peux pas faire d'allocation dynamique.
Il faudrait utiliser un buffer satique suffisamment grand pour faire une recopie, mais là encore c'est trop coûteux.

Si j'ai mis un 'const', ce n'est pas pour des questions de performance, mais pour donner une indication.
C'était peut être une mauvaise idée ?
Pour faire une indication, peut être qu'il vaut mieux tout simplement faire un commentaire ?
C'est quoi l'usage dans ces cas là ?

[Médinoc]

Comme je dis, si tu es certain que la fonction n'essaiera pas de modifier la chaîne (ce qui signifie tout simplement qu'elle est mal déclarée), le cast est la meilleure chose à faire.

Si tu n'en es pas certain, tu supprimes le const de ton prototype, et tu indiques dans l'aide de ta fonction qu'il n'est pas garanti qu'elle accepte une chaîne constante.