Salut

par définition, toute variable préfixée du type const ne peut pas être modifiée.

il est donc vain de tenter de copier quoi que ce soit dans une constante:

strcpy(const char * cible, char * source);

strcpy(chaine_cible, constante_chaine);

Tu précise un type const dans un prototype de fonction pour garantir qu'un paramètre ne sera pas modifier :

Paramètre classique :

void f(int const i){
...
}

Pour une méthode m de la classe C, rendre "const" le "this"

void C::m(int i) const{
...
}

Le paramètre en question n'a pas besoin d'être const pour être pris. Le seul cas ou un const est nécessaire dans un prototype c'est lorsque tu dois appeler ta méthode sur un paramètre qui lui est const.

Ex :
void f(int const i){
...
g(i); // g doit avoir le prototype g(int const i) pour garantir que i reste constant
...
}

Bonne chance

Const char dest;
char source;
strcpy(dest,source);

Hum !!! Même sans les problèmes de 'const', ça marcherais déjà mieux avec des char*...

Utilise une chaine de copie temporaire...

J'utilise une fonction qui me renvoie un const char.
seulement si je veux faire un strcpy avec un char ca ne marche pas.

Pourquoi tu veux écraser une variable qui de toute façon ne t'appartient pas ??
Elle a fait quoi pour ça ??
Faut bien comprendre que le const char* qui t'es renvoié est const car il dans l'espace de donnée d'une fonction, qui lui appartient, alors retroune travailler dans ton espace mémoire et arrête d'embêter les fontions système, sinon, je vais le dire au contrôleur d'interruption pour qu'il te balance des Division par Zéro dans la gl, non mais !!!

Segfault la skz !!! Un peu de sérieux, t'as pas alloué ton dest ;o) Bon et perso en c++ j'utilise jamais les char *... Les strings c'est sympa !!! ;o)

Bonjour, j'ai aussi un pb de const char mais un peu différent. Je veux bien une explication et/ou une aide.

Voilà le descriptif du problème :

j'ai une chaine de caractère défini dans un const char * (avec chaine[255])

une fonction qui extrait une partie de cette chaine avec un indice inf et un indice sup (perso ou strncpy) dans un char *temp (donc pas const)
malheureusement, il me retourne "...ceque je voulais suivi de Ù".
Pourquoi ai-je ce Ù?
Si je fais cela avec temp en tant que const (taille fixée), je n'ai pas ce Ù.
MAis j'ai besoin bien sûr d'une taille dynamique...
au final, je dois faire un strcpy... mais avec un char* comme source, il n'aime pas trop...

PS : J'ai aussi essayé la conversion forcée... sans succès!

Peux tu me donner le morceau de code ?
http://www.linux-kheops.com/doc/man/manfr/man-html-0.9/man3/­strcpy.3.html

A priori ça ça doit marcher:

#include <string.h>
#include <stdlib.h>
#include <stdio.h>

int main(){
  char * src = "plop plop";
  char * dst = (char *)calloc(sizeof(char)*255);
  strcpy(dst,(const char *) src);
  free(src);
  free(dst);
  printf("src = [%s]\n",src);
  printf("dst = [%s]\n",dst);
  printf("press any key\n");
  getchar();
  return 0;
}

Choco.
si tu n'utilise pas des pointeurs, pas la peine de passer par strcpy !
tu fait directement dest=src, à condition que det ne soit pas const. Salutation !
Char Snipeur

Tout dépend de ce qu'il veut faire. S'il fait un sec = dst, modifier *src modifiera aussi *dst (et réciproquement) je ne sais pas si c'est ce qu'il veut faire.

Bonne chance

Ben si ce sont des char ouui... Mais la on a juste parlé de char * ?

MERCI mamiemando, c'est au poil.... mais j'avoue ne pas avoir tout compris sur ce coup là!!

Ben dis moi ce que tu n'as pas compris et je tenterais de t'expliquer. En gros l'idée c'est qu'on peut caster d'un objet "non const" vers un objet "const" mais pas le contraire (et même si c'est possible il faut pas le faire :p).

Lorsqu'un objet est déclaré const dans le prototype d'une fonction comme c'est le cas pour toi, cette fonction te garantit que ce paramètre ne sera pas modifié. En effet :
1) const char * = char const * = les chars pointés par le char * sont maintenus constant
2) char * const = le pointeur char * est maintenu constant mais pas les chars pointés
3) const char * const = char const * const = tout est maintenu constant.

Ceci dit ca ne sert à rien car le pointeur est recopié sur la pile lors de l'appel de la fonction donc de toute façon même si strcpy changeait ce pointeur ça n'aurait pas d'impact sur le reste du programme. On peut donc se passer de ce deuxième const qui ne sert en fait à rien.

Partant de là on comprend aisément que la chaine source est en toute logique garantie constante par la fonction strcpy. C'est donc bien un const char *. Alors pourquoi les gens du C on mis ce const ? Tout simplement si tu appellès strcpy avec pour source un const char *. En effet si le const ne figurait pas dans le prototype, gcc refuserait de compiler car strcpy ne garantirait plus la constance de cette source.

Exemple :

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

void f(const char * src){
  char * plop = (char *)malloc(sizeof(char)*strlen(src));
  strcpy(plop,src); // Ici on a besoin de garantir la constance de src
  printf("%s\n",plop);
  free(plop);
}

int main(){
  const char *src="j'aime les tapirs";
  f(src);
  return 0;
}

Que des boulets