Discussion :

[mazertys17]

Bonjour.

Je suis débutant en programmation / C++, et je me pose quelques questions...quand on envoi un pointeur d'objet à un autre objet, concrètement, ce qu'on envoi est:

une simple adresse concernant le début de l'objet en question, donc quelque chose de très légers ?
ou
une série d'adresse comprenant toutes les fonctions, attributs etc...de l'objet, donc plus lourd?

En somme, si j'ai un objet assez chargé en fonction et attributs, dont je n'ai besoin d'avoir accès qu'a quelques attributs/fonctions dans un autre objet, ais-je intérêt à'envoyer l'objet entier en pointeur, ou plutôt de me débrouiller autrement...?

ex:

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
22
23
24
25
26
27
28
29
30
31
 
class ObjetLourd
{
public:
 
     ObjetLourd();
     ~ObjetLourd();
 
     ObjetX renvoiObjetX();
     ObjetY renvoiObjetY();
     etc...
     void faitUneChose(Truck truck, Bidul bidul, float machin);
     etc...
 
     bool renvoiSimple();
 
private:
 
    ObjetX m_objetX, m_objetX2 etc...;
    ObjetY m_objetY, m_objetY2 etc...;
    etc...
    Truck m_truck1 etc...
    Bidul m_bdul1 etc...  
 
    float m_machin, m_machin2, etc...
 
    bool m_simple;
 
    etc...
 
}

a suposé, donc que "ObjetLourd" soit un objet qui contienne lui même plein d'objet, fonctions etc...et que j'ai simplement besoin d'utiliser la fonction bool "renvoiSimple()" par un autre objet

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
22
23
24
25
26
27
28
29
 
 
class AutreObjet
{
 
public:
 
     AutreObjet();
     ~AutreObjet();
 
    void recoitObjetLourd(ObjetLourd *objetLourd)
    {
    m_objetLourd = objetLourd;
    }
 
    void utiliseObjet()
   {
       if(m_objetLourd->renvoiSimple() == true)
       {
           //fait quelqueChose...
       }
   }
 
 
 
private:
 
    ObjetLourd *m_objetLourd;
}

Si je procède ainsi, mon "AutreObjet" prendra-t-il des ressources en plus de facon concéquente ou pas? (même s'il n'utilise pas forcément de facon systématique le pointeur "ObjetLourd"...

Bref, ce n'est pas encore tout à fait clair pour moi, les pointeurs, voila pourquoi je viens vers vous au cas ou vous pourriez m'aider à y voir plus clair...


Merci

[Daïmanu]

Bonjour.

Dans ton exécutable, la règle est simple : « Tout est une question adresse » (les pointeurs, les fonctions, les variables etc…)

Quant tu transmet un pointeur à quelqu'un d'autre, tu lui transmet uniquement une adresse, un emplacement en mémoire RAM.

Maintenant comment le destinataire sait où se trouve le reste ? Où se cache faitUneChose(Truck, Bidul,float) en mémoire ?
Comme je l'ai dit précédemment, tout est adresse, y compris les fonctions.

Quand dans le code source on a objet.faitUneChose(t, b, f);, le compilateur inscrit l'adresse de la fonction « en dur » dans l’exécutable (ou plutôt un offset mais là on rentre dans le très bas niveau).

[mazertys17]

Merci pour votre réponse, Daïmanu.

Si j'ai bien saisi, donc, quand j'envoi un pointer d'objet à un objet, en fait, je lui envoi toutes les adresses de chacune des fonctions de l'objet? donc plus l'objet envoyé est lourd, plus le pointeur envoyé le sera également, et donc l'objet qui le recevra aussi ?

[Daïmanu]

Le pointeur c'est simplement une adresse mémoire, rien de plus. Sa taille ne varie pas selon ce vers quoi il pointe.

Après c'est le compilateur qui gère tout ce qui est adresse, taille etc. On a pas a s'y préoccuper, c'est totalement transparent.

[mazertys17]

OK.

Donc, que j'envoi le pointeur d'un objet "mégaLourd", ou celui d'un "SuperLégers", il aura le même poid, prendra la même place (soit un simple nombre correspondant à une adresse).
C'est simplement quand je l'utilise, qu'il va parcourir toutes les fonctions/attributs de l'objet concerné?

Si j'ai bien compris, j'ai donc tout intérêt a envoyé des pointeurs d'objet, même lourd, pour une questions d'organisations du code, car cela ne ralentira pas plus le programme...?

[Daïmanu]

Si j'ai bien compris, j'ai donc tout intérêt a envoyé des pointeurs d'objet, même lourd, pour une questions d'organisations du code, car cela ne ralentira pas plus le programme...?

Quand tu dois transmettre un objet à une fonction, tu a deux choix : soit tu passe par valeur, soit par pointeur / référence
Par valeur void f(ObjetLourd o); tu envoie une copie de ton objet à la fonction. Une copie d'autant plus longue à faire que ton objet est lourd.
Par pointeur void f(ObjetLourd *o); tu envoie une copie de l'adresse de l'objet à la fonction, ce qui est bien plus léger. Les références f(ObjetLourd& o); sont un peu différents mais tout aussi rapide.

Mais attention à ne pas tomber dans le piège « Mettre des pointeurs partout », il faut en mettre uniquement quand on doit transmettre un objet.

[renoo]

OK.

Donc, que j'envoi le pointeur d'un objet "mégaLourd", ou celui d'un "SuperLégers", il aura le même poid, prendra la même place (soit un simple nombre correspondant à une adresse).
C'est simplement quand je l'utilise, qu'il va parcourir toutes les fonctions/attributs de l'objet concerné?

Si j'ai bien compris, j'ai donc tout intérêt a envoyé des pointeurs d'objet, même lourd, pour une questions d'organisations du code, car cela ne ralentira pas plus le programme...?

La taille des pointeurs c'est sizeof(void *) souvent 4 ou 8 octets. Quand tu as un objet lourd situé à l'adresse x alors si tu accedes à une variable membre m_ma_variable alors le compilateur sait que ce membre est situé à l'adresse x + offset où offset depend du membre bref c'est du temps constant. Si tu appelles une fonction virtuelle alors il y a simplement une indirection en plus mais c'est rapide.

ps: utilise plutot des references "&" qui ne peuvent etre null pour passer tes objets "lourds"