Bonjour,
J'ai regardé pour voir si ce sujet a déjà été déclaré auparavant, mais je n'ai pas trouvé !
J'aimerais savoir s'il est possible de retourner une variable par référence ?

Du style, un membre d'une classe qui renvoie son attribut sans le copier (imaginons que ce soit un lourd vector, bonjour les dégâts )

J'avais essayé un truc du style :

wxArrayInt& arraySize() const

mais cela ne marche pas vu que mon attribut (l'array) n'est pas une référence...

Merci d'avance pour vos réponses

PS : et pour que ma fonction soit la plus courte possible, j'aimerais que ma fonction soit composée d'un return et puis c'est tout (je ne sais pas si c'est possible). J'aimerais éviter de créer une variable référence pour faire cette manipulation, vous comprenez !

ben oui, tu peux renvoyer une référence.
Un exemple : un vector est un truc lourd a copier, alors au lieu de le copier, tu renvoies une référence

class truc
{
  vector<int> V;

public:
  // ...
  vector<int>& Get();
  const vector<int>& GetConst() const;
};

vector<int>& truc::Get()
{
  return V;
}

const vector<int>& truc::GetConst() const
{
  return V;
}

Apres, pour bien appeler le truc :

truc T;
//...
vector<int>& machin = T.Get();  // pas de copie, mais si tu modifie machin, ça modifie truc::V
const vector<int>& machin = T.GetConst();  // pas de copie : safe, lecture seule.
vector<int> machin = T.Get();  // RECOPIE par le = : du coup, modifier machin ne touche pas truc::V

Oui c'est possible mais soit tu as une fonction membre non constante ce qui permet la modification depuis l'extérieur de la classe de ta variable puisque c'est une référence, soit tu retournes une référence constante avec une fonction const, ce qui empêche la mofif' par un étranger de ton attribut.

C'est bon cela marche parfaitement
Mais en fait c'est à cause du fait que je retrouve deux const....

Pourquoi il y a deux const ?
Un qui informe qu'on renvoie une variable que l'on ne doit pas modifier et l'autre qui informe du prototype de la fonction ?

Parce que je l'aurais écris comme cela :

inline wxArrayString& arrayFilesName() const {return m_array_files_name;}

et non :

inline const wxArrayString& arrayFilesName() const {return m_array_files_name;}

wxArrayString& arrayFilesName() const {return m_array_files_name;}

ne devrait pas marcher.

Je prends mon exemple :

vector<int>& truc::GetConst2() const
{
	return V;
}

Je me prend une erreur de compile (et c'est logique) :
error C2440: 'return' : cannot convert from 'const std::vector<_Ty>' to 'std::vector<_Ty> &'

En effet, tu as une méthode const (qui garantie donc qu'elle ne modifie aucun membre de la classe), et tu veux lui faire renvoyer un des membres de la classe en référence, sans protection (donc modifiable depuis dehors) -> ça gueule !

D'accord, je pense avoir compris
Merci pour l'information, cela va beaucoup me servir !!

Une autre utilisation est l'utilisation en l-value : mais c'est le meme concept : regarde (toujours d'apres mon exemple de vector)

vector<int> unautrevector;
vector<int>& recup = T.Get();   // je recupere le vector
recup = unautrevector;   // je remplace le vector de la classe par un autre !

// cela aurait pu etre abrégé en se passant de la référence temporaire "recup" en utilisant une l-value
T.Get() = unautrevector;   // meme résultat !!

// On parle de fonction l_value (left value) quand tu fonction est placée a gauche d'un = . C'est le cas ici.

// De meme je peux faire :
vector<int>& recup = T.Get();   // je recupere le vector
recup[5] = 3;   // je remplace le 5e element par le nombre 3, l'instance T est modifiée !

et on peut de nouveau se passer de la référence temporaire :
T.Get()[5] = 3;

Lol, c'est pas mal la référence finalement
Mais je me demande si le compilateur ne crée quand même pas des variables temporaires (bien que j'en doute, sinon ce concept n'aurait pas été crée )

En tout cas merci de l'information !!