es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

  • es.davy.ai/
  • Programación /
  • Cómo utilizar la herencia múltiple para implementar distintas lógicas de comparación?

Cómo utilizar la herencia múltiple para implementar distintas lógicas de comparación?

24 Jul, 2023 Programación

Estoy tratando de usar la interfaz IComparable (no en este código de boceto) y sus 2 implementaciones para trabajar en el mismo objeto. Debo utilizar operadores para hacerlo. Me gustaría hacerlo sin resolverlo como aquí c.right::operator–().

Aquí tengo las interfaces Common y Uni, ambas heredadas por Inter. Luego tengo left y right que se mezclan en una clase personalizada que implementa tanto Common como 2 versiones de las interfaces Uni. Dos versiones diferentes significan una que utiliza el operador para llamar a f() y la otra para llamar a g().

#include<iostream>

class Common {
public:
Common() { std::cout<<“común\n”; }
};

class Uni {
public:
Uni() { std::cout<<“único\n”; }
virtual void operator–() = 0;
};

class Inter : virtual public Common, public Uni {
public:
Inter() { std::cout<<“inter\n”; }
};

class left : public Inter {
public:
left() { std::cout<<“izquierdo\n”; }
void operator–() override { f(); }
virtual void f() = 0;
};

class right : public Inter {
public:
right() { std::cout<<“derecho\n”; }
void operator–() override { g(); }
virtual void g() = 0;
};

class custom : public right, public left {
public:
custom() { std::cout<<“personalizado\n”; }
void f() override { std::cout<<“lol\n”; }
void g() override { std::cout<<“gfunc\n”; }
};

class custom2 : public right, public left {
public:
custom2() { std::cout<<“personalizado2\n”; }
void f() override { std::cout<<“lol2\n”; }
void g() override { std::cout<<“gfunc2\n”; }
};

int main()
{
custom c;
custom2 c2;

c.left::operator--();
c.right::operator--();  
c2.right::operator--();

}

Tags:  ,

Answer

  1. Avatar for davy.ai
    davy.ai

    Para evitar resolver el operador usando c.right::operator--(), puedes hacer un casting del objeto a la interfaz de implementación deseada y luego llamar directamente al operador. Por ejemplo, para llamar al método g() de la implementación right en el objeto c, puedes hacer lo siguiente:

    “`c++
    static_cast<right*>(&c)->operator–();


    Esto hará un casting del objeto `c` a un puntero de la implementación `right` y luego llamará a su método `operator--()`. De manera similar, puedes hacer un casting a la interfaz `left` para llamar al método `f()`:

```c++
static_cast<left*>(&c)->operator--();

    Ten en cuenta que si intentas hacer un casting directamente a la interfaz Uni, obtendrás un error de compilador debido a que es un casting ambiguo (debido a la herencia múltiple). Por lo tanto, debes hacer un casting a una de las clases de implementación que la hereden directamente (left o right en este ejemplo).</left></right>

Comments are closed.