Discussion :

[jph_void]

Bonjour!,
J'aurais besoin d'un tout petit éclairsissement...

imaginons :

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
 
class String{
 private: char* value;
 public:
  ...
  char* value(){return value;};
  char* toupper(){
    char tempo[strlen(value)+1]={'\0'};
    for(int i=0;i<strlen(value);t++)
      tempo[i]=toupper(value[i]);
    return tempo;
  };
};
 
int main(void){
 String s;
 char *p;
 s = "une valeur";
 s = s.toupper(); //Reaffectation d'une variable locale ?
 p = s.toupper();
 
  ...
  ...
  ...
 
 *p=0; //Dangereux ?
 
 return EXIT_SUCCESS;
}

Le but de méthodes telle que toupper est essentiellement de réutiliser immédiatement la valeur de retour pour une assignation.

Cependant il se pourait que du mauvais code conduise a l'example ou apres un certain temp un pointeur p pointe toujours sur la valeur de retour...

Ma question est :

En imaginant que l'operateur = ait été surchargé de façon a copier le contenu de la valeur reçue dans value:

- Est ce que réaffecter la variable locale tempo est dangereux du fait qu'elle ne soit pas sur le heap ?

- Idealement vaudrait-il mieu stocker tempo en variable membre de la classe String et l'utiliser pour tout une série d'opérations (qui ne modifient pas la valeur passée) comme toupper, ceci de façon a toujour etre certain de retourner un emplacement mémoire "sur" ?

- Ceci est-il géré par les compilateur ou les environements récents ?
- Enfin ceci est-il bon pour la portabilité (systèmes d'exploitations pouvant avoir un mauvais management de la mémoire en général par example) ?


Voila, c'est une qestion toute bete et je voudrais etre certain de ne pas faire de betises.

[loufoque]

Tu renvoies un pointeur vers une variable locale, ce qui est donc mauvais.

[MatRem]

Si tu utilises la classe std::string, tu n'auras pas de problème, car il y aura une copie par valeur.

[jph_void]

Si tu utilises la classe std::string, tu n'auras pas de problème, car il y aura une copie par valeur.

Je voudrais etre sur de bien comprendre : la copie par valeur s'éffectue en fait simplement des lors que je vais retourner non plus par pointeur ou par référence, c'est bien ça?

[MatRem]

Effectivement tu as trois façon de renvoyer quelquechose (comme d'ailleurs pour le passage d'aguments) :
- par pointeur;
- par référence;
- par valeur;

Ensuite on peut utiliser le mot clef const, pour améliorer ces trois "types" d'envoi de données.


=> Si tu utilise le retour par pointeur ou référence tu accédéras, en dehors de la fonction, à la variable elle même (la même instance). Il faut donc absolument qu'elle existe encore après l'appel de la fonction.


Le retour d'objet locaux à la fonction : qui sont détruits à la fin de l'appel de cette fonction, ne doit donc surtout pas être utilisé dans ce cas.
En effet, le pointeur ou la référence utiliser après l'appel de fonction sera invalide => erreur de segmentation.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
int * f()
{
   int i; //Allocation automatique sur la pile
   return &i; //Gros problèmes quand on va se servir du pointeur renvoyé. i sera détruit à la fin de sa portée (la fonction).
}
 
int main()
{
   int * pi = f();
   std::cout << *pi << std::endl; // *pi a été alloué puis détruit automatiquement, donc il n'est plus valide ici. => Il y aura trés certainement une erreur de segmentation.
}

Par contre tu peux retourner par pointeurs des objets qui sont alloués dynamiquement dans la fonction (new), et non détruit à la fin de l'appel. Cependant il faudra penser à détruire la donnée, en dehors de la fonction.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
int * f()
{
   return new int; //Allocation manuelle (dynamique)
}
 
int main()
{
   int * pi = f();
   std::cout << *pi << std::endl; // *pi a été alloué dynamiquement par f, donc il est encore valide.
   delete pi;
}

=> Enfin tu peux retourner l'objet par valeur. Dans ce cas, il y aura une copie, qui pour les types défini par l'utilisateur (classe) sera fait en appellant le constructeur par copie (C::C(C const &));

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
int f()
{
   int i;
   return i; //Retour par valeur, la variable affectée par le retour copiera la valeur de i.
}
int main()
{
   int i = f(); // copie de la valeur de i dans f;
   std::cout << i << std::endl; //i est valide car il s'agit du i défini dans main;
}

J'espère que j'ai été à peu prés clair

[jph_void]

Oui c'est parfait.