¿Qué puedo usar en lugar del operador de flecha, `->`?

¿Cuál es el ->sinónimo del operador de flecha ( )?

Las siguientes dos expresiones son equivalentes:

a->b

(*a).b

(sujeto a sobrecarga del operador, como menciona Konrad, pero eso es inusual).

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.

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.

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 ..."

Lo leo principalmente de derecha a izquierda y llamo "en"

foo->bar->baz = qux->croak

se convierte en:

"baz in bar in foo se convierte en croak in qux".

-> 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; 

Puede usar -> para definir una función.

auto fun() -> int
{
return 100;
}

No es una lambda. Realmente es una función. "->" indica el tipo de retorno de la función.