4

我正在尝试将来自大型代码库的日志代码模块化，因为实时日志框架 (Apache) 使我们的代码与其紧密耦合，这使得编写单元测试变得非常困难。我被我无法拥有虚拟模板化功能的事实所困扰。我目前的做法可以总结如下：

// Context.h
struct Logger
{
    template <typename... Args>
    void operator()(const char* aFormat, Args&&... aArgs)
    {
         // This function would ideally be virtual.
         // Is there a funky way to get this function to call
         // a derived class' implementation instead.
         std::cerr << "I don't want to see this printed" << std::endl;
    }
};

class Context
{
public:
    Context(const Logger& aLogger)
    :   iLogger(aLogger)
    {
    }

    template <typename... Args>
    void DEBUG(const char* aFormat, Args&&... aArgs)
    {
        iLogger(aFormat, aArgs...);
    }

private:
    const Logger& iLogger;
};


// MyType.h
#include "Context.h"

class MyType
{
public:
    MyType(Context& aCtx)
    :   iCtx(aCtx)
    {
        DEBUG("> ctor");
        DEBUG("< ctor. this=%p", this);
    }

private:
    template <typename... Args>
    void DEBUG(const char* aFormat, Args&&... aArgs)
    {
        iCtx.DEBUG(aFormat, aArgs...);
    }

    Context& iCtx;
};


// main.cpp
#include "MyType.h"

template <typename... Args>
static void StdErrLog(const char* aFormat, Args&&... aArgs)
{
    fprintf(stderr, aFormat, aArgs...);
}

struct StdErrLogger : public Logger
{

    // This function never gets called because it's not virtual.
    template <typename... Args>
    void operator(const char* aFormat, Args&&... aArgs)
    {
        StdErrLog(aFormat, aArgs...);
    }
}

int main(...)
{
    StdErrLogger logger; // For unit tests this could be 'EmptyLogger' for example.
    Context ctx(logger);

    MyType t(ctx);
}

如此接近却又如此遥远。我有什么办法可以在不模板化Context课程的情况下完成这项工作？代码库根本没有模板化，我非常不愿意走这条路，因为这将是很多乏味的工作。

如果可以通过将模板保持在功能级别范围内来完成，我会很高兴看到解决方案。函数指针也是可以接受的，但我不确定获取可变参数模板函数地址的可行性。

谢谢

4

2 回答 2

0

我退后一步，剥掉了几层模板。原始函数指针给了我我需要的东西。nullptr如果我作为函数传递，我也希望编译器足够聪明，不会生成任何代码。缺点是每个 LogFunction 都必须做这些va_list/start/end事情。

// Context.h
typedef void (*LogFunction)(const char*, ...);

class Context
{
public:
    Context(LogFunction aDebugFunc)
    :   iDebugFunc(aDebugFunc)
    {
    }

    template <typename... Args>
    void DEBUG(const char* aFormat, Args&&... aArgs)
    {
        if (iDebugFunc)
        {
            iDebugFunc(aFormat, aArgs...);
        }
    }

private:
    LogFunction iDebugFunc;
};


// main.cpp
#include <cstdarg>

void StdErrLogger(const char* aFormat, ...)
{
    va_list args;
    va_start(args, aFormat);

    fprintf(stderr, aFormat, args);

    va_end(args);
}

int main(...)
{
    Context ctx(StdErrLogger);
    MyType t(ctx);
}
于 2013-09-07T22:00:36.017 回答
0

正如其他人已经说过的那样，模板需要被实例化，换句话说，编译器必须知道模板函数可能与一组特定的参数一起使用，从而创建函数的相应实例。

如果您想“伪造”模板函数的虚函数行为，并动态地将函数A<T>发送到B1<T>, B2<T>, B3<T>... 之一，那么您需要确保所有B函数都被实例化。为了做到这一点，实现A需要“了解”所有不同的可能Bs。然后，您可以应用类似Visitor Pattern的东西。

第二个选项是让编译器知道哪个B将用于A<T>. 在其他福特中，您Context使用ConcreteLoggerType.

第三种选择是根本不模板化s，而是以某种方式动态B处理不同的 s。TJames 描述了如何使用可变参数列表来做到这一点。

总之，您的选择是：

  1. 使用一组固定的记录器。
  2. 模板Context与Logger
  3. 使用非模板Logger

作为 C++ 模板编程功能的忠实粉丝，我倾向于第二种解决方案Policy-Based Design。

于 2013-09-08T12:11:43.787 回答