使用可变参数模板函数实现基于pImpl的类包装器

6

摘要

我正在编写一个库和客户端应用程序。在库中,我试图在另一个静态链接的第三方库(具体来说是 spdlog)周围编写一个包装器,并尝试使用 pImpl 习惯用法完全隐藏它,以避免对客户端应用程序产生影响。问题是第三方库使用可变参数模板函数,因此我也需要在我的库中使用。

背景

我第一次尝试编写一个包装器时非常简单直接,但是在客户端应用程序中出现了“没有这样的文件或目录”的错误,因为第三方头文件被包含在我的库头文件中。

然后我尝试创建一个 pImpl 类,并将其编译成功,但是在客户端中仍然出现“未定义引用”的链接器错误。

将实现的源代码拉入我的包装器头文件中会让我回到最初的“没有这样的文件”问题。经过研究,我开始认为在可变参数模板周围创建包装器是不可能的,但我不确定。这是我第一次尝试制作可变函数/模板。

示例代码

这是我的项目当前的状态:

为了简洁和清晰起见,几乎所有的命名空间、函数名、头文件等都已经被编辑(或删除)。

客户端应用程序 - sandbox.cpp

#include "sandbox.h"
#include <logger.h>  //  <-- This is all I want clients to see.

int Sandbox::run() {
    LOG_INFO("Hello World!");        // My library is providing this.
    LOG_INFO("Hello {}", "indeed!"); // And, this variable input function.
    return 0;
}

我的库 - logger.h

class LoggerImp;  // Forward declaration of implementation.

class LIB_EXPORT Logger {
  public:

    /* Constructors, destructor, etc. */

    template <typename... Args>
    void info(const char * fmt, Args &... args);

    void info(const char * msg) { this->info("{}", msg); }

    /* Other logging functions: trace, error, etc. */

  private:
    LoggerImp * _imp;
};

static Logger coreLogger("Core");
static Logger clientLogger("App");

#define LOG_INFO(args...) clientLogger.info(args)
/* Other such convenience definitions. */

我的库 - logger.cpp

#include "logger.h"
#include "loggerimp.h"

Logger::Logger(std::string name) { _imp = new LoggerImp(name, this); }
Logger::~Logger() { delete _imp; }

template <typename... Args>
void Logger::info(const char * fmt, Args &... args) {
    _imp->info(fmt, args...);
}

我的库 - loggerimp.h

#include "logger.h"
#include <spdlog/spdlog.h>
#include <spdlog/sinks/stdout_color_sinks.h>

class LoggerImp {
  public:
    explicit LoggerImp(string name, Logger * pubInterface) :
        _pubInterface(pubInterface) {  // Back pointer.
        _sink   = make_shared<spdlog::sinks::stdout_color_sink_mt>();
        _logger = make_shared<spdlog::logger>(name, _sink);
        spdlog::initialize_logger(_logger);
        // The above three lines create the actual logging object
        // that my library is wrapping and hiding from its clients.
    }

    template <typename... Args>
    inline void info(const char * fmt, const Args &... args) {
        _logger->info(fmt, args...);  // Third-party logging function.
    }
}

预期结果

如上所述,我只希望我的库的客户端能够包含像<logger.h>这样的头文件,而不需要配置其项目以找到和处理我库的所有依赖项,但由于我目前正在使用一个使用可变参数模板的第三方工具,我没有看到任何方法可以隐藏它,因为模板的 "非真实函数" 性质。


