How do you declare an interface in C

Question

How do I setup a class that represents an interface   Is this just an abstract base class

User · Answer

All good answers above  One extra thing you should keep in mind - you can also have a pure virtual destructor   The only difference is that you still need to implement it     Confused          --- header file ----     class foo       public        foo             virtual  foo     0         virtual bool overrideMe    return false               ---- source ----     foo   foo                  The main reason you d want to do this is if you want to provide interface methods  as I have  but make overriding them optional     To make the class an interface class requires a pure virtual method  but all of your virtual methods have default implementations  so the only method left to make pure virtual is the destructor   Reimplementing a destructor in the derived class is no big deal at all - I always reimplement a destructor  virtual or not  in my derived classes

User · Answer

There is no concept of  interface  per se in C     AFAIK  interfaces were first introduced in Java to work around the lack of multiple inheritance   This concept has turned out to be quite useful  and the same effect can be achieved in C   by using an abstract base class   An abstract base class is a class in which at least one member function  method in Java lingo  is a pure virtual function declared using the following syntax   class A     virtual void foo     0       An abstract base class cannot be instantiated  i  e  you cannot declare an object of class A  You can only derive classes from A  but any derived class that does not provide an implementation of foo   will also be abstract   In order to stop being abstract  a derived class must provide implementations for all pure virtual functions it inherits   Note that an abstract base class can be more than an interface  because it can contain data members and member functions that are not pure virtual  An equivalent of an interface would be an abstract base class without any data with only pure virtual functions   And  as Mark Ransom pointed out  an abstract base class should provide a virtual destructor  just like any base class  for that matter

User · Answer

You can also consider contract classes implemented with the NVI  Non Virtual Interface Pattern   For instance   struct Contract1   boost  noncopyable       virtual  Contract1        void f Parameters p            assert checkFPreconditions p  amp  amp  Contract1  f  pre-condition failure                 class invariants          do f p              Check post-conditions   class invariants        private      virtual void do f Parameters p    0         class Concrete   public Contract1  public Contract2   private      virtual void do f Parameters p      From contract 1      virtual void do g Parameters p      From contract 2

User · Answer

You can also consider contract classes implemented with the NVI  Non Virtual Interface Pattern   For instance   struct Contract1   boost  noncopyable       virtual  Contract1        void f Parameters p            assert checkFPreconditions p  amp  amp  Contract1  f  pre-condition failure                 class invariants          do f p              Check post-conditions   class invariants        private      virtual void do f Parameters p    0         class Concrete   public Contract1  public Contract2   private      virtual void do f Parameters p      From contract 1      virtual void do g Parameters p      From contract 2

User · Answer

If you re using Microsoft s C   compiler  then you could do the following   struct   declspec novtable  IFoo       virtual void Bar     0      class Child   public IFoo   public      virtual void Bar   override      Do Something          I like this approach because it results in a lot smaller interface code and the generated code size can be significantly smaller  The use of novtable removes all reference to the vtable pointer in that class  so you can never instantiate it directly  See the documentation here - novtable

User · Answer

As far I could test  it is very important to add the virtual destructor  I m using objects created with new and destroyed with delete   If you do not add the virtual destructor in the interface  then the destructor of the inherited class is not called   class IBase   public      virtual  IBase          destructor  use it to call destructor of the inherit classes     virtual void Describe     0     pure virtual method     class Tester   public IBase   public      Tester std  string name       virtual  Tester        virtual void Describe    private      std  string privatename      Tester  Tester std  string name        std  cout  lt  lt   Tester constructor   lt  lt  std  endl      this- gt privatename   name     Tester   Tester         std  cout  lt  lt   Tester destructor   lt  lt  std  endl     void Tester  Describe         std  cout  lt  lt   I m Tester     lt  lt  this- gt privatename  lt  lt       lt  lt  std  endl      void descriptor IBase   obj        obj- gt Describe       int main int argc  char   argv         std  cout  lt  lt  std  endl  lt  lt   Tester Testing      lt  lt  std  endl      Tester   obj1   new Tester  Declared with Tester        descriptor obj1       delete obj1       std  cout  lt  lt  std  endl  lt  lt   IBase Testing      lt  lt  std  endl      IBase   obj2   new Tester  Declared with IBase        descriptor obj2       delete obj2          this is a bad usage of the object since it is created with  new  but there are no  delete      std  cout  lt  lt  std  endl  lt  lt   Tester not defined      lt  lt  std  endl      descriptor new Tester  Not defined           return 0      If you run the previous code without virtual  IBase        you will see that the destructor Tester   Tester   is never called

