whirlpool - Anulando la función sobrecargada de una base en C++

whirlpool washing machine repair manual pdf

Question

Posible duplicado:
Resolución de sobrecarga de C ++

Me encontré con un problema en el que, después de que mi clase anulara una función de su clase base, todas las versiones sobrecargadas de las funciones se ocultaban. ¿Esto es por diseño o simplemente estoy haciendo algo mal?

Ex.

class foo
{
  public:
    foo(void);
    ~foo(void);
    virtual void a(int);
    virtual void a(double);
};

class bar : public foo 
{
  public:
    bar(void);
    ~bar(void);
    void a(int);
};

lo siguiente daría un error de compilación diciendo que no hay una función (doble) en la barra.

main() 
{
  double i = 0.0;
  bar b;
  b.a(i);
}

Answer 1

En la barra de clase, agregue

using foo::a;

Este es un ''gotcha'' común en C ++. Una vez que se encuentra una coincidencia de nombre en el alcance de una clase, no busca más sobre el árbol de herencia para las sobrecargas. Al especificar la declaración ''using'', traes todas las sobrecargas de ''a'' de ''foo'' al alcance de ''bar''. Entonces la sobrecarga funciona correctamente.

Tenga en cuenta que si existe un código que utiliza la clase ''foo'', su significado podría cambiarse por las sobrecargas adicionales. O las sobrecargas adicionales podrían introducir ambigüedad y el código no podrá compilarse. Esto se señala en la respuesta de James Hopkin.

Answer 2

Es por diseño. La resolución de sobrecarga está restringida a un único alcance. Previene algunos casos desagradables de cambio de significado de significado válido cuando se agregan funciones adicionales a una clase base o al ámbito de espacio de nombres.

Answer 3

Esa es la forma en que el lenguaje solía funcionar. Antes de utilizar la palabra clave, si anulaba una función sobrecargada, tenía que sobrecargarlas todas:

class bar : public foo 
{
  public:
    bar(void);
    ~bar(void);
    a(int);
    a(double d) { foo::a(d); }  // add this
}

Esto molestó a la gente que el comité de lenguaje agregó la función de uso , pero algunos viejos hábitos se ponen difíciles; y los habitués † tienen un buen argumento.

Como señala James Hopkins, al agregar el uso , el programador expresa la intención de que la clase derivada, sin previo aviso, agregue cualquier sustitución futura de foo :: a () a su lista de firmas aceptables.

Aquí hay un ejemplo de lo que él describe:

#include <iostream>
class Base {
public:
  virtual void f(double){ std::cout << "Base::Double!" << std::endl; }
  // virtual void f(int) { std::cout << "Base::Int!" << std::endl; } // (1)
  virtual ~Base() {}
};

class Derived : public Base {
public:
  // using Base::f; // (2)
  void f(double) { std::cout << "Derived::Double!" << std::endl; }
};

int main(int, char **) {
  Derived d;
  d.f(21);
  return 0;
}

El resultado será "Derivado :: ¡Doble!" porque el compilador promoverá el argumento entero a un doble. g ++ 4.0.1 -Wall no advertirá que se produjo esta promoción.

Descomentar (1) para simular un cambio futuro a Base agregando el método Base :: f (int). El código se compila, de nuevo, sin previo aviso, incluso con -Wall, y "Derived :: Double!" sigue siendo la salida.

Ahora elimine el comentario (2) para simular una decisión del programador Derived de incluir todas las firmas Base :: f. El código se compila (sin advertencias), pero el resultado ahora es "Base :: Int!".

-

† No puedo pensar en una palabra en inglés para "aquellos que tienen el hábito" y "adicto" es demasiado fuerte.