Qual é a diferença entre o operador ponto (.) E -> em C ++?

Qual é a diferença entre o operador ponto (.) E -> em C ++?

   

foo->bar() é o mesmo que (*foo).bar() .

Os parêntesis acima são necessários devido à força de binding de * e . operadores.

*foo.bar() não funcionaria porque o operador Dot ( . ) é avaliado primeiro (veja a precedência do operador )

O operador Dot ( . ) Não pode ser sobrecarregado, o operador arrow ( -> ) pode estar sobrecarregado.

O operador Dot ( . ) Não pode ser aplicado a pointers.

Veja também: O que é o operador de seta (->) para o C ++?

Para um ponteiro, poderíamos apenas usar

 *pointervariable.foo 

Mas o . operador tem maior precedência que o operador * , então . é avaliado primeiro. Então, precisamos forçar isso com parênteses:

 (*pointervariable).foo 

Mas digitar o () o tempo todo é difícil, então eles desenvolveram -> como um atalho para dizer a mesma coisa. Se você estiver acessando uma propriedade de um object ou referência de object, use . Se você está acessando uma propriedade de um object através de um ponteiro, use ->

Operador de ponto não pode ser sobrecarregado, o operador de seta pode estar sobrecarregado. O operador de seta geralmente deve ser aplicado a pointers (ou objects que se comportam como pointers, como pointers inteligentes). O operador de ponto não pode ser aplicado a pointers.

EDIT Quando aplicado ao operador de seta de ponteiro é equivalente a aplicar o operador de ponto a pointee (ptr-> campo é equivalente a (* ptr) .field)

O operador de seta é como ponto, exceto que ele desreferencia um ponteiro primeiro. foo.bar() chama o método bar() no object foo , foo->bar chama a bar método no object apontado pelo ponteiro foo .

 pSomething->someMember 

é equivalente a

 (*pSomething).someMember 

O. operador é para access direto a membros.

 object.Field 

A seta desreferencia um ponteiro para que você possa acessar o object / memory para o qual ele está apontando

 pClass->Field 

O alvo. ponto funciona em objects; seta funciona em pointers para objects.

 std::string str("foo"); std::string * pstr = new std::string("foo"); str.size (); pstr->size (); 

-> use quando você tiver um ponteiro. use quando tiver estrutura (class) quando quiser que o atributo point pertença ao uso da estrutura. structure.attribute quando deseja apontar para o atributo que tem referência à memory pelo ponteiro use ->:

 pointer->method; or same as: (*pointer).method 

Note que o operador -> não pode ser usado para certas coisas, por exemplo, acessar o operador [].

 #include  int main() { std::vector iVec; iVec.push_back(42); std::vector* iVecPtr = &iVec; //int i = iVecPtr->[0]; // Does not compile int i = (*iVecPtr)[0]; // Compiles. } 

É simples, sempre que você vê

  x->y 

sei que é o mesmo que

  (*x).y 

O operador -> é usado quando estamos trabalhando com um ponteiro e o ponto é usado de outra forma. Então, se nós temos uma class de estrutura como:

 struct class{ int num_students; int yr_grad; }; 

e nós temos uma instância de uma class * curr_class (ponteiro de class), então para ter access ao número de estudantes que faríamos

 cout < < curr_class->num_students < < endl; 

No caso de termos um object de class simples, digamos class_2016, faríamos

 cout < < class_2016.num_students << endl; 

Para o ponteiro classificar o operador -> é equivalente a

 (*obj).mem_var 

Nota: Para uma class, a maneira de acessar as funções de membro da class também será da mesma maneira.

O . O operador (ponto) é geralmente usado para obter um campo / chamar um método de uma instância de class (ou um campo estático / método de uma class).

p.myField, p.myMethod () – p instância de uma class

O operador -> (seta) é usado para obter um campo / chamar um método do conteúdo apontado pela class.

p-> myField, p-> myMethod () – p aponta para uma class

O -> é simplesmente açúcar sintático para uma referência de ponteiro,

Como outros disseram:

ponteiro-> método ();

é um método simples de dizer:

(ponteiro *) .method ();

Para mais diversão ponteiro, confira Binky, e sua varinha mágica de desreferenciação:

http://www.youtube.com/watch?v=UvoHwFvAvQE

A diferença mais simples entre os dois é que “->” desreferencia um ponteiro antes de analisar os campos de objects, a function etc. enquanto “.” não desreferencia primeiro. Use “->” quando você tiver um ponteiro para um object e use “.” quando você está trabalhando com a instância real de um object.

Outra maneira equivalente de destruir isso pode ser usar o dereferenciamento “*” no ponteiro primeiro e depois usar o “.”. Nós pulamos o intermediário usando “->”.

Existem outras diferenças, mas as outras respostas cobriram isso extensivamente.

Se você tem experiência em Java, isso pode confundi-lo, já que, em Java, tudo é pointers. Isso significa que não há razão para ter um símbolo que não apague seu ponteiro primeiro. Em c ++, porém, você precisa ser um pouco mais cuidadoso ao lembrar o que é e o que não é um ponteiro, e pode ser uma boa ideia rotulá-los com o prefixo “p_” ou simplesmente “p”.