2010-11-06 63 views

Respuesta

24

Es para acceder a una función miembro o variable miembro de un objeto a través de un puntero, en contraposición a una variable regular o referencia.

Por ejemplo: con una variable o referencia regular, utiliza el operador . para acceder a funciones de miembros o variables de miembros.

std::string s = "abc"; 
std::cout << s.length() << std::endl; 

Pero si está trabajando con un puntero, es necesario utilizar el operador ->:

std::string* s = new std::string("abc"); 
std::cout << s->length() << std::endl; 

También puede sobrecargarse para realizar una función específica para un determinado tipo de objeto. Los punteros inteligentes como shared_ptr y unique_ptr, así como los iteradores de contenedor STL, sobrecargan este operador para imitar la semántica del puntero nativo.

Por ejemplo: se necesita

std::map<int, int>::iterator it = mymap.begin(), end = mymap.end(); 
for (; it != end; ++it) 
    std::cout << it->first << std::endl; 
23

a->b significa (*a).b.

Si a es un puntero, a->b es el miembro b de los cuales a puntos a.

a también puede ser un objeto similar al puntero (como un trozo de vector<bool>) que anula a los operadores.

(si usted no sabe lo que es un puntero es, usted tiene otra pregunta)

+0

A menos que sea una clase con el operador sobrecargado. –

+3

Es una pena que tenga tantos votos, ya que la sobrecarga del operador es común y una parte importante de la respuesta. –

+3

No sé qué significa (* a) .b. –

0

El operador ->, que se aplica exclusivamente a los punteros, para obtener el campo especificado o método del objeto al que hace referencia el puntero. (Esto también se aplica a structs solo para sus campos)

Si tiene una variable ptr declarada como un puntero, puede pensarlo como (*ptr).field.

Un nodo lateral que agrego solo para hacer feliz a las personas pedantes: COMO CASI CADA OPERADOR se puede definir una semántica diferente del operador al sobrecargarlo para sus clases.

+0

No se aplica exclusivamente a los punteros porque se puede sobrecargar como operador de clase. El componente puntero compartido hace esto al igual que los iteradores para contenedores en la biblioteca estándar. –

+0

sí, por supuesto puede estar sobrecargado (como todos los operadores) pero supongo que el OP necesitaba conocer la semántica original del operador. – Jack

5

x-> y puede significar 2 cosas. Si x es un puntero, significa el miembro y del objeto apuntado por x. Si x es un objeto con operador ->() sobrecargado, entonces significa x.operator ->(). operador

+0

No. Si x es un objeto con operador-> sobrecargado, significa x.operador- >(), y si el valor de retorno también admite operator->, significa x.operator ->(). operator ->(). Operador-> no tiene argumentos. – Puppy

+0

mi malo, ahora editado –

10
  1. acceso aplicable a (a) todos los tipos de puntero, (b) todos los tipos, que explícitamente sobrecargan este operador
  2. Introductor para el tipo de retorno de una expresión lambda locales:

    std::vector<MyType> seq; 
    // fill with instances... 
    std::sort(seq.begin(), seq.end(), 
          [] (const MyType& a, const MyType& b) -> bool { 
           return a.Content < b.Content; 
          }); 
    
  3. introducir un tipo de retorno de una función en la combinación de la reinventada auto:

    struct MyType { 
        // declares a member function returning std::string 
        auto foo(int) -> std::string; 
    }; 
    
+0

+1 para los tipos de devolución. – Puppy

+0

No olvide que el # 2 se aplica a todos los tipos de devolución deducidos (lambdas y no lambdas). –

+0

Agregado a la enumeración abve. No sé por qué los ejemplos del código no se muestran correctamente, si alguien sabe lo que está pasando, no dude en corregir el formato. –