kawazaki
-
10 sept. 2001 à 01:27
cs_cognac
Messages postés50Date d'inscriptionsamedi 20 avril 2002StatutMembreDernière intervention11 mars 2010
-
10 sept. 2002 à 19:53
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
int * var; //déclaration d'un pointeur sur entier
*var //contennu pointé par var
int **var; //tableau de pointeur sur entiers
**var; //contennu du pointeur du 1° elt du tableau de pointeurs sur entier
&var; //adresse de var :
Ex:
int var= 10;
int *pVar;
pVar = &var;
//ici, *pVar (contennu pointé par pVar) est égal a 10;
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;
(...)
};
Vous n’avez pas trouvé la réponse que vous recherchez ?
SmallToad
Messages postés110Date d'inscriptionlundi 7 janvier 2002StatutMembreDernière intervention26 septembre 2004 21 janv. 2002 à 18:49
Bof! C'est pas vraiment bon ca. C'est juste un petit pointeur mais ca montre pas tout. Il faut apseulument que tu t'achette un livre (je c ca coue 150$ CAN c chere) mais ca vaut la pein). Avec ca tu peux comprendre les class, private, public, et tout les choses les plus importantes.