User · Answer

All good answers above  One extra thing you should keep in mind - you can also have a pure virtual destructor   The only difference is that you still need to implement it     Confused          --- header file ----     class foo       public        foo             virtual  foo     0         virtual bool overrideMe    return false               ---- source ----     foo   foo                  The main reason you d want to do this is if you want to provide interface methods  as I have  but make overriding them optional     To make the class an interface class requires a pure virtual method  but all of your virtual methods have default implementations  so the only method left to make pure virtual is the destructor   Reimplementing a destructor in the derived class is no big deal at all - I always reimplement a destructor  virtual or not  in my derived classes

User · Answer

I m still new in C   development  I started with Visual Studio  VS     Yet  no one seems to mentioned the   interface in VS   NET   I am not very sure if this is a good way to declare an interface  But it seems to provide an additional enforcement  mentioned in the documents   Such that you don t have to explicitly specify the virtual TYPE Method     0   since it will be automatically converted      interface IMyInterface      HRESULT CommitX       HRESULT get X BSTR  pbstrName           However  I don t use it because I am concern about the cross platform compilation compatibility  since it only available under  NET    If anyone do have anything interesting about it  please share   -   Thanks

User · Answer

The whole reason you have a special Interface type-category in addition to abstract base classes in C  Java is because C  Java do not support multiple inheritance     C   supports multiple inheritance  and so a special type isn t needed   An abstract base class with no non-abstract  pure virtual  methods is functionally equivalent to a C  Java interface

User · Answer

To expand on the answer by bradtgmurray   you may want to make one exception to the pure virtual method list of your interface by adding a virtual destructor  This allows you to pass pointer ownership to another party without exposing the concrete derived class  The destructor doesn t have to do anything  because the interface doesn t have any concrete members  It might seem contradictory to define a function as both virtual and inline  but trust me - it isn t   class IDemo       public          virtual  IDemo              virtual void OverrideMe     0      class Parent       public          virtual  Parent        class Child   public Parent  public IDemo       public          virtual void OverrideMe                           do stuff                You don t have to include a body for the virtual destructor - it turns out some compilers have trouble optimizing an empty destructor and you re better off using the default

User · Answer

My answer is basically the same as the others but I think there are two other important things to do    Declare a virtual destructor in your interface or make a protected non-virtual one to avoid undefined behaviours if someone tries to delete an object of type IDemo  Use virtual inheritance to avoid problems whith multiple inheritance   There is more often multiple inheritance when we use interfaces      And like other answers    Make a class with pure virtual methods  Use the interface by creating another class that overrides those virtual methods   class IDemo       public          virtual void OverrideMe     0          virtual  IDemo          Or  class IDemo       public          virtual void OverrideMe     0      protected           IDemo          And     class Child   virtual public IDemo       public          virtual void OverrideMe                           do stuff

User · Answer

The whole reason you have a special Interface type-category in addition to abstract base classes in C  Java is because C  Java do not support multiple inheritance     C   supports multiple inheritance  and so a special type isn t needed   An abstract base class with no non-abstract  pure virtual  methods is functionally equivalent to a C  Java interface

User · Answer

