Mastering C++ Interfaces: Zero‑Overhead Techniques and Practical Patterns

Interface Classification

In C++ there is no built‑in interface concept, but several techniques can be used to achieve similar functionality. Interfaces can be divided into calling interfaces and callback interfaces.

Calling Interfaces

Example Network interface definition:

class Network {
public:
    bool send(const char* host, uint16_t port, const std::string& message);
};

Various implementations:

Virtual Functions

class Network {
public:
    virtual bool send(const char* host, uint16_t port, const std::string& message) = 0;
    static Network* New();
    static void Delete(Network* network);
};

Pros: simple. Cons: runtime overhead, binary incompatibility when adding functions.

Pointer to Implementation (Pimpl)

class NetworkImpl;
class Network {
public:
    bool send(const char* host, uint16_t port, const std::string& message);
    Network();
    ~Network();
private:
    NetworkImpl* impl;
};

The implementation is hidden behind a forward‑declared class, allowing users to manage object lifetime and preserving binary compatibility.

Hidden Subclass (Zero‑Overhead)

class Network {
public:
    bool send(const char* host, uint16_t port, const std::string& message);
    static Network* New();
    static void Delete(Network* network);
protected:
    Network();
    ~Network();
};

class NetworkImpl : public Network {
    friend class Network;
private:
    // members of Network
};

bool Network::send(const char* host, uint16_t port, const std::string& message) {
    NetworkImpl* impl = (NetworkImpl*)this;
    // use impl's members
}

This approach keeps the interface class free of data members, provides static creation/destruction, and incurs no virtual‑function overhead.

Callback Interfaces

Callback interfaces let the system invoke user‑provided code.

Using Virtual Functions

class Network {
public:
    class Listener {
    public:
        virtual void onReceive(const std::string& message) = 0;
    };
    bool send(const char* host, uint16_t port, const std::string& message);
    void registerListener(Listener* listener);
};

Function Pointer

class Network {
public:
    typedef void (*OnReceive)(const std::string& message, void* arg);
    bool send(const char* host, uint16_t port, const std::string& message);
    void registerListener(OnReceive listener, void* arg);
};

std::function

class Network {
public:
    using OnReceive = std::function<void(const std::string& message)>;
    bool send(const char* host, uint16_t port, const std::string& message);
    void registerListener(const OnReceive& listener);
};

Member Function Pointer

class Network {
public:
    class Listener { public: void onReceive(const std::string& message); };
    using OnReceive = void (Listener::*)(const std::string& message);
    bool send(const char* host, uint16_t port, const std::string& message);
    void registerListener(Listener* listener, OnReceive method);
    template<typename Class>
    void registerListener(Class* listener, void (Class::*method)(const std::string& message)) {
        registerListener((Listener*)listener, (OnReceive)method);
    }
};

Non‑intrusive Interfaces

Inspired by Rust traits, a non‑intrusive interface separates data from behavior. Example Serializable trait:

class Serializable {
public:
    virtual void serialize(std::string& buffer) const = 0;
};

The Network interface can depend on Serializable without requiring the user class to inherit from a base with virtual functions:

class Network {
public:
    bool send(const char* host, uint16_t port, const Serializable& s);
};

Concrete implementations such as IntSerializable can provide serialization for primitive types without modifying the original class.