Différences d'accès des membres

Question

quelqu'un peut-il me dire quelle est la différence entre (*ptr).field et ptr->field? Je sais qu'il se connecte en quelque sorte à la liaison statique et dynamique, mais je ne sais pas ce que c'est. quelqu'un peut-il me dire le differnet et me donner un exemple?

modifier: si j'ai ce code:

Point p;  //point is a class that derive from class shape 
Shape *s=&p; 
       //there is a diffrence if i write: 

(*s).print(); //print is virtual func 
s->print(); // the answers will not be the same, why? 

TNX!

Answer 1

il n'a rien à voir avec la liaison statique ou dynamique les deux expressions renvoie la valeur de ptr.field

la ptr-> forme de champ est une syntaxe abrégée pour accéder à un membre directement à partir d'un pointeur

MISE à JOUR: il me vint que votre intention initiale était pas l'enchaînement mais liant si cela était en effet ce que vous visiez à alors il est liaison statique et dynamique obligatoire qui ont une certaine relation avec l'opérateur ->see here

Answer 2

de liaison statique est le résultat de la copie de linker toutes les routines de bibliothèque utilisées dans le programme dans l'image exécutable. Cela peut nécessiter plus d'espace disque et de mémoire que la liaison dynamique, mais il est à la fois plus rapide et plus portable, car il ne nécessite pas la présence de la bibliothèque sur le système où il est exécuté.

La liaison dynamique est accomplie en plaçant le nom d'une bibliothèque partageable dans l'image exécutable. La liaison réelle avec les routines de bibliothèque ne se produit pas jusqu'à ce que l'image soit exécutée, lorsque l'exécutable et la bibliothèque sont placés en mémoire. Un avantage de la liaison dynamique est que plusieurs programmes peuvent partager une seule copie de la bibliothèque.

Mais il n'est pas lié à l'indirection de pointeur que vous avez mentionnée - en fait, ces deux expressions sont identiques.

Answer 3

Ils sont identiques.
*ptr.field déréférences la variable ptr puis renvoie la valeur du membre field.

L'opérateur -> est une notation abrégée pour ce qui précède.

Answer 4

Cela n'a rien à voir avec la liaison.

ptr->fld 

est simplement un raccourci pour

(*ptr).fld 

Il est pur sucre syntaxique;)

Answer 5

Je suppose que vous vouliez dire par *ptr.field(*ptr).field.

Dans la mesure où seuls les opérateurs intégrés sont pris en compte, il n'y a pas de différence entre les deux. Et non, cela n'a rien à voir avec un lien "statique" ou "dynamique", quoi que ce soit impliqué par ces termes.

La seule différence de potentiel entre les deux est que dans ptr->field variante -> est un opérateur surchargeable en C++, tandis que dans la variante (*ptr).field seulement * est surchargeable, tandis que . est pas.

De plus, certaines différences entre ces deux méthodes d'accès aux membres existaient dans des versions très archaïques du langage C (CRM C), mais je doute que quiconque s'en soucie aujourd'hui.

Answer 6

Tant que ptr est un pointeur, les deux sont équivalents une fois correctement entre parenthèses (comme d'autres l'ont dit). Si ptr est un objet, plutôt qu'un pointeur, ils peuvent être différents selon les définitions pour operator* et operator-> (le cas échéant) de la classe ou des ancêtres de l'objet.

Answer 7

Cela n'a rien à voir avec la liaison statique ou dynamique.

Voir C++'s operator precedence. Le . a une priorité inférieure à *, donc il y a en fait une assez grande différence entre *ptr.fld et ptr->fld. Par exemple, le code suivant montre:

#include <iostream> 

struct foo { 
    int f; 
}; 

int main() { 
    struct foo *p = new struct foo; 
    p->f = 42; 
    std::cout << p->f << std::endl; 
    std::cout << (*p).f << std::endl; 
    // The following will not compile 
    // std::cout << *p.f << std::endl; 
} 

Comme John Knoeller souligne, ptr->fld est le sucre syntaxique pour (*(ptr)).fld, mais n'est pas la même chose que *ptr.fld, qui fait évaluer à *(ptr.fld), probablement pas ce que vous voulez.

Vous utiliseriez ptr->fld lorsque vous avez un pointeur vers une structure et souhaitez accéder à un champ qui y est contenu. (*(ptr)).fld signifie la même chose mais n'est pas aussi bien rangé. Vous utiliseriez *strct.fld lorsque vous avez une structure, pas un pointeur sur une structure, qui contient un champ (fld) qui est un pointeur que vous souhaitez déréférencer. Le cas de ptr->fld est illustré ci-dessus. Le cas de *strct.fld pourrait être utilisé avec la structure suivante:

struct foo { 
    int *fld; 
} 

struct foo f; 
f.fld = new int; 
*f.fld = 42; 

Answer 8

Le formulaire -> est juste un raccourci pour de-refrencing le pointeur et l'accès au membre.

(*ptr).field; 
// Equiv to 
ptr->field; 

Une bonne raison d'utiliser -> est que lorsque vous suivez une chaîne:

int x = (*(*(*(*ptr).field1).field2).field3).field4; 
// Equiv to 
int y = ptr->field1->field2->field3->field4; 

Le second devient beaucoup plus lisible.

Comme pour la deuxième partie de votre question.
Je trouve vraiment facile de trouver un exemple.

#include <iostream> 

class Shape 
{ 
    public: virtual ~Shape()  {} 
       virtual void Print() {std::cout << "Shape\n";} 
}; 
class Point: public Shape 
{ 
    public: virtual void Print() {std::cout << "Point\n";} 
}; 

int main() 
{ 
    Point p; 
    Shape* s = &p; 

    s->Print(); 
    (*s).Print(); 
} 

> vi x.cpp 
> g++ x.cpp 
> ./a.exe 
Point 
Point 

Comme vous pouvez le voir le résultat est le même dans les deux situations.

Lorsque vous appelez une méthode via un pointeur ou une référence, le mécanisme d'appel virtuel est appelé. L'opérateur star (AKA derefence operator) renvoie une référence à un objet (il ne dé-référence pas réellement l'objet). Donc, quand il est utilisé pour appeler une méthode, le mécanisme d'appel virtuel sera appelé et la version la plus dérivée de la méthode appelée.