There is no concept of  interface  per se in C     AFAIK  interfaces were first introduced in Java to work around the lack of multiple inheritance   This concept has turned out to be quite useful  and the same effect can be achieved in C   by using an abstract base class   An abstract base class is a class in which at least one member function  method in Java lingo  is a pure virtual function declared using the following syntax   class A     virtual void foo     0       An abstract base class cannot be instantiated  i  e  you cannot declare an object of class A  You can only derive classes from A  but any derived class that does not provide an implementation of foo   will also be abstract   In order to stop being abstract  a derived class must provide implementations for all pure virtual functions it inherits   Note that an abstract base class can be more than an interface  because it can contain data members and member functions that are not pure virtual  An equivalent of an interface would be an abstract base class without any data with only pure virtual functions   And  as Mark Ransom pointed out  an abstract base class should provide a virtual destructor  just like any base class  for that matter

User · Answer

Make a class with pure virtual methods  Use the interface by creating another class that overrides those virtual methods   A pure virtual method is a class method that is defined as virtual and assigned to 0   class IDemo       public          virtual  IDemo              virtual void OverrideMe     0      class Child   public IDemo       public          virtual void OverrideMe                           do stuff

User · Answer

If you re using Microsoft s C   compiler  then you could do the following   struct   declspec novtable  IFoo       virtual void Bar     0      class Child   public IFoo   public      virtual void Bar   override      Do Something          I like this approach because it results in a lot smaller interface code and the generated code size can be significantly smaller  The use of novtable removes all reference to the vtable pointer in that class  so you can never instantiate it directly  See the documentation here - novtable

User · Answer

A little addition to what s written up there   First  make sure your destructor is also pure virtual   Second  you may want to inherit virtually  rather than normally  when you do implement  just for good measures

User · Answer

To expand on the answer by bradtgmurray   you may want to make one exception to the pure virtual method list of your interface by adding a virtual destructor  This allows you to pass pointer ownership to another party without exposing the concrete derived class  The destructor doesn t have to do anything  because the interface doesn t have any concrete members  It might seem contradictory to define a function as both virtual and inline  but trust me - it isn t   class IDemo       public          virtual  IDemo              virtual void OverrideMe     0      class Parent       public          virtual  Parent        class Child   public Parent  public IDemo       public          virtual void OverrideMe                           do stuff                You don t have to include a body for the virtual destructor - it turns out some compilers have trouble optimizing an empty destructor and you re better off using the default

User · Answer

There is no concept of  interface  per se in C     AFAIK  interfaces were first introduced in Java to work around the lack of multiple inheritance   This concept has turned out to be quite useful  and the same effect can be achieved in C   by using an abstract base class   An abstract base class is a class in which at least one member function  method in Java lingo  is a pure virtual function declared using the following syntax   class A     virtual void foo     0       An abstract base class cannot be instantiated  i  e  you cannot declare an object of class A  You can only derive classes from A  but any derived class that does not provide an implementation of foo   will also be abstract   In order to stop being abstract  a derived class must provide implementations for all pure virtual functions it inherits   Note that an abstract base class can be more than an interface  because it can contain data members and member functions that are not pure virtual  An equivalent of an interface would be an abstract base class without any data with only pure virtual functions   And  as Mark Ransom pointed out  an abstract base class should provide a virtual destructor  just like any base class  for that matter

User · Answer

All good answers above  One extra thing you should keep in mind - you can also have a pure virtual destructor   The only difference is that you still need to implement it     Confused          --- header file ----     class foo       public        foo             virtual  foo     0         virtual bool overrideMe    return false               ---- source ----     foo   foo                  The main reason you d want to do this is if you want to provide interface methods  as I have  but make overriding them optional     To make the class an interface class requires a pure virtual method  but all of your virtual methods have default implementations  so the only method left to make pure virtual is the destructor   Reimplementing a destructor in the derived class is no big deal at all - I always reimplement a destructor  virtual or not  in my derived classes

User · Answer

