c++ - 模块化 C++ 设计

Question

我正在设计一个包含多个模块的工具包。我试图让模块尽可能独立，这样它们甚至可以独立编译(例如作为一个库)。

其中一个模块是logging，另一个是geometry。现在 geometry 中的一个基类接收到一个指向 logging 对象的指针，然后使用它来记录数据:

#include "../logging/logger.h"
class GeometryBase {
    public:
      //...
      void do_something() { if (logger) logger->debug("doing something"); }
      void setLogger(Logger* logger) {//...};
    private:
      Logger* logger = nullptr;
};

为此，我需要包含 ../logging/logger.h，这意味着编译此模块需要 logging header 。有没有办法解决这个问题，所以即使 logging header 不存在，它仍然可以编译？

现在我可以想到在预处理期间使用宏来使与日志记录相关的所有部分成为条件。喜欢:

#ifdef USE_LOGGING
#include "../logging/logger.h"
#endif

class GerometryBase {
    //...
    void do_something() { if (logger) _log("doing something"); }

#ifdef USE_LOGGING
    void _log(const std::string& s) {//...}
    Logger* logger = nullptr;
#else
    void _log(const std::string& s) {// do nothing}
    void* logger = nullptr;
#endif

}; // class

是否有更好/更清洁的方法来做到这一点？是否有针对此类设计的推荐指南或最佳实践？

============================================= ===================================

更新

这是一个使用函数指针(基于 rioki 的想法)的示例实现，它确实有助于解耦对象:

对象.h

#ifndef MYOBJ_H_
#define MYOBJ_H_

#include <iostream>

class MyObj {

public:
    MyObj() { std::cout << "constructing MyObj" << std::endl;  }
    void setLogger( void (*p)(const char*, int) ) {
        logger = p;
    }

    void do_somthing() {
        if (logger) {
            logger("this is a debug message", 1);
        }
    } 

private:
    void (*logger)(const char*, int ) = nullptr;

};

#endif 

记录器.h

#ifndef LOGGER_H
#define LOGGER_H

void logger(const char* , int);

#endif

记录器.cpp

#include <iostream>
#include "logger.h"

void logger(const char* str, int lvl) {

    std::cout << "level " << lvl << " " << str << std::endl;

}

主要.cpp

#include "logger.h"
#include "obj.h"

int main() {
    MyObj obj;

    obj.setLogger(logger);
    obj.do_somthing();


    return 0;

}

输出:

constructing MyObj
level 1 this is a debug message

Answer 1

对于“这样它们甚至可以独立编译”，您只需将类声明为类即可，

class Logger;

然后您可以随意将它用于正式的结果和参数类型，但是由于编译器不知道它的大小或它的成员，您不能用它做一些事情，例如在函数实现中。

但是，将一个 header 包含在另一个 header 中与仅将其包含在一个实现文件中存在很大差异:后者对总构建时间贡献一次，而前者可能贡献多次，每个翻译单元一次。

另一方面，如果您正在制作仅包含 header 的模块，那么就没有办法包含所有相关代码。