如何在 C++ 中实现干净的架构组件边界？

Question

I am reading Clean Architecture by Robert C. Martin and I would like to apply the knowledge in the book to my C++ programs. One thing I don't understand, however, is how the interface boundaries are supposed to work.

The "inner layers" (business rules) are not supposed to know anything about outer layers. Meaning the things above the red line shouldn't know anything about the things below it in the image below.

But if the business rules use an C++ interface (pure abstract class) to talk to the database (the Database Interface in the image below), won't they have to include a reference to the implementation header in the "Database Access/Database" module since an abstract base class cannot be instantiated? And wouldn't that be a violation of the principle that the business rules should'nt know anything about the outer layers?

What would be the correct way to to this in c++?

Image: Figure 17.2 from Clean Architecture

Answer 1

A pure virtual interface in C++ is roughly analogous to an interface in a managed language like C# or Java:

struct DatabaseInterface {
    virtual ~DatabaseInterface();
    virtual std::string get(std::string key) = 0;
    virtual void put(const std::string& key, const std::string& value) = 0;
};

A class depending on a database can depend on an owning pointer to the abstract base class. It doesn't need to know anything about the implementation:

struct BusinessRules {
    std::unique_ptr<DatabaseInterface> db; // reference
    BusinessRules(std::unique_ptr<DatabaseInterface>);
    /* stuff using the database interface */
};

And while you can't instantiate that directly, you can have another class inherit the interface, and you can pass an instance of the concrete class to a consumer which expects a pointer to the abstract class interface:

struct SpecificDatabaseAccess: public DatabaseInterface {
    SpecificDatabaseAccess(const std::string& connectionString);
    std::string get(std::string key) override;
    void put(const std::string& key, const std::string& value) override;
};

/* ... */

// dependency injection through the constructor
auto db = std::make_unique<SpecificDatabaseAccess>("...");
auto rules = BusinessRules(std::move(db));

The standard library does something similar with istream . istream has a bunch of methods which act on top of an lower-level streambuf member. streambuf is an abstract interface whose implementations perform I/O access (to stdin, files , strings , etc).

While none of this is directly related to Clean Architecture, this is how you can make your component's implementations independent of their dependencies.