The whole reason you have a special Interface type-category in addition to abstract base classes in C  Java is because C  Java do not support multiple inheritance     C   supports multiple inheritance  and so a special type isn t needed   An abstract base class with no non-abstract  pure virtual  methods is functionally equivalent to a C  Java interface

User · Answer

In C  11 you can easily avoid inheritance altogether   struct Interface     explicit Interface SomeType amp  other      foo        return other my foo             bar        return other my bar                     explicit Interface SomeOtherType amp  other      foo        return other some foo             bar        return other some bar                        you can add more types here          or use a generic constructor    template lt class T gt    explicit Interface T amp  other      foo        return other foo             bar        return other bar                      const std  function lt void std  string  gt  foo    const std  function lt void std  string  gt  bar                In this case  an Interface has reference semantics  i e  you have to make sure that the object outlives the interface  it is also possible to make interfaces with value semantics     These type of interfaces have their pros and cons     They require more memory than inheritance based polymorphism   They are in general faster than inheritance based polymorphism  In those cases in which you know the final type  they are much faster   some compilers like gcc and clang perform more optimizations in types that do not have inherit from types with virtual functions     Finally  inheritance is the root of all evil in complex software design  In Sean Parent s Value Semantics and Concepts-based Polymorphism  highly recommended  better versions of this technique are explained there  the following case is studied   Say I have an application in which I deal with my shapes polymorphically using the MyShape interface   struct MyShape   virtual void my draw     0     struct Circle   MyShape   void my draw                       more shapes  e g  triangle   In your application  you do the same with different shapes using the YourShape interface   struct YourShape   virtual void your draw     0     struct Square   YourShape   void your draw                        some more shapes here      Now say you want to use some of the shapes that I ve developed in your application  Conceptually  our shapes have the same interface  but to make my shapes work in your application you would need to extend my shapes as follows   struct Circle   MyShape  YourShape      void my draw       stays the same        void your draw     my draw           First  modifying my shapes might not be possible at all  Furthermore  multiple inheritance leads the road to spaghetti code  imagine a third project comes in that is using the TheirShape interface    what happens if they also call their draw function my draw      Update  There are a couple of new references about non-inheritance based polymorphism    Sean Parent s Inheritance is the base class of evil talk  Sean Parent s Value-semantics and concept-based polymorphism talk  Pyry Jahkola s Inheritance free polymorphism talk and the poly library docs  Zach Laine s Pragmatic Type Erasure  Solving OOP Problems with an Elegant Design Pattern talk  Andrzej s C   blog - Type Erasure parts i  ii  iii  and iv  Runtime Polymorphic Generic Programming   Mixing Objects and Concepts in ConceptC   Boost TypeErasure docs Adobe Poly docs Boost Any  std  any proposal  revision 3   Boost Spirit  hold any

User · Answer

My answer is basically the same as the others but I think there are two other important things to do    Declare a virtual destructor in your interface or make a protected non-virtual one to avoid undefined behaviours if someone tries to delete an object of type IDemo  Use virtual inheritance to avoid problems whith multiple inheritance   There is more often multiple inheritance when we use interfaces      And like other answers    Make a class with pure virtual methods  Use the interface by creating another class that overrides those virtual methods   class IDemo       public          virtual void OverrideMe     0          virtual  IDemo          Or  class IDemo       public          virtual void OverrideMe     0      protected           IDemo          And     class Child   virtual public IDemo       public          virtual void OverrideMe                           do stuff

User · Answer

A little addition to what s written up there   First  make sure your destructor is also pure virtual   Second  you may want to inherit virtually  rather than normally  when you do implement  just for good measures

User · Answer

To expand on the answer by bradtgmurray   you may want to make one exception to the pure virtual method list of your interface by adding a virtual destructor  This allows you to pass pointer ownership to another party without exposing the concrete derived class  The destructor doesn t have to do anything  because the interface doesn t have any concrete members  It might seem contradictory to define a function as both virtual and inline  but trust me - it isn t   class IDemo       public          virtual  IDemo              virtual void OverrideMe     0      class Parent       public          virtual  Parent        class Child   public Parent  public IDemo       public          virtual void OverrideMe                           do stuff                You don t have to include a body for the virtual destructor - it turns out some compilers have trouble optimizing an empty destructor and you re better off using the default