2
你在一个.cpp文件中定义了Logger::info,你知道所有模板定义都需要在编译时可用吗?这就是为什么通常将它们放在头文件中的原因,包括第三方依赖项中的模板。 - super
2
pImpl和模板不兼容,pImpl隐藏了所有的实现细节,而模板根据模板参数在用户端生成代码并需要知道实现细节。我会使用C++20格式库将所有内容转换为单个字符串,然后转发到实现部分。 - JVApen
感谢回复。@super,我现在了解了。这几天我读了很多关于模板的内容。@JVApen,那个格式化库还没有正式成为C++标准的一部分,对吧?此外,我不明白使用fmtlib会如何帮助我。它已经在spdlog中了,而且它也是使用可变参数模板构建的,所以它不会给我带来我已经遇到的问题吗?...大家的共识是,在使用模板时,没有办法将第三方库隐藏起来,让客户端看不到。我只能选择向客户端公开额外的依赖项,或者推出自己的解决方案,对吧? :-( - RoboticForest
它正式被投票纳入C++20,如果我没记错的话,该版本尚未正式发布。(也许他们仍需要修改措辞)有一个GitHub仓库包含了该提议作者的完整工作版本。 - JVApen
由于format使用类似的语法甚至是相同的语法,您可以通过可变参数和格式转换为单个参数(字符串),然后将其转发到您的实现。 - JVApen
我不明白。如何解决我的问题?即使我试图在fmtlib周围创建一个包装器,我也会像使用spdlog一样向我的库客户端公开它。我的包装器需要使用可变参数来扩展到它们的可变参数,因此存在客户端依赖性。我正在尝试通过隔离我正在使用的库与我正在制作的库的客户端来“正确处理”事情,但是从我在上周末学习的所有内容来看,由于可变参数模板的本质,这看起来越来越不可能。 fmtlib和spdlog似乎无法隐藏。我的选择? - RoboticForest
1个回答

3

您可以在头文件中进行类型擦除,并在实现源文件中处理擦除后的类型。

以下是两个示例:

1. 使用std::any进行类型擦除


最初的回答:您可以在头文件中使用std::any进行类型擦除,并在实现源文件中处理擦除后的类型。
// log.hpp
#pragma once

#include <any>
#include <vector>
#include <utility>

struct Log {
  Log(int a);
  ~Log();

  template <class... A>
  void log(A&&... a) {
    log_impl({std::any(std::forward<A>(a))...});
  }

private:
  void log_impl(std::vector<std::any> v);
  struct Impl;
  Impl* impl_;
};

// log.cpp
#include "log.hpp"
#include <iostream>
#include <boost/mp11.hpp>

struct Log::Impl {
  int a;
};

void Log::log_impl(std::vector<std::any> v) {
  std::cout << impl_->a << " ";
  for (auto&& i : v) {
    bool b = false;
    using namespace boost::mp11;
    mp_for_each<mp_list<int, const char*, double>>(
        [&](auto t) {
          if (!b) {
            try {
              std::cout << std::any_cast<decltype(t)>(i) << " ";
              b = true;
            } catch (std::bad_any_cast&) {
            }
          }
        });
    if (!b) {
      std::cout << "UNKNOWN ";
    }
  }
  std::cout << std::endl;
}

Log::Log(int a) : impl_(new Log::Impl{a}) {}
Log::~Log() { delete impl_; }


// client.cpp
#include "log.hpp"

struct A {
  char a;
};
std::ostream& operator<<(std::ostream& os, const A& a) { os << a.a; }

int main() {
  Log a(555);
  a.log(11, "222");    // output: 555 11 222 
  a.log(A{'a'}, 3.3);  // output: 555 UNKNOWN 3.3 
}

2. 使用std::function进行类型擦除

最初的回答
// log.hpp
#pragma once

#include <vector>
#include <utility>
#include <functional>
#include <iostream>

struct Log {
  Log(int a);
  ~Log();

  template <class... A>
  void log(A&&... a) {
    log_impl({[&a](std::ostream& os) { os << std::forward<A>(a); }...});
  }

private:
  void log_impl(std::vector<std::function<void(std::ostream&)>> v);
  struct Impl;
  Impl* impl_;
};


// log.cpp
#include "log.hpp"
#include <iostream>

struct Log::Impl {
  int a;
};

void Log::log_impl(std::vector<std::function<void(std::ostream&)>> v) {
  std::cout << impl_->a;
  for (auto&& i : v) {
    std::cout << ' ';
    i(std::cout);
  }
  std::cout << std::endl;
}

Log::Log(int a) : impl_(new Log::Impl{a}) {}
Log::~Log() { delete impl_; }


// client.cpp
#include "log.hpp"

struct A {
  char a;
};
std::ostream& operator<<(std::ostream& os, const A& a) { os << a.a; }

int main() {
  Log a(555);
  a.log(11, "222");    // output: 555 11 222
  a.log(A{'a'}, 3.3);  // output: 555 a 3.3
}

为类型擦除的类型提供fmt::formatter

以下是一个示例,演示如何为类型擦除的类型提供fmt自定义格式化程序

namespace {
struct erased_type : std::vector<std::any> {};
} // namespace

namespace fmt {
template <>
struct formatter<erased_type> {
  template <typename ParseContext>
  constexpr auto parse(ParseContext &ctx) { return ctx.begin(); }

  template <typename FormatContext>
  auto format(const erased_type &v, FormatContext &ctx) {
    auto ctx_itr = ctx.begin();
    for (auto&& i : v) {
      bool b = false;
      using namespace boost::mp11;
      mp_for_each<mp_list<int, const char*, double>>([&](auto t) {
        if (!b) {
          try {
            format_to(ctx_itr, " {}", std::any_cast<decltype(t)>(i));
            b = true;
            ctx_itr++;
          } catch (std::bad_any_cast&) {
          }
        }
      });
      if (!b) {
        format_to(ctx_itr++, " UNKNOWN");
      }
    }
    return ctx_itr;
  }
};
}

void Log::log_impl(std::vector<std::any> v) {
  spdlog::info("{} {}", impl_->a, erased_type{std::move(v)});
}

谢谢您。我非常感激这些详细的示例,并从中学到了很多。不幸的是,这并不能避开spdlog使用可变参数模板函数的问题,尽管如果该库提供了至少一个基于列表的日志记录过程,它将完美地工作。 - RoboticForest
@RoboticForest,你可以为擦除类型 struct erased_type : std::vector<std::any>{}; 提供一个fmt自定义格式化程序 - user2709407

网页内容由stack overflow 提供, 点击上面的
可以查看英文原文,
原文链接