comment implémenter les interfaces en C++ ?

Question

Duplicata possible :
Méthode privilégiée pour simuler les interfaces en C++

J'étais curieux de savoir s'il y a des interfaces en C++ car en Java, il y a la mise en œuvre des design patterns principalement avec le découplage des classes via des interfaces. Existe-t-il un moyen similaire de créer des interfaces en C++ ?

Answer 1

Le C++ n'a pas de concepts intégrés d'interfaces. Vous pouvez l'implémenter en utilisant classes abstraites qui ne contient que fonctions virtuelles pures . Puisqu'elle permet l'héritage multiple, vous pouvez hériter de cette classe pour créer une autre classe qui contiendra alors cette interface (je veux dire, interface objet :) ).

Un exemple serait quelque chose comme ceci -

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

Une "interface" est équivalente à une classe abstraite pure en C++. Idéalement, cela interface class ne doit contenir que pur virtual public méthodes et static const les membres des données. Par exemple :

struct MyInterface
{
  static const int X = 10;

  virtual void Foo() = 0;
  virtual int Get() const = 0;
  virtual inline ~MyInterface() = 0;
};
MyInterface::~MyInterface () {}

Answer 3

Le concept d'interface n'existe pas en C++,
Vous pouvez simuler le comportement en utilisant un Classe abstraite .
Une classe abstraite est une classe qui possède au moins une fonction virtuelle pure. On ne peut pas créer d'instances d'une classe abstraite mais on peut y créer des pointeurs et des références. De plus, chaque classe héritant de la classe abstraite doit implémenter les fonctions virtuelles pures afin que ses instances puissent être créées.