Override en declaración.

[tonyasura]

Hola.

No estoy aún muy familiarizado con C++ y menos con los overrides.

Yo tengo conocimientos en Java y en este se pueden hacer overrides en las declaraciones, es decir...

Código Java:

class Base{String a(){...};}
 
Base a = new Base(){
   @override
   String a(){....}
}
 

¿De que manera se puede hacer esto en C++ sin tener que hacer una clase para cada modificación de la clase base?

Gracias.

[Instru]

No entiendo exactamente tu pregunta.

En C++ tambien puedes hacer overides. Hay 2 formas.
En la sencilla. Tienes una clase base con un método.

Cuando creas una clase hija, sólo vuelves a implementar el método que quieres anular. Al final, si usas la clase base, usas el método de la clase base, si usas la hija, se usa el método de la clase hija.

La segunda es por medio de polimorfismo. Tienes tu clase case, pero el método lo declaras virtual.

Código C++:

virtual void mi_metodo();
 

En la clase hija, lo reimplementas y listo (no es necesario volver le a poner virtual a menos que la clase hija tenga su propia clase hija y quiera implementar el método de forma diferente).

Código C++:

class Padre
{
    virtual void mi_metodo()
    {
        std::cout << "Hola padre\n";
    }
};
 
class Hijo : public Padre
{
    void mi_metodo()
    {
        std::cout << "Hola hijo\n";
    }
 
};
 
class Nieto : public Hijo
{
    void mi_metodo()
    {
        std::cout << "Hola nieto\n";
    }
 
};
 

En ese ejemplo. Un puntero o una referencia tipo Padre puede apuntar a objetos tipo Hijo o Nieto. Si desde ese puntero o referencia mandas llamar a mi_metodo(), tendras comportamientos diferentes

Código C++:

Padre *p;
p = new Padre();
p->mi_metodo(); // Imprime Hola Padre
 
p = new Hijo();
p->mi_metodo(); // Imprime Hola Hijo
 
p = new Nieto();
p->mi_metodo(); // Imprime Hola Hijo creo..... jajaja
 

Si al metodo de Hijo le pusieramos virtual, entonces daría el mensaje correcto.

Finalmente. En C++11 puedes usar overide para decirle al compilador de manera explicita que lo que quieres es anular el método padre, (como en java). Mas que nada sirve por si nos equivocamos al escribir mal el nombre o los parametros del método.

Código C++:

class Hijo : public Padre
{
    void mi_metodo() override
    {
        std::cout << "Hola hijo\n";
    }
};
 

[tonyasura]

Hola... Gracias por tu respuesta.

Respecto a ella, esas formas de overrides han sido las que he encontrado por internet. En todas ellas te ha sido necesario crear una nueva clase para hacer el override. En Java se puede hacer algo asi:

Código Java:

class Base(){
   void metodo(){};
}
 

Esto definiria la clase base. Despues podrias hacer algo asi:

Código Java:

main(){
 
Base base1 = new Base(){
@override
   void metodo(){
      System.out("este el un metodo unico para base 1");
   }
}
 
Base base2 = new Base(){
@override
   void metodo(){
      System.out("este el un metodo unico para base 2"); 
   }
}
 
}
 

Como se puede observar, no ha sido necesario crear una clase para cada una de las modicaciones del metodo "metodo", lo cual me parece muy util par no llenar un codigo de clases unicas.

Espero haberme expresado bien.

Un saludo.

[enrieto]

Hola

¿De que manera se puede hacer esto en C++ sin tener que hacer una clase para cada modificación de la clase base?