User · Answer

You can also consider contract classes implemented with the NVI  Non Virtual Interface Pattern   For instance   struct Contract1   boost  noncopyable       virtual  Contract1        void f Parameters p            assert checkFPreconditions p  amp  amp  Contract1  f  pre-condition failure                 class invariants          do f p              Check post-conditions   class invariants        private      virtual void do f Parameters p    0         class Concrete   public Contract1  public Contract2   private      virtual void do f Parameters p      From contract 1      virtual void do g Parameters p      From contract 2

User · Answer

All good answers above  One extra thing you should keep in mind - you can also have a pure virtual destructor   The only difference is that you still need to implement it     Confused          --- header file ----     class foo       public        foo             virtual  foo     0         virtual bool overrideMe    return false               ---- source ----     foo   foo                  The main reason you d want to do this is if you want to provide interface methods  as I have  but make overriding them optional     To make the class an interface class requires a pure virtual method  but all of your virtual methods have default implementations  so the only method left to make pure virtual is the destructor   Reimplementing a destructor in the derived class is no big deal at all - I always reimplement a destructor  virtual or not  in my derived classes

User · Answer

class Shape    public        pure virtual function providing interface framework     virtual int getArea     0     void setWidth int w             width   w          void setHeight int h             height   h       protected      int width      int height      class Rectangle  public Shape   public      int getArea                  return  width   height             class Triangle  public Shape   public      int getArea                  return  width   height  2             int main void         Rectangle Rect       Triangle  Tri        Rect setWidth 5        Rect setHeight 7         cout  lt  lt   Rectangle area     lt  lt  Rect getArea    lt  lt  endl        Tri setWidth 5        Tri setHeight 7         cout  lt  lt   Triangle area     lt  lt  Tri getArea    lt  lt  endl         return 0      Result  Rectangle area  35 Triangle area  17  We have seen how an abstract class defined an interface in terms of getArea   and two other classes implemented same function but with different algorithm to calculate the area specific to the shape

User · Answer

In C  11 you can easily avoid inheritance altogether   struct Interface     explicit Interface SomeType amp  other      foo        return other my foo             bar        return other my bar                     explicit Interface SomeOtherType amp  other      foo        return other some foo             bar        return other some bar                        you can add more types here          or use a generic constructor    template lt class T gt    explicit Interface T amp  other      foo        return other foo             bar        return other bar                      const std  function lt void std  string  gt  foo    const std  function lt void std  string  gt  bar                In this case  an Interface has reference semantics  i e  you have to make sure that the object outlives the interface  it is also possible to make interfaces with value semantics     These type of interfaces have their pros and cons     They require more memory than inheritance based polymorphism   They are in general faster than inheritance based polymorphism  In those cases in which you know the final type  they are much faster   some compilers like gcc and clang perform more optimizations in types that do not have inherit from types with virtual functions     Finally  inheritance is the root of all evil in complex software design  In Sean Parent s Value Semantics and Concepts-based Polymorphism  highly recommended  better versions of this technique are explained there  the following case is studied   Say I have an application in which I deal with my shapes polymorphically using the MyShape interface   struct MyShape   virtual void my draw     0     struct Circle   MyShape   void my draw                       more shapes  e g  triangle   In your application  you do the same with different shapes using the YourShape interface   struct YourShape   virtual void your draw     0     struct Square   YourShape   void your draw                        some more shapes here      Now say you want to use some of the shapes that I ve developed in your application  Conceptually  our shapes have the same interface  but to make my shapes work in your application you would need to extend my shapes as follows   struct Circle   MyShape  YourShape      void my draw       stays the same        void your draw     my draw           First  modifying my shapes might not be possible at all  Furthermore  multiple inheritance leads the road to spaghetti code  imagine a third project comes in that is using the TheirShape interface    what happens if they also call their draw function my draw      Update  There are a couple of new references about non-inheritance based polymorphism    Sean Parent s Inheritance is the base class of evil talk  Sean Parent s Value-semantics and concept-based polymorphism talk  Pyry Jahkola s Inheritance free polymorphism talk and the poly library docs  Zach Laine s Pragmatic Type Erasure  Solving OOP Problems with an Elegant Design Pattern talk  Andrzej s C   blog - Type Erasure parts i  ii  iii  and iv  Runtime Polymorphic Generic Programming   Mixing Objects and Concepts in ConceptC   Boost TypeErasure docs Adobe Poly docs Boost Any  std  any proposal  revision 3   Boost Spirit  hold any

