C++ 我是否应该使用枚举作为专门化的模板参数？

我正在尝试删除代码重复。我有两个类，它们做的事情几乎相同，但类型不同

因此，我根据一个成员的类型创建了一个类模板，并添加了trait类来查找另一个成员的相应类型

现在我刚刚发现，对于我的一个类型，有一个enum成员，用于在一个或两个位置调用不同的函数

所以我的traits结构不再工作了，因为它的模板参数是成员的类型，但现在我需要两个不同的专门化，这取决于另一个成员

概括地说，我现在有三组代码，它们做的事情与我可以使用模板重构的几乎相同，但是没有专门化所基于的类型

我应该为这三种类型创建一个枚举并将其用作模板参数，还是有不同的规范解决方案

编辑：代码示例！它原来很长，但我想要一些编译的东西

// original state

#include <iostream>
#include <string>


class Foo {
public:
  std::string GetFooAttributes() {
    return "<Foo attributes>";
  }
};

class Bar {
public:
  std::string GetSomeAttributes() {
    return "<Some Bar attributes>";
  }
  std::string GetOtherAttributes() {
    return "<Other Bar attributes>";
  }
};

enum BarAttrType { SomeBarAttrs, OtherBarAttrs };

class FooLogger {
  Foo mFoo;
public:
  FooLogger(Foo foo) : mFoo(foo) {};
  /* a lot of code */
  void log() {
    std::cout << mFoo.GetFooAttributes() << std::endl;
  }
};

class BarLogger {
  Bar mBar;
  BarAttrType mAttrType;
public:
  BarLogger(Bar bar, BarAttrType attrType) : mBar(bar), mAttrType(attrType) {};
  /* a lot of code that looks pretty much like in FooLogger */
  void log() {
    if(mAttrType) {
      std::cout << mBar.GetOtherAttributes() << std::endl;
    } else {
      std::cout << mBar.GetSomeAttributes() << std::endl;
    }
  }
};





// current template solution

template <typename LOGOBJECT>
std::string GetAttributesHelper(LOGOBJECT logObject) {};

template <>
std::string GetAttributesHelper<Foo>(Foo foo) {
  return foo.GetFooAttributes();
}

template <>
std::string GetAttributesHelper<Bar>(Bar bar) {
  return bar.GetSomeAttributes();
  /* return bar.GetOtherAttributes ...sometimes */
}



template <typename LOGOBJECT>
class Logger {
  LOGOBJECT mLogObject;
public:
  Logger(LOGOBJECT logObject) : mLogObject(logObject) {};
  /* other code that is pretty similar in all cases */
  void log() {
    std::cout << GetAttributesHelper(mLogObject) << std::endl;
  }
};



int main(int argc, char* argv[])
{
  Foo myFoo;
  Bar myBar;

  // old solution
  FooLogger fooLogger(myFoo);
  fooLogger.log();
  BarLogger someBarLogger(myBar, SomeBarAttrs);
  someBarLogger.log();
  BarLogger otherBarLogger(myBar, OtherBarAttrs);
  otherBarLogger.log();

  // new solution
  Logger<Foo> tFooLogger(myFoo);
  tFooLogger.log();
  Logger<Bar> tSomeBarLogger(myBar);
  tSomeBarLogger.log();
  //Logger<Bar> otherBarLogger(myBar, OtherBarAttrs); // PROBLEM!
  //otherBarLogger.log();


  return 0;
}

//原始状态
#包括
#包括
福班{
公众：
std:：string getfootattributes（）{
返回“”；
}
};
分类栏{
公众：
std:：string GetSomeAttributes（）{
返回“”；
}
std:：string GetOtherAttributes（）{
返回“”；
}
};
枚举BarAttrType{SomeBarAttrs，OtherBarAttrs}；
类傻瓜{
福姆福；
公众：
傻瓜（Foo-Foo）：mFoo（Foo）{}；
/*很多代码*/
无效日志（）{
std:：cout在示例中的场景中，您希望生成一个函数
log（）
，该函数调用作为第一个模板参数的对象的特定成员函数

可以通过添加非类型模板参数来实现这一点，该参数包含指向要调用的成员函数的指针

template <typename T, std::string(T::*getAttributes)()>
class Logger {
  T mLogObject;
public:
  Logger(T logObject) : mLogObject(logObject) {};
  void log() {
    std::cout << (mLogObject.*getAttributes)() << std::endl;
  }
};

想提供一些示例代码吗？这使您的问题比那些描述更清楚。然而，听起来政策或CRTP可能是您所寻找的-我们需要一些代码来确认这一点。好的，给我一分钟。：）只要有一个区别。如果有更多，您将需要任何一个政策（模板参数是一种结构，它具有类似于
GetAttributes
（对于主类型，它可能具有
typedef
，并且可能是唯一的参数或是单独的参数）或CRTP（专用于派生它的类的基类模板，它可以具有任何额外的成员或其他内容）@JanHudec你有关于第一个的更详细解释的链接吗？我在维基百科上找到了CRTP。@Sarien：第一个没有什么复杂的问题。它与这个答案类似，只是没有传递
&Foo:：getfootattributes
你传递的是定义方法
GetAttributes（Foo const&）的
footattributegetter
，因此它还可以定义
GetSomethingElse（Foo-const&）
等@JanHudec因此基本上它就像一个traits结构，除了没有模板参数外，并且不是模板参数，而是作为模板参数传递结构，对吗？
  Foo myFoo;
  Bar myBar;

  Logger<Foo, &Foo::GetFooAttributes> tFooLogger(myFoo);
  tFooLogger.log();
  Logger<Bar, &Bar::GetSomeAttributes> tSomeBarLogger(myBar);
  tSomeBarLogger.log();
  Logger<Bar, &Bar::GetOtherAttributes> tOtherBarLogger(myBar);
  tOtherBarLogger.log();