Bueno, con cada new Base(){... estás creando una nueva clase derivada anónima para cada modificación de la clase base.

Pero de todos modos, en C++, como supongo que en Java o en cualquier otro lenguaje, hay más de una manera de resolver un problema, y cada forma tendrá sus consideraciones, incluida la tan reputada "es la primera basura que se me ocurrió y quedó así".

Pensando en seguir esa línea, y creando una nueva clase derivada para cada modificación de la clase base y suponiendo que la clase Base no se puede tocar (premisa básica, creo, porque si se pudiera modificar no estaríamos dando esta vuelta), se me ocurre que podría tratar de imitarse con algo así:

Creando una clase Derivada y pasándole a cada objeto creado la función que debe usar para sobrescribir metodo():

Código C++:

#include <iostream>
#include <functional>
#include <memory>
 
class Base {
public:
    virtual void metodo() { std::cout << "metodo() en Base.\n"; }
    virtual ~Base() {}
};
 
 
class Derivada : public Base {
public:
    void set_metodo(std::function<void(void)> f) { fun = f; }
    void metodo() override { fun(); }
private:
    std::function<void(void)> fun;
};
 
 
int main()
{
    std::unique_ptr<Base> d1(new Derivada);
    (dynamic_cast<Derivada*>(d1.get()))->set_metodo([] { std::cout << "metodo() en d1.\n"; });
 
    std::unique_ptr<Base> d2(new Derivada);
    (dynamic_cast<Derivada*>(d2.get()))->set_metodo([] { std::cout << "metodo() en d2.\n"; });
 
    d1->metodo();
    d2->metodo();
 
    // también, las clases derivadas se pueden definir en el cuerpo de la función.
    struct : Base {
        void metodo() override { std::cout << "metodo() sobrescrito en d.\n"; }
    } d;
    d.metodo();
 
    struct : Base {
        void metodo() override { std::cout << "metodo() sobrescrito en e.\n"; }
    } e;
    e.metodo();
}
 

[tonyasura]

Ese codigo me sirvio de algo. Ahora tengo otra pequeña duda.

Código C++:

class Base {
 
    virtual void metodo() {
      Serial.println("codigo original");
    }
 
};
 
Base BaseAmbitoGlobal;
 
void setup() {
  Serial.begin(9600);
 
  struct : Base {
    void metodo() override {
      Serial.println("codigo override");
    }
  } b;
 
c = Base BaseAmbitoGlobal;<-------------------------???
 
}
 
void loop() {
 
 
 
 
  b->metodo();
 
  delay(1000);
 
}
 

Creando de esa manera el objeto creo que obtengo el resultado que creo. pero ahora necesitaria poder almacenar/castear ese objeto para hacerlo pasar por un objeto tipo Base, ya que con el codigo anterior lo que obtengo es un <unidentified-object>

Muchas gracias.

[eferion]

La forma correcta de heredar una clase es:

Código C++:

struct Derivada : public Base {
    void metodo() override {
      Serial.println("codigo override");
    }
  };
 

Es parecido a lo que estabas intentando pero no igual. Deberías documentarte un poco sobre la declaración y herencia de clases en C++.

Un saludo

[enrieto]

Hola; y eh! por favor no me malinterpretes, el ejemplo que puse por ahí arriba sólo pretende ser una forma de imitar el fragmento de código Java donde se crean clases anónimas derivadas de una clase Base.

Código Java:

Base base1 = new Base(){
@override
   void metodo(){
      System.out("este el un metodo unico para base 1");
   }
}
 

Entonces, mi transcripción literal en C++ venía a ser:

Código C++:

struct : Base {
   void metodo() override { std::cout << "metodo() sobrescrito en d.\n"; }
} d;
 

Igual creo que todos acá sabemos que traducir literalmente de un lenguaje a otro produce curiosos engendros mutantes.

Bay de güey, ante la duda de si algo se puede o no, si es o no correcto en C++, siempre conviene desasnarse con la documentación del estándar; por ejemplo, sobre clases anónimas:

9 Classes
9.1
... A class-specifier whose class-head omits the class-head-name defines an unnamed class ...

Así que el objeto d del ejemplo es de un tipo anónimo derivado de Base.

[eferion]

Iniciado por tonyasura

Respecto a ella, esas formas de overrides han sido las que he encontrado por internet. En todas ellas te ha sido necesario crear una nueva clase para hacer el override. En Java se puede hacer algo asi:

Java y C++ se parecen tanto como el agua y el aceite. En C++ se pueden hacer cosas imposibles en Java y viceversa. No se pueden comparar con tanto detalle porque hay áreas que directamente no son comparables.

Si no quieres tener herencia puedes usar templates:

Código C++:

template<class T>
struct Base
{
  std::string Func()
  { return T::func(); }
};
 
struct Func1
{
  static std::string func()
  { return "func1\n"; }
};
 
struct Func2
{
  static std::string func()
  { return "func2\n"; }
};
 
int main()
{
  Base<Func1> f1;
  Base<Func2> f2;
 
  std::cout << f1.Func();
  std::cout << f2.Func();
}
 

También se puede usar un functor para especificarle a la una parte del algoritmo (en la línea de lo comentado por enrieto):

Código C++:

struct Base
{
  std::string Func(std::function<std::string()> func)
  { return func(); }
};
 
std::string miFunc()
{ return "algo\n"; }
 
int main()
{
    Base b;
    
    std::cout << b.Func(miFunc);
}
 

Los dos ejemplos anteriores se pueden complicar hasta límites insospechados con tal de adaptarlos a las necesidades específicas de un proyecto.

Iniciado por tonyasura

Ese codigo me sirvio de algo. Ahora tengo otra pequeña duda.

Código C++:

class Base {
    virtual void metodo() {
      Serial.println("codigo original");
    }
 
};
 
Base BaseAmbitoGlobal;
 
void setup() {
  Serial.begin(9600);
 
  struct : Base {
    void metodo() override {
      Serial.println("codigo override");
    }
  } b;
 
c = Base BaseAmbitoGlobal;<-------------------------???
 
}
 
void loop() {
  b->metodo();
  delay(1000);
}
 

Varios errores tienes en ese código:

• En la línea que marcas, c no está definida. El compilador no va a saber qué es eso y va a dar error.
• En la línea que marcas, Base BaseAmbitoGlobal está mal. Si quieres hacer una asignación únicamente has de indicar las variables implicadas: c = BaseAmbitoGlobal;
• b->metodo();: Esta línea también tiene un problema y es que b no solo no existe en ese ámbito sino que además la que sí existe, no solo no es un puntero sino que al estar metida dentro de una función nunca va a ser accesible desde fuera.

Las variables globales son algo a evitar ya que las relaciones se pierden y se hace imposible implementar mecanismos de acceso y control.

Si tu idea es cambiar, en tiempo de ejecución, el algoritmo a ejecutar dentro de Base::metodo lo ideal es usar un std::function y pasarle dicho objeto a Base para que pueda modificar su comportamiento:

Código C++:

class Base
{
  public:
 
    Base()
      : _func(Base::metodoImpl)
    { }
 
    void metodo()
    {
      _func();
     }
 
    void SetCustomFunc(std::function<void(void)> customFunc)
    {
      _func = customFunc;
    }
 
  private:
 
    std::function<void(void)> _func;
 
    static void metodoImpl()
    { std::cout << "metodoImpl" << std::endl; }
};
 
void alternativa()
{ std::cout << "alternativa" << std::endl; }
 
int main()
{
    Base b;
    b.metodo();
    
    b.SetCustomFunc(alternativa);
    b.metodo();
}
 

Iniciado por enrieto

Así que el objeto d del ejemplo es de un tipo anónimo derivado de Base.

Pero reconoce que eso te ha funcionado de casualidad jejejejeje.

Lo normal es no encontrar declaraciones de ese estilo en C++ porque pueden ser bastante problemáticas. Ya es complicado de por sí dominar el lenguaje como para andar poniéndonos trabas cada dos por tres.