Override en declaración.

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