Question

我正在尝试删除代码重复。我有两个类，但是对于不同的类型，它们几乎完全相同。

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

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

所以我的traits struct不再起作用，因为它的模板参数是成员的类型，但现在我需要两个不同的特化，这取决于另一个成员。

总而言之，我现在有三组代码，这些代码与我使用模板重构的内容基本相同，但没有基于特殊化的类型。

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

修改：代码示例！结果很长，但我想要编译的东西。

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

我应该使用枚举作为模板参数来进行专业化吗？

1 个答案: