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.