User · Answer

Make a class with pure virtual methods  Use the interface by creating another class that overrides those virtual methods   A pure virtual method is a class method that is defined as virtual and assigned to 0   class IDemo       public          virtual  IDemo              virtual void OverrideMe     0      class Child   public IDemo       public          virtual void OverrideMe                           do stuff

User · Answer

I m still new in C   development  I started with Visual Studio  VS     Yet  no one seems to mentioned the   interface in VS   NET   I am not very sure if this is a good way to declare an interface  But it seems to provide an additional enforcement  mentioned in the documents   Such that you don t have to explicitly specify the virtual TYPE Method     0   since it will be automatically converted      interface IMyInterface      HRESULT CommitX       HRESULT get X BSTR  pbstrName           However  I don t use it because I am concern about the cross platform compilation compatibility  since it only available under  NET    If anyone do have anything interesting about it  please share   -   Thanks

User · Answer

Here is the definition of abstract class in c   standard  n4687  13 4 2     An abstract class is a class that can be used only as a base class of some other class  no objects of an abstract   class can be created except as subobjects of a class derived from it  A class is abstract if it has at least   one pure virtual function

User · Answer

As far I could test  it is very important to add the virtual destructor  I m using objects created with new and destroyed with delete   If you do not add the virtual destructor in the interface  then the destructor of the inherited class is not called   class IBase   public      virtual  IBase          destructor  use it to call destructor of the inherit classes     virtual void Describe     0     pure virtual method     class Tester   public IBase   public      Tester std  string name       virtual  Tester        virtual void Describe    private      std  string privatename      Tester  Tester std  string name        std  cout  lt  lt   Tester constructor   lt  lt  std  endl      this- gt privatename   name     Tester   Tester         std  cout  lt  lt   Tester destructor   lt  lt  std  endl     void Tester  Describe         std  cout  lt  lt   I m Tester     lt  lt  this- gt privatename  lt  lt       lt  lt  std  endl      void descriptor IBase   obj        obj- gt Describe       int main int argc  char   argv         std  cout  lt  lt  std  endl  lt  lt   Tester Testing      lt  lt  std  endl      Tester   obj1   new Tester  Declared with Tester        descriptor obj1       delete obj1       std  cout  lt  lt  std  endl  lt  lt   IBase Testing      lt  lt  std  endl      IBase   obj2   new Tester  Declared with IBase        descriptor obj2       delete obj2          this is a bad usage of the object since it is created with  new  but there are no  delete      std  cout  lt  lt  std  endl  lt  lt   Tester not defined      lt  lt  std  endl      descriptor new Tester  Not defined           return 0      If you run the previous code without virtual  IBase        you will see that the destructor Tester   Tester   is never called

User · Answer

class Shape    public        pure virtual function providing interface framework     virtual int getArea     0     void setWidth int w             width   w          void setHeight int h             height   h       protected      int width      int height      class Rectangle  public Shape   public      int getArea                  return  width   height             class Triangle  public Shape   public      int getArea                  return  width   height  2             int main void         Rectangle Rect       Triangle  Tri        Rect setWidth 5        Rect setHeight 7         cout  lt  lt   Rectangle area     lt  lt  Rect getArea    lt  lt  endl        Tri setWidth 5        Tri setHeight 7         cout  lt  lt   Triangle area     lt  lt  Tri getArea    lt  lt  endl         return 0      Result  Rectangle area  35 Triangle area  17  We have seen how an abstract class defined an interface in terms of getArea   and two other classes implemented same function but with different algorithm to calculate the area specific to the shape

User · Answer

There is no concept of  interface  per se in C     AFAIK  interfaces were first introduced in Java to work around the lack of multiple inheritance   This concept has turned out to be quite useful  and the same effect can be achieved in C   by using an abstract base class   An abstract base class is a class in which at least one member function  method in Java lingo  is a pure virtual function declared using the following syntax   class A     virtual void foo     0       An abstract base class cannot be instantiated  i  e  you cannot declare an object of class A  You can only derive classes from A  but any derived class that does not provide an implementation of foo   will also be abstract   In order to stop being abstract  a derived class must provide implementations for all pure virtual functions it inherits   Note that an abstract base class can be more than an interface  because it can contain data members and member functions that are not pure virtual  An equivalent of an interface would be an abstract base class without any data with only pure virtual functions   And  as Mark Ransom pointed out  an abstract base class should provide a virtual destructor  just like any base class  for that matter

User · Answer

While it s true that virtual is the de-facto standard to define an interface  let s not forget about the classic C-like pattern  which comes with a constructor in C     struct IButton       void   click        might be std  function void    if you prefer      IButton  void   click             click click                      call as      button  click       This has the advantage that you can re-bind events runtime without having to construct your class again  as C   does not have a syntax for changing polymorphic types  this is a workaround for chameleon classes    Tips    You might inherit from this as a base class  both virtual and non-virtual are permitted  and fill click in your descendant s constructor  You might have the function pointer as a protected member and have a public reference and or getter  As mentioned above  this allows you to switch the implementation in runtime  Thus it s a way to manage state as well  Depending on the number of ifs vs  state changes in your code  this might be faster than switch  es or ifs  turnaround is expected around 3-4 ifs  but always measure first  If you choose std  function lt  gt  over function pointers  you might be able to manage all your object data within IBase  From this point  you can have value schematics for IBase  e g   std  vector lt IBase gt  will work   Note that this might be slower depending on your compiler and STL code  also that current implementations of std  function lt  gt  tend to have an overhead when compared to function pointers or even virtual functions  this might change in the future

User · Answer

To expand on the answer by bradtgmurray   you may want to make one exception to the pure virtual method list of your interface by adding a virtual destructor  This allows you to pass pointer ownership to another party without exposing the concrete derived class  The destructor doesn t have to do anything  because the interface doesn t have any concrete members  It might seem contradictory to define a function as both virtual and inline  but trust me - it isn t   class IDemo       public          virtual  IDemo              virtual void OverrideMe     0      class Parent       public          virtual  Parent        class Child   public Parent  public IDemo       public          virtual void OverrideMe                           do stuff                You don t have to include a body for the virtual destructor - it turns out some compilers have trouble optimizing an empty destructor and you re better off using the default

User · Answer

A little addition to what s written up there   First  make sure your destructor is also pure virtual   Second  you may want to inherit virtually  rather than normally  when you do implement  just for good measures

User · Answer

You can also consider contract classes implemented with the NVI  Non Virtual Interface Pattern   For instance   struct Contract1   boost  noncopyable       virtual  Contract1        void f Parameters p            assert checkFPreconditions p  amp  amp  Contract1  f  pre-condition failure                 class invariants          do f p              Check post-conditions   class invariants        private      virtual void do f Parameters p    0         class Concrete   public Contract1  public Contract2   private      virtual void do f Parameters p      From contract 1      virtual void do g Parameters p      From contract 2

User · Answer

My answer is basically the same as the others but I think there are two other important things to do    Declare a virtual destructor in your interface or make a protected non-virtual one to avoid undefined behaviours if someone tries to delete an object of type IDemo  Use virtual inheritance to avoid problems whith multiple inheritance   There is more often multiple inheritance when we use interfaces      And like other answers    Make a class with pure virtual methods  Use the interface by creating another class that overrides those virtual methods   class IDemo       public          virtual void OverrideMe     0          virtual  IDemo          Or  class IDemo       public          virtual void OverrideMe     0      protected           IDemo          And     class Child   virtual public IDemo       public          virtual void OverrideMe                           do stuff

User · Answer

Here is the definition of abstract class in c   standard  n4687  13 4 2     An abstract class is a class that can be used only as a base class of some other class  no objects of an abstract   class can be created except as subobjects of a class derived from it  A class is abstract if it has at least   one pure virtual function

User · Answer

While it s true that virtual is the de-facto standard to define an interface  let s not forget about the classic C-like pattern  which comes with a constructor in C     struct IButton       void   click        might be std  function void    if you prefer      IButton  void   click             click click                      call as      button  click       This has the advantage that you can re-bind events runtime without having to construct your class again  as C   does not have a syntax for changing polymorphic types  this is a workaround for chameleon classes    Tips    You might inherit from this as a base class  both virtual and non-virtual are permitted  and fill click in your descendant s constructor  You might have the function pointer as a protected member and have a public reference and or getter  As mentioned above  this allows you to switch the implementation in runtime  Thus it s a way to manage state as well  Depending on the number of ifs vs  state changes in your code  this might be faster than switch  es or ifs  turnaround is expected around 3-4 ifs  but always measure first  If you choose std  function lt  gt  over function pointers  you might be able to manage all your object data within IBase  From this point  you can have value schematics for IBase  e g   std  vector lt IBase gt  will work   Note that this might be slower depending on your compiler and STL code  also that current implementations of std  function lt  gt  tend to have an overhead when compared to function pointers or even virtual functions  this might change in the future

User · Answer

The whole reason you have a special Interface type-category in addition to abstract base classes in C  Java is because C  Java do not support multiple inheritance     C   supports multiple inheritance  and so a special type isn t needed   An abstract base class with no non-abstract  pure virtual  methods is functionally equivalent to a C  Java interface

User · Answer

A little addition to what s written up there   First  make sure your destructor is also pure virtual   Second  you may want to inherit virtually  rather than normally  when you do implement  just for good measures

User · Answer

Make a class with pure virtual methods  Use the interface by creating another class that overrides those virtual methods   A pure virtual method is a class method that is defined as virtual and assigned to 0   class IDemo       public          virtual  IDemo              virtual void OverrideMe     0      class Child   public IDemo       public          virtual void OverrideMe                           do stuff

User · Answer

My answer is basically the same as the others but I think there are two other important things to do    Declare a virtual destructor in your interface or make a protected non-virtual one to avoid undefined behaviours if someone tries to delete an object of type IDemo  Use virtual inheritance to avoid problems whith multiple inheritance   There is more often multiple inheritance when we use interfaces      And like other answers    Make a class with pure virtual methods  Use the interface by creating another class that overrides those virtual methods   class IDemo       public          virtual void OverrideMe     0          virtual  IDemo          Or  class IDemo       public          virtual void OverrideMe     0      protected           IDemo          And     class Child   virtual public IDemo       public          virtual void OverrideMe                           do stuff

User · Answer

Make a class with pure virtual methods  Use the interface by creating another class that overrides those virtual methods   A pure virtual method is a class method that is defined as virtual and assigned to 0   class IDemo       public          virtual  IDemo              virtual void OverrideMe     0      class Child   public IDemo       public          virtual void OverrideMe                           do stuff

[c++] How do you declare an interface in C++?

Examples related to c++

Examples related to inheritance

Examples related to interface

Examples related to abstract-class

Examples related to pure-virtual