c++ - 我应该使用枚举作为专门化的模板参数吗？

Question

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

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

现在我刚刚发现，对于我的一个类型，有一个枚举成员用于在一个或两个地方调用不同的函数。

所以我的 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;
}

Answer 1

在您的示例场景中，您想要生成一个函数 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;
  }
};

声明成员指针的语法——见第二个模板参数:ReturnType (ObjectType::*memberPointer)(ArgumentTypes...)。

通过成员指针调用成员函数的语法 - 参见log() 函数:(object.*memberPointer)(arguments...)

这就是您获取指向成员函数的指针并将其用作模板参数的方式:

  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();