¿Cuál es el ->sinónimo del operador de flecha ( )?
¿Cuál es el ->sinónimo del operador de flecha ( )?
Respuestas:
Las siguientes dos expresiones son equivalentes:
a->b
(*a).b
(sujeto a sobrecarga del operador, como menciona Konrad, pero eso es inusual).
a[0].blugar de (*a).b. Pero no estaría tan bien estructurado.
a->bes generalmente un sinónimo de (*a).b. Los paréntesis aquí son necesarios debido a la fuerza de enlace de los operadores *y .: *a.bno funcionaría porque se .enlaza más fuerte y se ejecuta primero. Esto es, por tanto, equivalente a *(a.b).
Sin embargo, tenga cuidado con la sobrecarga: dado que ambos ->y *pueden sobrecargarse, su significado puede diferir drásticamente.
binding strengthTe refieres a la precedencia del operador? si no, ¿cuál es la diferencia entre los dos?
El lenguaje C ++ define el operador de flecha ( ->) como sinónimo de desreferenciar un puntero y luego usa el .operador -en esa dirección.
Por ejemplo:
Si usted tiene un objeto, anObjecty un puntero, aPointer:
SomeClass anObject = new SomeClass();
SomeClass *aPointer = &anObject;
Para poder usar uno de los métodos de objetos, elimine la referencia del puntero y realice una llamada al método en esa dirección:
(*aPointer).method();Que podría escribirse con el operador de flecha:
aPointer->method();La razón principal de la existencia del operador de flecha es que acorta la escritura de una tarea muy común y también es fácil olvidar los paréntesis alrededor de la desreferenciación del puntero. Si olvidó los paréntesis, el.-Operator se vinculará más fuerte que * -operator y hará que nuestro ejemplo se ejecute como:
*(aPointer.method()); // Not our intention!Algunas de las otras respuestas también han mencionado que los operadores de C ++ pueden estar sobrecargados y que no es tan común.
new SomeClass()devuelve un puntero ( SomeClass *), no el SomeClassobjeto. Y comienzas declarando anObjecty luego aPointerusas p.
En C ++ 0x, el operador obtiene un segundo significado, que indica el tipo de retorno de una función o expresión lambda
auto f() -> int; // "->" means "returns ..."::es en realidad un operador, como .or ->, y se llama "operador de resolución de alcance" en el estándar.
-> se usa al acceder a datos a los que tiene un puntero.
Por ejemplo, podría crear un puntero ptr a una variable de tipo int intVar como este:
int* prt = &intVar;Luego, podría usar una función, como foo, en él solo desreferenciando ese puntero, para llamar a la función en la variable a la que apunta el puntero, en lugar de en el valor numérico de la ubicación de memoria de esa variable:
(*ptr).foo();Sin los paréntesis aquí, el compilador entendería que esto se *(ptr.foo())debe a la precedencia del operador, que no es lo que queremos.
En realidad, esto es lo mismo que escribir
ptr->foo();Como ->elimina la referencia a ese puntero, y así llama a la función foo()de la variable a la que apunta el puntero.
De manera similar, podemos usar ->para acceder o configurar un miembro de una clase:
myClass* ptr = &myClassMember;
ptr->myClassVar = 2;
->operador sobrecargado para algunos tipos de iteradores, por lo que tenía que usar*.. Muchas bibliotecas los definen de manera inconsistente. Se vuelve realmente molesto cuando trabaja con plantillas y no conoce el tipo exacto.