Compréhension des pointeurs c++

Le problème exposé dans ce sujet a été résolu.

Bonjour, je connaitre la différence entre ces 2 fonctions ? Une avec pointeur l’autre sans. Merci :)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
#include <iostream>  

void duplicate(int& a, int& b, int& c) 
{   
a*=2;   
b*=2;   
c*=2; }  

int main () 
{   
int x=1, y=3, z=7;   

duplicate (x, y, z);   

std::cout << "x=" << x << ", y=" << y << ", z=" << z;   



return 0; 
}

2:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
#include <iostream>  

void duplicate(int a, int b, int c) 
{   
a*=2;   
b*=2;   
c*=2; }  

int main () 
{   
int x=1, y=3, z=7;   

duplicate (x, y, z);   

std::cout << "x=" << x << ", y=" << y << ", z=" << z;   



return 0;
+0 -0
  • Résultat 1 (avec pointeurs) : x = 2, y = 6, z = 14.
  • Résultat 2 (sans pointeurs) : x = 1, y = 3, z = 7.

Pas de duplication, pourquoi ? … Pas de besoin de mettre de return a la fonction avec pointeurs ?

Eh bien enfaite le sans pointeurs il faudrait qui est un type int déja et pour le reproduire il faudrait faire de la surcharge de fonction alors celle avec les pointeurs non a pas besoin ?

+0 -0

Aucun pointeur à proprement parlé n’est utilisé dans ton exemple.

On parle de référence ici ; et de passage par référence pour les pointeurs et pour les références.

+1 -0

On va changer d’angle de vue. Pour échanger deux valeurs de type "int" en C++, on peut écrire un code comme :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
#include <iostream>

int main(){
  int a = 42;
  int b = 24;

  std::cout << "a: " << a << ", b:" << b << std::endl;

  int tmp = a ;
  a = b ;
  b = tmp ;

  std::cout << "a: " << a << ", b:" << b << std::endl;
}

Seulement, c’est un peu énervant de devoir réécrire ces trois instructions à chaque fois que l’on veut faire un échange. On aimerait pouvoir écrire :

1
2
3
4
5
6
7
8
int main(){
  int a = 42;
  int b = 24;

  std::cout << "a: " << a << ", b:" << b << std::endl;
  echange(a, b);
  std::cout << "a: " << a << ", b:" << b << std::endl;
}

L’exercice maintenant pour toi c’est d’écrire la fonction échange. Et tu vas voir que tu ne peux pas le faire sans références (type& introduit une référence sur une variable dont le type est "type", pas un pointeur). Pour la simple et bonne raison que si tu ne mets pas de références, tu auras des copies des variables que l’on t’a donné en paramètre et pas les variables elles-mêmes. Les références permettent justement d’obtenir un accès direct aux variables.

+1 -0

Donc la seule différence c’est qu’on peux accéder aux vraie variables et non a des copies ?

PixarFilmz

C’est quand même une sacré différence, surtout quand la référence en question autorise la modification (non const).

Il me semble qu’à accéder aux références ou aux vraies variables ne change rien ? (peut être les performances ?)

PixarFilmz

Ça peut avoir un impact sur les performances, si le compilateur détermine qu’il a besoin de produire un passage d’adresse (la création d’un pointeur) pour produire le passage par référence. Dans ce cas, pour les types simples (int, char, bool, …), cela va induire un surcoût parce que le pointeur sera plus lourd. Mais ce n’est pas forcé, cela va fortement dépendre du contexte. Généralement, le bon algo pour déterminer le type d’un paramètre de fonction c’est :

  • par défaut :
    • si la variable est un type simple (bool, char, int, …) : par copie,
    • si la variable est un type complexe (struct, class, …) : par référence const,
  • si on s’aperçoit que la variable reçue doit être modifiée du point de vue de celui qui appelle la fonction : par référence.
+1 -0
Connectez-vous pour pouvoir poster un message.
Connexion

Pas encore membre ?

Créez un compte en une minute pour profiter pleinement de toutes les fonctionnalités de Zeste de Savoir. Ici, tout est gratuit et sans publicité.
Créer un compte