Discussion :

[bricecol]

rebonjour, ou plutôt bonsoir !

voilà, lorsqu'on veut utiliser des variables à plusieurs endroits sans les dupliquer, on utilise soit les pointeur, soit les références.

en utilisant les pointeurs (par fonction), on dit à notre fonction : "tiens, voilà un pointeur vers la variable que tu dois utiliser".

en utilisant une référence (par fonction), on dit : "tiens, voilà la référence de la variable que tu dois utiliser".

dis comme çà, il n'y a aucune différence car un pointeur, c'est une adresse de variables, une référence, c'est bien une adresse de variables ?!

la seule différence se situe donc dans l'utilisation (dans l'appel)

ex avec pointeurs :

Code :

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

1
2
3
4
5
6
7
8
9
void Permut(int* a, int* b) {
int c = *a;
*a = *b;
*b = c;
}
 
int a = 2;
int b = 7;
Permut(&a, &b); // on retrouve a = 7 et b = 2...

ex avec références :

Code :

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

1
2
3
4
5
6
7
8
9
void Permut(int& a, int& b) {
int c = a;
a = b;
b = c;
}
 
int a = 2;
int b = 7;
Permut(a, b); // on retrouve a = 7 et b = 2...

je voudrais donc simplement savoir pourquoi utiliser l'un plutot que l'autre ? a mon avis, mais je peux me tromper, les pointeurs nous permettent de mieux gérer l'espace mémoire utilisé, c'est çà ? qu'est-ce qui est plus rapide ? moins gourmant ?

merci pour votre aide.

[Nogane]

Bonsoirs,
La principale raison d'utiliser les pointeur dans ce cas c'est que... les référence n'existaient pas en C.
Autrement dit, il n'y as que peu d'intérêt a utiliser un pointeur, vu tous les inconvénient que ca peut avoir:
- Passage d'un pointeur NULL non attendu
- La fonction peut faire un delete dessus
- On pourrait être tenté de la mètre dans un pointeur intelligent alors qu'il y est déjà, mais ailleurs.
- Plein d'autre qui me reviendrons plus tard...

Les avantages du pointeurs serais:
- Possibilité de passer un pointeur NULL(en effet c'est impossible avec une référence)
- Possibilité de faire un delete dessus(mais ca impliquerais généralement une gestion mémoire un peu douteuse).

A priori il n'y a pas de différence d'un point de vu efficacité. Donc d'une manière général, si tu peut passer par une référence plutôt qu'un pointeur nu, fait le, (et rend la constante a chaque fois que ca semble logique)

[koala01]

Salut,

Il faut déjà peut être commencer par comprendre les différences réelles entre les pointeurs et les références.

Un pointeur, comme tu l'as signalé, c'est un objet (ayant sémantique de valeur) contenant... une adresse mémoire, alors qu'une référence est plutôt un alias, avec tout ce que cela implique, de l'objet original.

On te dira sans doute qu'une référence et un pointeur fournissent le même code exécutable (binaire), et c'est vrai.

Par contre, il faut comprendre qu'un pointeur présente pas mal d'inconvénients par rapport aux références:

• Il n'a aucune garantie de non nullité (ce qui implique la nécessité de vérifier qu'il n'est pas nul avant d'essayer d'accéder à l'objet pointé)
• Il ne transmet absolument pas la constance de l'objet pointé
• Il est souvent synonyme de gestion dynamique "a mano" de la mémoire
• Il nécessite une adaptation de la syntaxe d'utilisation (utilisation de l'étoile "*" ou de la flèche "->"
• on peut, à tout moment, décider de faire pointer le pointeur sur un autre objet

Les références présentent donc une série d'avantages par rapport aux pointeurs:

• Il y a une garantie de non nullité: une référence fait, d'office, référence à un objet "existant par ailleurs" (il devient donc inutile de vérifier si, oui ou non, cet objet existe)
• Elles garantissent la transmission de la constance: si tu transmet un objet sous la forme d'une référence constante, seules les fonctions membres déclarées constantes de cet objet seront utilisables
• la syntaxe d'utilisation d'une référence est strictement identique à celle de l'objet originale
• il est possible de passer une référence sur un pointeur (mais il est par contre impossible de passer un pointeur sur référence, du fait que la référence ne dispose pas d'une adresse "à elle")
• Une fois qu'une référence est définie comme faisant référence à un objet particulier, il n'est plus question de la redéfinir comme faisant référence à un autre objet
• Enfin, les différentes classes fournies par le standard (std::string, std::vector, ...) sont particulièrement adaptées au passage par référence et particulièrement inadaptées à l'utilisation de pointeurs

L'idée est donc, en générale, d'utiliser les références chaque fois que l'on peut, et surtout lorsque l'utilisation d'un pointeur impliquerait le recours à l'opérateur "address of" (l'esperluette "&") et de n'utiliser les pointeurs que... quand on n'a pas le choix.

Contrairement à ce que l'on pourrait croire, l'utilisation d'une référence n'a aucune incidence du point de vue de l'utilisation de la mémoire car une référence n'est absolument pas une copie de l'objet: c'est l'objet référencé lui-même, simplement, il est identifié par un nom (potentiellement) différent

Il n'y a également aucune incidence sur la vitesse ou sur les performances, car, comme je te l'ai indiqué, l'utilisation d'une référence produira un code exécutable binaire identique à celle d'un pointeur.

Par contre, à l'usage, une référence sera largement plus simple à utiliser parce que, justement, elle utilisera la même syntaxe que l'objet original et te permet, le cas échéant, d'éviter le recours au pointeurs de pointeurs (de pointeur de...), qui finit invariablement par nous faire poser la question du nombre d'indirections à utiliser

[Cheps]

Utilise les pointeurs quand tu dois faire de la programmation dynamique, faire du polymorphisme, ou quand une interface (bibliothèque) t'y force. Pour tout le reste il y a Mastercard (enfin les références quoi ).

[koala01]

Utilise les pointeurs quand tu dois faire de la programmation dynamique,

Oui, il n'est pas possible d'effectuer une allocation dynamique sur autre chose qu'un pointeur, par contre

faire du polymorphisme,

non...

Le polymorphisme peut aussi s'effectuer sur base d'une référence

ou quand une interface (bibliothèque) t'y force.

Là, effectivement, tu as rarement le choix

[Cheps]

C'est vrai que les seules fois où j'ai fais du polymorphisme c'est dans le cadre de programmation dynamique, mais en fait y'a pas de raison que ça marche pas sans pointeurs. Autant pour moi.

[koala01]

C'est vrai que les seules fois où j'ai fais du polymorphisme c'est dans le cadre de programmation dynamique, mais en fait y'a pas de raison que ça marche pas sans pointeurs. Autant pour moi.

Le fait est que le polymorphisme peut, parfaitement, prendre la forme d'une utilisation non dynamique de la mémoire:

Soit une hiérarchie de classe proche de

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
class Shape
{
    public:
        Shape(){}
        virtual ~Shape(){}
        virtual void draw() const = 0;
};
class Circle : public Shape
{
    public:
        Circle(){}
        virtual ~Circle(){}
        virtual void draw const{std::cout<<"I'm a circle"<<std::end;}
};
class Square : public Shape
{
    public:
        Square(){}
        virtual ~Circle(){}
        virtual void draw const{std::cout<<"I'm a square"<<std::end;}
};

Et une fonction prenant une référence vers un objet de type (compatible avec la classe) Shape:

Code :

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

1
2
3
4
5
void doSomething(Shape const & s)
{
    // ceci appelle bel et bien le comportement polymorphe de l'objet ;)
    s.draw();
}

Il t'est, tout à fait, possible de déclarer un objet de type ... Circle, ou Square (pour suivre l'exemple) sans passer par l'allocation dynamique de la mémoire et d'invoquer la fonction en question en lui passant ton instance, sous une forme proche de

Code :

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

1
2
3
4
5
6
7
8
int main()
{
    Circle c;
    Square s;
    doSomething(c);
    doSomething(s);
    return 0;
}

PS: ce n'est qu'un détail, mais on doit normalement écrire au temps pour moi, lorsqu'il s'agit de rectifier une erreur commise...

Il n'y a que si tu souhaite demander "la même quantité d'une chose" que la personne qui a parlé avant toi que l'utilisation de "autant pour moi" se justifie

[3DArchi]

Bonjour,

a mon avis, mais je peux me tromper, les pointeurs nous permettent de mieux gérer l'espace mémoire utilisé, c'est çà ?

Non. Dans un passage d'argument, pointeurs et références utilisent le même espace mémoire.

qu'est-ce qui est plus rapide ?

Le passage en argument d'une référence ou d'un pointeur génèrent le même code et sont donc aussi rapides.

moins gourmant ?

Le passage en argument d'une référence ou d'un pointeur génèrent le même code et sont donc aussi gourmands.

je voudrais donc simplement savoir pourquoi utiliser l'un plutot que l'autre ?

Dans le cadre du passage d'argument à une fonction, j'aurais tendance à préférer un passage par référence pour toutes les raisons données ci-dessus.

[Lavock]

Un des principale avantage c'est qu'une référence constante peut servir à récupérer une rvalue, sans passer par l'opérateur de copie.

Le principale désavantage, c'est qu'elle définit ça valeur à la création... Et qu'elle à besoin d'une lvalue si elle n'est pas constante >< !

En gros, c'est généralement dans les membre des classes ou on va trouver les pointeurs, et dans le passage d'argument que l'on trouve les références.

[Cheps]

PS: ce n'est qu'un détail, mais on doit normalement écrire au temps pour moi, lorsqu'il s'agit de rectifier une erreur commise...

Il n'y a que si tu souhaite demander "la même quantité d'une chose" que la personne qui a parlé avant toi que l'utilisation de "autant pour moi" se justifie

Je sais que l'origine de l'expression est "au temps pour moi", mais l'académie française accepte les deux formes

[Lavock]

Ah, et surtout, on ne peut pas surcharger les opérateurs avec des pointeurs >< !

PS : Oui, nous avons solutionné le problème après avoir rotationné quelque peu ! Mais ne nous attentionnons pas trop, sans quoi nous allons nous agravationner ><!

PPS : Je deteste les verbes en -tionner !

[bricecol]

hé bien hé bien ! merci pour vos réponses !
je serais moins bête en me couchant ce soir !

merci !