Question

我正在尝试设计一段需要使用算法的代码。该算法将来很容易被其他人替换。所以在我的 LargeClass 中，必须有一种方法来调用特定的算法。

我在下面提供了一些示例代码。我的想法是创建一个接口类 IAlgorithm ，这样你就必须自己提供一个实现。我以为你可以在 LargeClass 的构造函数中将它初始化为你想要的派生类。但是，由于IAlgorithm: cannot instantiate abstract class

，以下代码无法在VS2015中编译

我的问题：我应该如何设计才能获得我想要的结果？

提前致谢！

Algorithm.h

class IAlgorithm
{
protected:
    virtual int Algorithm(int, int) = 0;
};

class algo1 : public IAlgorithm
{
public:
    virtual int Algorithm(int, int);
};

class algo2 : public IAlgorithm
{
public:
    virtual int Algorithm(int, int);
};

Algorithm.cpp

#include "Algorithm.h"

int algo1::Algorithm(const int a, const int b)
{
    // Do something
}

int algo2::Algorithm(const int a, const int b)
{
    // Do something
}

Source.cpp

#include "Algorithm.h"

class LargeClass
{

private:
    IAlgorithm algo;
};

int main()
{


}

Answer 1

我对此的第一个想法是，为什么要使用这样一个原始界面？

好的，我们要求某些进程需要向其发送算法。此算法必须是多态的，必须采用两个整数并返回一个int。

一切都很好。标准库中已有一个构造。它叫std::function。这是具有兼容接口的任何函数对象的包装。

示例：

#include <functional>
#include <iostream>

class LargeClass
{
  public:

  using algorithm_type = std::function<int(int,int)>;

  LargeClass(algorithm_type algo)
  : _algo(std::move(algo))
  {}

  int apply(int x, int y) {
    return _algo(x,y);
  }

private:
    algorithm_type _algo;
};

int test(LargeClass&& lc) {
  return lc.apply(5,5);
}

int divide(int x, int y) { return x / y; }

int main()
{
  // use a lambda
  std::cout << test(LargeClass{ [](auto x,auto y){ return x + y; } });

  // use a function object
  std::cout << test(LargeClass{ std::plus<>() } );

  // use a free function
  std::cout << test(LargeClass{ divide } );

  // use a function object

  struct foo_type {
    int operator()(int x, int y) const {
      return x * 2 + y;
    }
  } foo;
  std::cout << test(LargeClass{ foo_type() } );
  std::cout << test(LargeClass{ foo } );

}

在另一个类中使用接口类作为成员类型

1 个答案: