How to define an interface in C++?

I'm working on a C++ class which provides an abstraction of BSD sockets for networking. I want to define an interface ISocket which is implemented by CSocket and MockSocket (the latter for unit testing). I know that I need to define the methods that I want implementing classes to provide as pure virtual, i.e.

class ISocket {
public:
  virtual int Socket(int domain, int type, int protocol) = 0;
};

What I'm worried about is whether a class of type ISocket can be instantiated. My instincts tell me that any class with at least one pure virtual method is an abstract class (i.e. interface) and cannot be instantiated, but I have a niggling worry in开发者_运维百科 the back of my mind that I need to do something about the auto-generated constructors and destructor that the C++ compiler will provide (Effective C++ is both a gift--when you remember everything you read in it--and a curse--when you don't).

Am I doing this correctly, or is there a best practise for defining interfaces in C++ that I'm not following here?

In general, you should declare a virtual destructor; otherwise you'll get into undefined behaviour if you try to invoke delete on a pointer-to-interface. There are no such issues with constructors.

Oh, and you are correct that it is not possible to instantiate an object of a class with a pure-virtual.

My instincts tell me that any class with at least one pure virtual method is an abstract class (i.e. interface) and cannot be instantiated

Your instincts are correct on this one. Types with at least one pure virtual function can't be instantiated and will generate a compiler error.

You are doing correct:An abstract class is a class that is designed to be specifically used as a base class. An abstract class contains at least one pure virtual function. You cannot instantiate a virtual class.

You are correct in thinking that any class with a pure virtual method is abstract and cannot be instantiated.

Personally I tend to add a protected destructor to most of my interfaces as in many/most cases I don't want the code that uses the interface to be able to destroy it. Alternatively you should add a public virtual destructor (not pure, with an empty body!) so that the object can be deleted via the interface pointer and the correct destructors will be called.