flecha - ¿Cuál es la diferencia entre el operador de punto(.) Y-> en C++?
operador punto en c (14)
El -> es simplemente azúcar sintáctica para una desreferencia de puntero,
Como han dicho otros:
puntero-> método ();
es un método simple de decir:
(* puntero) .method ();
Para más diversión de punteros, echa un vistazo a Binky, y su varita mágica de desreferenciación:
Esta pregunta ya tiene una respuesta aquí:
¿Cuál es la diferencia entre el operador de punto (.) Y -> en C ++?
El . El operador es para el acceso directo de los miembros.
object.Field
La flecha hace referencia a un puntero para que pueda acceder al objeto / memoria al que apunta
pClass->Field
El objetivo. dot funciona en objetos; La flecha trabaja en los punteros a los objetos.
std::string str("foo");
std::string * pstr = new std::string("foo");
str.size ();
pstr->size ();
El operador -> se usa cuando estamos trabajando con un puntero y el punto se usa de otra manera. Así que si tenemos una clase de estructura como:
struct class{ int num_students; int yr_grad; };
y tenemos una instancia de una clase * curr_class (puntero de clase), para obtener acceso a la cantidad de estudiantes que haríamos
cout << curr_class->num_students << endl;
En caso de que tuviéramos un objeto de clase simple, digamos class_2016, haríamos
cout << class_2016.num_students << endl;
Para el puntero a clase, el operador -> es equivalente a
(*obj).mem_var
Nota: para una clase, la forma de acceder a las funciones miembro de la clase también será la misma
El operador de flecha es como un punto, excepto que hace una referencia previa a un puntero. foo.bar() llama a la bar() método bar() en el objeto foo , foo->bar llama a la bar método en el objeto apuntado por el puntero foo .
El operador de punto no se puede sobrecargar, el operador de flecha se puede sobrecargar. El operador de flecha generalmente está destinado a ser aplicado a punteros (u objetos que se comportan como punteros, como punteros inteligentes). El operador de puntos no se puede aplicar a los punteros.
EDITAR Cuando se aplica al puntero, el operador de flecha es equivalente a aplicar el operador de punto a pointee (ptr-> field es equivalente a (* ptr) .field)
Es simple, siempre que lo veas.
x->y
saber que es lo mismo que
(*x).y
La diferencia más simple entre los dos es que "->" elimina las referencias a un puntero antes de mirar los campos de los objetos, la función, etc., mientras que "." No hace falta desreferir primero. Use "->" cuando tenga un puntero a un objeto, y use "." cuando estás trabajando con la instancia real de un objeto.
Otra forma equivalente de escribir esto podría ser usar primero la desreferenciación "*" en el puntero y luego simplemente usar ".". Nos saltamos intermediarios utilizando "->".
Hay otras diferencias, pero las otras respuestas han cubierto esto ampliamente.
Si tiene antecedentes en Java, esto podría confundirlo, ya que, en Java, todo es punteros. Esto significa que no hay razón para tener un símbolo que no elimine la referencia al puntero primero. Sin embargo, en c ++ debe ser un poco más cuidadoso al recordar qué es y qué no es un puntero, y podría ser una buena idea etiquetarlos con el prefijo "p_" o simplemente "p".
Los . El operador (punto) se usa generalmente para obtener un campo / llamar a un método desde una instancia de clase (o un campo / método estático de una clase).
p.myField, p.myMethod () - p instancia de una clase
El operador -> (flecha) se usa para obtener un campo / llamar a un método desde el contenido señalado por la clase.
p-> myField, p-> myMethod () - p apunta a una clase
Para un puntero, podríamos usar
*pointervariable.foo
Pero el . operador tiene mayor precedencia que el operador * , entonces . Se evalúa primero. Así que tenemos que forzar esto con paréntesis:
(*pointervariable).foo
Pero escribir el () ''s todo el tiempo es difícil, así que se desarrollaron -> como atajo para decir lo mismo. Si está accediendo a una propiedad de un objeto u referencia de objeto, utilice . Si está accediendo a una propiedad de un objeto a través de un puntero, use ->
Tenga en cuenta que el operador -> no se puede utilizar para ciertas cosas, por ejemplo, accediendo al operador [].
#include <vector>
int main()
{
std::vector<int> iVec;
iVec.push_back(42);
std::vector<int>* iVecPtr = &iVec;
//int i = iVecPtr->[0]; // Does not compile
int i = (*iVecPtr)[0]; // Compiles.
}
Usa -> cuando tengas puntero. Utilizar . Cuando tienes estructura (clase).
Cuando se desea el atributo de punto que pertenecen al uso de la estructura . :
structure.attribute
Cuando quiera apuntar a un atributo que tenga referencia a la memoria mediante el uso del puntero -> :
pointer->method;
o lo mismo que
(*pointer).method
foo->bar() es lo mismo que (*foo).bar() .
Los paréntesis anteriores son necesarios debido a la fuerza de unión de * y . operadores
*foo.bar() no funcionaría porque el operador del Punto ( . ) se evalúa primero (ver precedencia del operador )
El operador de punto ( . ) No puede sobrecargarse, el operador de flecha ( -> ) puede sobrecargarse.
El operador de punto ( . ) No se puede aplicar a los punteros.
También vea: ¿Cuál es el sinónimo del operador de flecha (->) en C ++?
pSomething->someMember
es equivalente a
(*pSomething).someMember