Comprendo que la mayoría de sobrecarga de operadores, con la excepción de los estados operadores de acceso a ->, .*, ->* etc.

En particular, lo que se pasa a estas funciones de operador, y lo que debe ser devuelto?

¿Cómo funciona el operador de la función (por ejemplo,operator->(...) ) saber qué miembro se refiere? Lo puede saber? Qué se necesita saber?

Por último, ¿hay alguna const consideraciones que deben ser tomadas en cuenta? Por ejemplo, cuando la sobrecarga de algo como operator[], generalmente se necesita una constante y no const versión. Hacer que los miembros tengan acceso a los operadores requieren const y no const versiones?

  • Creo que por encima de C++-Faq toca todas las Q piden en el anterior P.
  • const y noconst versiones de operator-> no son necesarios, pero proporcionando tanto puede ser útil.
  • Véase también: yosefk.com/c++fqa/operator.html
  • La FAQ no se explica cómo la sobrecarga de ->* y .*. De hecho, ni siquiera hablar de ellas! Creo que son raras para estar en una sección de FAQ, pero yo con mucho gusto enlace a esta pregunta de las preguntas más frecuentes. por Favor, no cierre esta como una víctima de la página de preguntas frecuentes.
  • Acabo de fracasado por completo para encontrar un enlace a esta cuestión de la (impresionante) preguntas más frecuentes, y terminó pidiendo un duplicado de la pregunta. Podría usted hacer lo más obvio? (disculpas si ya es obvio).
InformationsquelleAutor Bingo | 2012-01-08

5 Comentarios

  1. 130

    ->

    Este es el único realmente complicado. Debe ser una función miembro no estático, y que no tiene argumentos. El valor de retorno se utiliza para realizar el miembro de búsqueda.

    Si el valor de retorno es otro objeto de tipo de clase, no es un puntero, luego la posterior miembro de búsqueda también es manejado por un operator-> función. Esto se llama el «drill-down comportamiento.» El lenguaje de las cadenas juntos el operator-> llamadas hasta que el último devuelve un puntero.

    struct client
        { int a; };
    
    struct proxy {
        client *target;
        client *operator->() const
            { return target; }
    };
    
    struct proxy2 {
        proxy *target;
        proxy &operator->() const
            { return * target; }
    };
    
    void f() {
        client x = { 3 };
        proxy y = { & x };
        proxy2 z = { & y };
    
        std::cout << x.a << y->a << z->a; //print "333"
    }

    ->*

    Este es sólo difícil en la que no hay nada especial acerca de ella. El no sobrecargado versión requiere un objeto de puntero a un tipo de clase en la mano izquierda y un objeto de puntero a tipo de miembro de la derecha. Pero cuando se sobrecarga, puede tomar los argumentos que te gusta y devolver todo lo que quieras. Ni siquiera tiene que ser un miembro no estático.

    En otras palabras, esta es solo una normal operador binario como +, -, y /. Ver también: Son libres de operador->* sobrecargas mal?

    .* y .

    Estos no pueden ser sobrecargados. Ya hay un built-en el sentido, cuando el lado izquierdo es del tipo de clase. Tal vez sería un poco el sentido de ser capaz de definir un puntero en la mano izquierda, pero el diseño del lenguaje comité decidió que sería más confuso que útil.

    Sobrecarga ->, ->*, ., y .* puede rellenar sólo en los casos en que una expresión sería indefinido, nunca puede cambiar el significado de una expresión que sería válido sin sobrecarga.

    • Su última afirmación no es completamente cierto. Por ejemplo, se puede sobrecargar el new operador, aunque es válida aún cuando no se vea sobrecargado.
    • bueno, new siempre está sobrecargada, o la sobrecarga de reglas de la realidad no se aplican a él (13.5/5: La asignación y desasignación de funciones, operador new, nuevo operador[], eliminación de operador y el operador delete[], se describen completamente en 3.7.4. Los atributos y restricciones de encontrar en el resto de esta subcláusula no se aplican a ellos, a menos que se indique explícitamente en 3.7.4.) Pero la sobrecarga de unario & o binario &&, ||, o ,, o la adición de sobrecargas de operator=, o sobrecargas en sólo acerca de cualquier cosa por un ámbito tipo de enumeración, puede cambiar una expresión del significado. Aclaró el comunicado, gracias!
  2. 28

    Operador -> es especial.

    «Ha adicionales, atípica restricciones: debe devolver un objeto (o una referencia a un objeto) que también tiene un puntero de eliminar operador, o debe devolver un puntero que puede ser utilizado para seleccionar el puntero de eliminar el operador flecha está apuntando.»
    Bruce Eckel: el Pensamiento CPP Vol-uno : operador->

    La funcionalidad extra se proporcionan para su comodidad, así que usted no tiene que llamar a

    a->->func();

    Usted puede simplemente hacer:

    a->func();

    Que hace el operador> diferente de los otros sobrecargas de operador.

    • Esta respuesta se merece más crédito, usted puede descargar Eckel del libro de enlace y la información está en el capítulo 12 del volumen uno.
    • el enlace está roto
  3. 23

    No se puede sobrecargar acceso de los miembros de . (es decir, la segunda parte de lo que -> hace). Sin embargo, puede sobrecargar la unario eliminar operador * (es decir, la primera parte de lo que -> hace).

    El C++ -> operador es básicamente la unión de dos pasos y esto es evidente si se piensa que x->y es equivalente a (*x).y. C++ permite personalizar qué hacer con el (*x) parte cuando x es una instancia de la clase.

    La semántica para -> la sobrecarga es algo extraño, debido a que C++ permite devolver un puntero normal (que va a ser utilizado para encontrar la punta de un objeto) o devolver una instancia de otra clase si esta clase también proporciona un -> operador. Cuando en este segundo caso, la búsqueda de la eliminan las referencias de objeto continúa de esta nueva instancia.

    • Gran explicación! Supongo que quiere decir lo mismo para ->*, ya que es equivalente a la forma de (*x).* ?
  4. 9

    La -> operador no sabe lo que los estados se señala, simplemente proporciona un objeto para realizar la real acceso de los miembros a.

    Además, no veo ninguna razón por qué usted no puede proporcionar const y no const versiones.

  5. 6

    Cuando se sobrecarga el operador>() (sin argumentos se pasan por aquí), lo que el compilador hace es llamar -> de forma recursiva hasta que se devuelve un real puntero a un tipo. A continuación, se utiliza la correcta miembro/método.

    Esto es útil, por ejemplo, para crear un puntero inteligente de la clase que encapsula el actual puntero. El operador sobrecargado-> se llama, hace lo que hace (por ejemplo, el bloqueo de rosca de seguridad), devuelve el puntero interno y, a continuación, el compilador de llamadas -> para este puntero interno.

    Como para constness – ha sido respondida en los comentarios y otras respuestas (puede, y debe, proporcionan).

Dejar respuesta

Please enter your comment!
Please enter your name here