策略类设计，但没有使整个用户类成为模板

to clarify, here the user class is Calculator which should not be a template. All writers can remain in headers and need not be hidden. For CRTP, it is actually needed in main to know what each writer implementation does.

#include <any>
#include <iostream>
#include <type_traits>
#include <utility> 

enum class Elem {
  HEADER,
  FOOTER,
};

template <typename Impl> class Writer_I {
public:
  template <Elem elemtype, typename... T> decltype(auto) write(T &&...args) {
    return static_cast<Impl *>(this)->template write<elemtype>(
        std::forward<T>(args)...);
  }
  virtual ~Writer_I() {}
};

class Streams : public Writer_I<Streams> {
public:
  template <Elem elemtype, std::enable_if_t<elemtype == Elem::HEADER, int> = 0>
  void write(int a) {
    std::cout << a << std::endl;
  }
  template <Elem elemtype, std::enable_if_t<elemtype == Elem::FOOTER, int> = 0>
  void write(float a) {
    std::cout << "
-------
" << a << std::endl;
  }
};

class Printf : public Writer_I<Printf>{
public:
  template <Elem elemtype, std::enable_if_t<elemtype == Elem::HEADER, int> = 0>
  void write(int a) {
    std::printf("%d
", a);
  }
  template <Elem elemtype, std::enable_if_t<elemtype == Elem::FOOTER, int> = 0>
  void write(float a) {
    std::printf("
--------
%f
", a);
  } 
};

/* Restrictions being that member functions header and footer
   remain in cpp files. And callers of Calculator's constructor
   can specify alternative implementations. */
class Calculator {
  std::any writer;

public:
  template <typename Impl>
  Calculator(Writer_I<Impl> &writer) : writer(writer) {}

  template <Elem elemtype, typename... T> void write_i(T &&...args) {
    // MAGIC_CAST ----------------------↓
    auto a = std::any_cast<Writer_I<Printf>>(writer);
    a.write<elemtype>(std::forward<T>(args)...);
  }

  void header() {
    for (int i = 0; i < 10; i++) {
      write_i<Elem::HEADER>(i);
    }
  }

  void footer() {
    write_i<Elem::FOOTER>(-100.0f);
  }
};
int main() {
  Streams streams;
//   Calculator calc_s(streams); // throws bad_cast.
//   calc_s.header();
//   calc_s.footer();


  Printf printf_;
  Calculator calc_p(printf_); 
  calc_p.header();
  calc_p.footer();
  return 0;
}

推荐答案

您的设计约束是 Calculator 不需要是模板，并且必须使用编写器进行初始化.

void header() {
  for (int i = 0; i < 10; i++) {
    write_i<Elem::HEADER>(i);
  }
}

void footer() {
  write_i<Elem::FOOTER>(-100.0f);
}

template<class T>
struct tag_t { using type=T; };
template<class T>
constexpr tag_t<T> tag = {};

template<class Sig, class Any=std::any>
struct any_type_erase;
template<class R, class...Args, class Any>
struct any_type_erase<R(Args...)> {
  std::function<R(Any&, Args&&...args)> operation;

  any_type_erase() = default;
  any_type_erase(any_type_erase const&) = default;
  any_type_erase(any_type_erase &&) = default;
  any_type_erase& operator=(any_type_erase const&) = default;
  any_type_erase& operator=(any_type_erase &&) = default;

  template<class T, class F>
  any_type_erase(tag_t<T>, F&& f) {
    operation = [f=std::forward<F>(f)](Any& object, Args&&...args)->R {
      return f(*std::any_cast<T*>(&object), std::forward<Args>(args)...);
    };
  }

  R operator()(Any& any, Args...args)const {
    return operation(any, std::forward<Args>(args)...);
  }
};

std::any writer;
any_type_erase<void(int)> print_header;
any_type_erase<void(float)> print_footer;

template<class T>
static auto invoke_writer() {
  return [](auto& writer, auto&&..args) {
    writer.write<T>(decltype(args)(args)...);
  };
}

template<typename Impl>
Calculator(Writer_I<Impl>& writer) :
  writer(writer),
  print_header( tag<Writer_I<Impl>>, invoke_writer<Elem::HEADER>() ),
  print_footer( tag<Writer_I<Impl>>, invoke_writer<Elem::FOOTER>() )
{}

void header() {
  for (int i = 0; i < 10; i++) {
    print_header( writer, i );
  }
}

void footer() {
  print_footer( writer, -100.0f );
}