Question

在C ++中实现同一类成员函数的多个版本的最佳方法是什么，而不会使类接口混乱？

为了寻找最有效的计算方法，我经常测量同一函数的多个实现的资源需求（时间，空间等）。我应该补充说，意图是保持这些实现，即使在比较之后已经证明比另一个更好。在C ++中，我提出了一些提供以下接口的东西：

#include "foo.h"

int main(){
    Foo foo;
    foo.Print();

    foo.Add();                   // adds 1
    foo.Print();

    foo.Implementation1::Add();  // adds 10
    foo.Print();

    foo.Implementation2::Add();  // adds 100
    foo.Print();

    return 0;
}

完整代码可在Git repository中找到。虽然我喜欢这个接口在每个实现之间提供明确的区别，你可以在同一个对象上调用它，但是用于实现它的方法并不漂亮：我从派生类中访问基类中的值。这种方法要求我们创建我们想要将多个实现作为派生类的类，该类具有每个单独实现的基类。另外，我必须与基类成为朋友。我得到了鸡皮疙瘩......不......噩梦...... :)

通过将Add1()，Add2()等添加到您的类中而不会使类混乱，有多个类成员函数实现的优秀架构是什么？

Answer 1

不确定这是否正是您正在寻找的，但您可以做这样的事情。

#include <iostream>

class Foo {
    int x = 0;

    public:
    template <std::size_t N = 1>
    void add();

    void print() {
        std::cout << x << std::endl;
    }
};

template <>
void Foo::add<1>() {
    x += 1;
}

template <>
void Foo::add<2>() {
    x += 10;
}

template <>
void Foo::add<3>() {
    x += 100;
}

int main() {
    Foo f;
    f.print();

    f.add();
    f.print();

    f.add<2>();
    f.print();

    f.add<3>();
    f.print();
    return 0;
}

您可以将专业化保留在.cpp中，以避免暴露类定义中的所有实现。

Answer 2

我有一个类似的问题，我希望能够为一个函数定义不同的实现，无论它们是在库内部还是外部。 super的答案帮助我找到了以下解决方案：

#include <iostream>
#include <vector>

class foo
{
public:
  template <typename T>
  void print();
};

struct LOWERCASE;
struct UPPERCASE;

template <>
void foo::print<LOWERCASE>()
{
  std::cout << "hello world!" << std::endl;
}

template <>
void foo::print<UPPERCASE>()
{
  std::cout << "HELLO WORLD!" << std::endl;
}

int main ()
{
  foo f;
  f.print<LOWERCASE>();
  f.print<UPPERCASE>();
  // f.print<int>();
  return 0;
}

这将给出以下输出：

hello world!
HELLO WORLD!

如果未对// f.print<int>();进行注释，则编译器将抱怨如下：

对`void foo :: print（）'的未定义引用

我希望这对可能遇到类似问题的其他人有所帮助。

C ++：类函数的多个实现的最佳实践架构？

2 个答案: