make - cómo implementar interfaces en C++?

how to make interfaces in c++

Question

Posible duplicado:
Forma preferida de simular interfaces en C ++

Tenía curiosidad por saber si había interfaces en C ++ porque en Java, la implementación de los patrones de diseño consiste principalmente en desacoplar las clases a través de interfaces. ¿Hay una forma similar de crear interfaces en C ++?

Answer 1

C ++ no tiene conceptos integrados de interfaces. Puede implementarlo usando clases abstractas que contienen solo funciones virtuales puras . Como permite la herencia múltiple, puede heredar esta clase para crear otra clase que contendrá esta interfaz (me refiero a la interfaz de objeto :-)) en ella.

Un ejemplo de muestra sería algo como esto:

class Interface
{
public:
    Interface(){}
    virtual ~Interface(){}
    virtual void method1()=0;    // "=0" part makes this method pure virtual, and
                                 // also makes this class abstract.
    virtual void method2()=0;
};

class Concrete : public Interface
{
private:
    int myMember;

public:
    Concrete(){}
    ~Concrete(){}
    void method1();
    void method2();
};

// Provide implementation for the first method
void Concrete::method1()
{
    // Your implementation
}

// Provide implementation for the second method
void Concrete::method2()
{
    // Your implementation
}

int main(void)
{
    Interface *f = new Concrete();

    f->method1();
    f->method2();

    delete f;

    return 0;
}

Answer 2

La interfaz no es más que una clase abstracta pura en C ++. Idealmente, esta class interfaz debe contener solo métodos públicos virtual puros y datos de static const . p.ej

class interfaceA
{
public:
  static const int X = 10;
  virtual void foo () = 0
  virtual int get () const = 0;
  virtual inline ~interfaceA () = 0;
};
interfaceA::~interfaceA () {}

Answer 3

No hay concepto de interfaz en C ++,
Puede simular el comportamiento utilizando una clase abstracta .
La clase abstracta es una clase que tiene al menos una función virtual pura. No se pueden crear instancias de una clase abstracta, pero se pueden crear punteros y referencias a ella. Además, cada clase que hereda de la clase abstracta debe implementar las funciones virtuales puras para que se puedan crear instancias.