[C++] passage par pointeur [Résolu]

Rappels sur les const

Il ne faut pas confondre un :
const char * (la chaine pointée est constante)
char * const (le pointeur est constant)
const char * const (les deux sont constants)

Pour ton problème...

Je rappelle qu'en C++ tu peux utiliser les référence et encore mieux les std::string :

#include <string>

void f(std::string & s=""){
  s = "essai";
}

Références et pointeurs

A noter que en C et en C++ les paramètres sont des recopies.
- un passage par pointeur va consister à empiler l'adresse de la variable pointée. Cette adresse est recopiée en mémoire mais pas la zone pointée. C'est pour ça qu'en C / C++ on utilise des pointeurs ou des références pour modifier la valeur d'un paramètre (plus exactement la valeur d'une variable pointée par un paramètre).
- on doit au maximum utiliser les références pour que le programme ne perde pas du temps à recopier inutilement des paramètre. Par exemple si je manipule un graphe de grande taille :

void f(graph_t & g); // rapide
void g(graph_t * g); // rapide
void h(graph_t g): // lent !!! car on recopie le graphe à chaque appel de h

Et les const...

Il faut par ailleurs veiller à bien mettre les const (cf début du post) quand ils sont justifiés. Typiquement :

#include <string>
#include <iostream>

void affiche(std::string & s){
  std::cout << s << std::endl;
}

void affiche2(const std::string & s){
  std::cout << s << std::endl;
}

int main(){
  const std::string s = "plop";
  affiche(s); //erreur de compilation car affiche de garantit pas la constance
  affiche2(s); //ok
  return 0;
}

Bonne chance

Il faut signaler que tu veux updater et donc reprendre la nouvelle valeur dans ton main, sinon, comme tu as peu le voir, la valeur dans le main ne changera pas pour ta variable 'ch', mais uniquement en local, dans ta fonction.
En C, je sais qu'il suffit de placer un '&' dans l'appel de fonction, juste devant la variable a reprendre, c'est à dire 'ch' pour toi :

char* ch="abcde";
f(&ch);

Mais je crois qu'en C++ les pointeurs sont gérés différemment non ?
En tout cas ton erreur viens de là, essai ca avec des sorties et ca devrait aller mieux.

Salut.
Merci de ta réponse, mais comme je m'y attendai, si tu met f(&ch) le compilateur te dit qu'il ne peut convertir char** en char*
en effet, si ch est un (char*) &ch est un (char**)
je ne comprend pas. ce problème plus un autre me fait douter de mon compilateur . gcc 3.2.3

J'ai trouvé la solution !
En fait, j'ai mal regarder, la valeur du pointeur est bien passer.
Or un passage par pointeur permet de modifier la valeur pointé, par contre dans f(char* g) g est bien une nouvelle variable prenant comme valeur la valeur du pointeur (l'adresse) par contre si dans la fonction on modifie ce 'g', l'effet ne ce fait pas sentir sur la variable passer en argument. En revanche modifié *g modifiera la valeur pointer par la variable passé à la fonction.
Et en fait, quand on fait char * f="essai", f pointe vers un "const char", il est alors impossible de modifié '*f' (en tout cas c'est la conclusion que je tire de l'erreur de segmentation lorsque je fait f[0]='f').
Au final, comme préconiser par tout le monde, il faut bien faire :
char*ch; strcpy(ch,"essai"); (et oui, on me l'avai bien dit)
en esperant avoir été à peu près clair

Exact :)