En quoi les opérations d’access des membres «->» et «.» Diffèrent-elles en C

J’ai consulté des ressources pour me dire comment -> et . sont différents, mais ils semblent faire la même chose. Est -> ce que -> agit comme un opérateur de points sur une structure?

. est utilisé lorsque vous avez une structure, et -> est utilisé lorsque vous avez un pointeur sur une structure. La flèche est une forme abrégée permettant de déréférencer le pointeur, puis d’utiliser . : p->field est identique à (*p).field .

Ils sont presque la même chose. La seule différence est que “->” prend un pointeur sur une structure du côté gauche tandis que “.” prend une struct; “->” défère (c’est-à-dire suit) le pointeur avant d’accéder au membre struct. Alors,

 struct foo bar; bar.x = 0; 

est le même que:

 struct foo bar; struct foo *diddly = &bar; diddly->x = 0; 

vous utilisez un point pour accéder aux membres de l’object et la flèche -> pour accéder à des membres par le biais du pointeur sur un object

-> est à un pointeur struct quoi . est à un struct.

 struct Data data; data.content = 1; struct Data* pData = &data; pData->content = 2; 

Ah, je suis juste tombé sur la même question, en regardant les parameters régionaux. L’une est destinée à accéder aux atsortingbuts via le pointeur et l’autre à la structure déréférencée:

 #include  int main (void) { struct lconv *locale_ptr; locale_ptr = localeconv(); printf("Currency symbol: %s\n", (*locale_ptr).currency_symbol); } 

est équivalent à:

 int main (void) { struct lconv *locale_ptr; locale_ptr = localeconv(); printf("Currency symbol: %s\n", locale_ptr->currency_symbol); } 

Le plus simplement, vous utilisez. en opérant sur une structure elle-même et -> en opérant sur un pointeur sur une structure.

Pour afficher dans le code:

  struct s myStruct; myStruct.num = 5; 

Est valide, mais:

  struct s myStruct; myStruct->num = 5; 

N’est pas valide car myStruct n’est pas un pointeur.

  struct s *myStruct; myStruct->num = 5; 

Serait valide.

L’opérateur -> est en réalité un raccourci pour (* myStruct) .num;

Le langage C, contrairement à de nombreux autres langages, permet aux variables d’avoir des objects (ici des structs) comme valeurs et des pointeurs sur des objects comme des valeurs. Selon le type de variable utilisé, “.” ou “->” doivent être utilisés respectivement.

[.] opère sur un object d’une structure. Une fois qu’un object d’une structure particulière est déclaré, l’opérateur [.] Peut être utilisé pour agir directement avec les membres.

[->] opère sur un pointeur sur l’object d’une structure. Il s’agit d’un opérateur de déréférence utilisé exclusivement avec des pointeurs sur des objects avec des membres. Nous permettant ainsi d’accéder aux membres de l’object vers lequel nous avons une référence.

Sur la base de la déclaration, vous pouvez utiliser ces opérateurs.

L’opérateur a-> b, canoniquement, signifie (* a) .b. Ainsi, contrairement à “.”, Il déréférencera son premier argument.

Je peux me tromper sur ce point, mais je crois comprendre que cela ne fait pas “officiellement” partie de C (vous mentionnez spécifiquement C dans la question). C’est une construction C ++ que la plupart des fournisseurs de compilateurs C ont ajoutée à C. Cependant, je dois admettre que je n’ai pas suivi les modifications apscopes à C, donc je peux me tromper complètement.

En C ++, il existe d’autres différences. L’opérateur “->” est surchargeable, alors que le “.” n’est pas.