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);

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 Salutation !
Char Snipeur

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 Salutation !
Char Snipeur

Exact :)
~ iclic @ gauch,iclic, iclic @ droate, iclic, iclic
et ya pas de bôg môsieu ! ~

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";
}

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

#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;
}