en C++, une référence est forcément initialisée de manière valide. (pas d'équivalent du NULL pour les pointeurs).
Une référence peut ainsi servir comme attribut d'une classe pour représenter un lien fort et indestructible (bien que modifiable) avec une autre entité.
Cependant, on se sert plutôt des références comme type de retour des méthodes ou bien comme paramètre.
La référence comme type de retour permet :
- un accès efficace à des instances tout en évitant la lourdeur et les risques d'erreur inutiles avec les pointeurs,
- un accès direct aux attributs de la classe (l'usage plus probable étant un usage semblable à l'opérateur d'indexation [] de la classe std::vector de la STL, qui retourne certes une référence, mais qui n'est pas directement un attribut).
La référence en paramètres de méthode et fonction :
- passage par référence
- passage par référence constante, plus efficace que le passage de paramètre par copie, et avec seule restriction de ne pouvoir modifier le paramètre dans la définition de la méthode ou fonction.
Les pointeurs restent nécessaire lorsque l'on a besoin de manipuler la mémoire soi-même (allocation dynamique par exemple), pour les tableaux, ou encore pour des utilisation très spécifiques où l'efficacité prévaut largement sur la qualité fonctionnelle du code.
Par exemple :
class Toto
{
public :
// Ici on retourne une référence constante.
// Si Truc est très gros, l'accès reste
// tout de même efficace.
const Truc & GetTruc() const { return m_truc; }
// Ici, accès direct à l'attribut. Très efficace et
// équivalent à rendre m_truc public
Truc & Truc() { return m_truc; }
// Exemple de paramètre passé par référence. La méthode
// peut modifier la valeur de param
void Change(Truc & param);
// Exemple de paramètre passé par référence constante
// La méthode ne peut modifier param, mais param n'est
// pas copié (efficacité si Truc est assez gros)
void NeChangePas(const Truc & param);
// Exemple de paramètre passé par copie.
// La méthode travaille sur une copie de param,
// qui peut être modifié dans le corps de la méthode
// mais l'instance de Truc utilisée comme
// paramètre par l'appelant reste inchangée
void ParCopie(Truc param);
(...)
protected :
Truc m_truc;
(...)
};
-------------------------------
Réponse au message :
-------------------------------
Bonjour
je commence a programmer en c++ je voudrais comprendre quand j'utilise les pointeurs et les références
ainsi que les déclarations:
*var
**var
&var
Merci bien pour vos réponses
|