Qual é a diferença entre o operador ponto (.) E -> em C ++? DoCow
c # operadores de
Qual é a diferença entre o operador ponto (.) E -> em C ++?
Como eu uso o IValidatableObject? Java Array, Encontrando Duplicados Animação no notebook iPython Como faço para escrever um script bash para reiniciar um processo se ele morrer? Por que canvas.toDataURL () lança uma exceção de segurança? Que uso é a propriedade Aliases de referências de assembly no Visual Studio 8 Como posso pesquisar ramificações do Git para um arquivo ou diretório? C ++ OpenMP Paralelo Para Loop – Alternativas para std :: vector Como criar um índice consecutivo com base em uma variável de agrupamento em um dataframe JavaFX ImageView sem qualquer suavização Digitalizando annotations de Java no tempo de execução Espere até que todos os ES6 prometem promises completas, até rejeitadas Casting com segurança para int em Java Obter tipo genérico de class em tempo de execução JProgressBar não está progredindo
Existe um operador de "coalescência nula" em JavaScript?
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
(*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ê
sei que é o mesmo que
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:
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".