Question

我有三层类，例如 BaseSpreading （基类）， IterativeMapSpreading （BaseSpreading的子类之一）和 TentSpreading ， BernoulliSpreading （IterativeMapSpreading的两个子类）。所有类中都会出现一个名为 generateSpreading 的方法。用户定义的选项指定传播，例如“ tent ”或“ bernoulli ”。然后if-else控制结构调用相应子类的generateSpreading方法（“tent”和“bernoulli”将分别调用TentSpreading和BernoulliSpreading子类的generateSpreading方法。）

我知道如何通过将generateSpreading声明为virtual并定义基类指针（到BaseSpreading）来解决我的问题。然后，可以根据用户选项在if-else控制结构内实例化派生类对象。尽管事实上这样的实例在控制结构的范围之外是不可用的，但是可以使用工厂模式将基类指针指向派生类对象，例如参见this post。虽然基于虚方法的解决方案有效，但由于其性能不佳，它对我的目的没有用。我的模拟称虚拟函数数百万次。

作为替代方法，我使用模板编程。在这种情况下，我必须处理嵌套模板类的实例在if-else结构范围之外不可用的问题。我的问题是在使用模板类时是否可以扩展工厂模式的想法。为了使这项工作成功，如果可能的话，我将不得不创建一个指向模板基类的指针，然后将其指向实例化的模板子类，该子类在if-else结构中定义。然后问题归结为为模板基类定义默认模板参数，这一直是我的难点。 This link给出了一个如何定义默认模板参数的示例，该参数不是众所周知的类型，例如“int”（链接示例的默认参数是矢量的标准“allocator”模板）。

这些是我的脚本：

base_spreading.h：

#ifndef BASE_SPREADING_H_
#define BASE_SPREADING_H_

#include <boost/filesystem.hpp>
#include <boost/filesystem/fstream.hpp>
#include <boost/numeric/ublas/vector.hpp>

template <class S>
class BaseSpreading
{
  public:
    BaseSpreading(S& spreading);

    void generateSpreading(boost::numeric::ublas::vector<double>&);
  private:
    S& spreading_;
};

template <class S>
BaseSpreading<S>::BaseSpreading(S& spreading) : spreading_(spreading) {}

template <class S>
void BaseSpreading<S>::generateSpreading(
  boost::numeric::ublas::vector<double>& spr) {
  spreading_.generateSpreading(spr);
}

#endif /* BASE_SPREADING_H_ */

spreading_iterative_map.h

#ifndef SPREADING_ITERATIVE_MAP_H_
#define SPREADING_ITERATIVE_MAP_H_

#include <boost/numeric/ublas/vector.hpp>

template <class S>
class IterativeMapSpreading
{
  public:
    IterativeMapSpreading(S& spreading);

    double evaluateMap(double);
    void generateSpreading(boost::numeric::ublas::vector<double>&);
    double sampleInitialPoint();
  private:
    S& spreading_;

    void calculateFollowingPoints(boost::numeric::ublas::vector<double>&);
};

template <class S>
IterativeMapSpreading<S>::IterativeMapSpreading(S& spreading) :
  spreading_(spreading) {}

template <class S>
void IterativeMapSpreading<S>::calculateFollowingPoints(
  boost::numeric::ublas::vector<double>& spr) {
    for (unsigned int i=1; i<spr.size(); ++i) {
      spr(i) = spreading_.evaluateMap(spr(i-1));
    }
}

template <class S>
double IterativeMapSpreading<S>::evaluateMap(double x) {
  return spreading_.evaluateMap(x);
}

template <class S>
void IterativeMapSpreading<S>::generateSpreading(
  boost::numeric::ublas::vector<double>& spr) {
  spr(0) = spreading_.sampleInitialPoint();
  calculateFollowingPoints(spr);
}

template <class S>
double IterativeMapSpreading<S>::sampleInitialPoint() {
  return spreading_.sampleInitialPoint();
}

#endif /* SPREADING_ITERATIVE_MAP_H_ */

spreading_tent.h：

#ifndef SPREADING_TENT_H_
#define SPREADING_TENT_H_

#include <math.h>

#include "random_number_generation.h"

class TentSpreading
{
  public:
    TentSpreading(double uniformMin=0, double uniformMax=1,
      double nonCentrality=0.5);

    double evaluateMap(double);
    double sampleInitialPoint();
  private:
    const double uniformMin_, uniformMax_, nonCentrality_;
    double leftIntercept_, leftSlope_, rightIntercept_, rightSlope_;
    boost::random::uniform_real_distribution<> Uniform;

    void setLines();
    void validateParameters() const;
};

#endif /* SPREADING_TENT_H_ */

spreading_tent.cpp：

#include "spreading_tent.h"

TentSpreading::TentSpreading(double uniformMin, double uniformMax,
  double nonCentrality) : uniformMin_(uniformMin), uniformMax_(uniformMax),
  nonCentrality_(nonCentrality), Uniform(uniformMin, uniformMax) {
  setLines();
}

double TentSpreading::evaluateMap(double x) {
  double y;

  if((uniformMin_<=x) && (x<nonCentrality_))
    y = leftSlope_*x+leftIntercept_;
  else if((nonCentrality_<=x) && (x<=uniformMax_))
    y = rightSlope_*x+rightIntercept_;

  return y;
}

double TentSpreading::sampleInitialPoint() {
  return Uniform(rng);
}

void TentSpreading::setLines() {
  leftSlope_ = (uniformMax_-uniformMin_)/(nonCentrality_-uniformMin_);
  leftIntercept_ = -uniformMin_*(uniformMax_-nonCentrality_)/
    (nonCentrality_-uniformMin_);
  rightSlope_ = -(uniformMax_-uniformMin_)/(uniformMax_-nonCentrality_);
  rightIntercept_ = (pow(uniformMax_, 2)-uniformMin_*nonCentrality_)/
    (uniformMax_-nonCentrality_);
}

最后，感兴趣的是main.cpp的一部分：

  try  {
    if (sbcOptions.mode=="sim-spr") {
      boost::numeric::ublas::vector<double> sprVector(3);

      if (sbcOptions.spr=="tent") {
        TentSpreading tent(-1, 1, 0);
        IterativeMapSpreading<TentSpreading> map(tent);
        BaseSpreading<IterativeMapSpreading<TentSpreading> > spreading(map);
      }

      spreading.generateSpreading(sprVector);
    }
  }
  catch(std::logic_error& logicError) {
    logTee << logicError.what() << "\n";
    return 1;
  }

为了使用工厂模式，我尝试添加一个名为FactoryBaseSpreading的抽象基类，其中BaseSpreading是一个子类。这是FactoryBaseSpreading的定义：

FactoryBaseSpreading {
  public:
    static BaseSpreading* create(std::string type);
}

FactoryBaseSpreading* FactoryBaseSpreading::create(std::string type) {
  if (type == "tent") {
    TentSpreading tent(-1, 1, 0);
    IterativeMapSpreading<TentSpreading> map(tent);
    return new BaseSpreading<IterativeMapSpreading<TentSpreading> >(map);
  }
  return NULL;
}

//Also, change the following line in base_spreading.h:
class BaseSpreading : public FactoryBaseSpreading

这样，我就可以在“main.cpp”中定义一个指向FactoryBaseSpreading的指针，并将其指向if-else结构中的相应子类，例如：

FactoryBaseSpreading* spreading;

try  {
  if (sbcOptions.mode=="sim-spr") {
    boost::numeric::ublas::vector<double> sprVector(3);

    if (sbcOptions.spr=="tent") {
      spreading = FactoryBaseSpreading::create("tent");
    }

    spreading.generateSpreading(sprVector);
  }
}
catch(std::logic_error& logicError) {
  logTee << logicError.what() << "\n";
  return 1;
}

如果我在FactoryBaseSpreading中定义了一个虚拟的generateSpreading方法，那么这个编译并运行正常。但是，我试图避免的是使用虚函数，因此工厂模式不能解决我的问题。

因此，我考虑在BaseSpreading基类中定义“create”方法，而不创建FactoryBaseSpreading抽象基类。在这种情况下，“创建”方法的定义变为：

template <class S>
BaseSpreading<S>* BaseSpreading<S>::create(std::string type) {
  if (type == "tent") {
    TentSpreading tent(-1, 1, 0);
    IterativeMapSpreading<TentSpreading> map(tent);
    return new BaseSpreading<IterativeMapSpreading<TentSpreading> >(map);
  }
  return NULL;
}

此代码的问题在于我无法再定义基类指针，因为它取决于模板参数S.例如，这是无效的：

BaseSpreading<S>* spreading;

这就是我问我是否可以在BaseSpreading的定义中提供默认参数的原因。即使我能够指定默认模板参数，我也无法在运行时切换模板参数，因为模板在编译时由编译器实例化，如here所述。所以，似乎我无法避免使用虚函数，甚至在模板元编程的帮助下也是如此。我能想到解决问题的另一种方法是通过函数指针，委托函数，或者使用函数编程完全改变我的代码设计......

Answer 1

如果我理解了所有这些，你想要基于内部循环中不会改变的东西的动态调度，并且你希望内部循环不受任何“if”语句或间接调度的影响。这可以通过对代码进行小规模重组来完成：

template<typename SPREADING>
void inner_loop(SPREADING* spreading) {
  while(something_long) {
    spreading->whatever();
  }
}

main(){
  if (opts.tentspreading) {
    TentSpreading spreading(stuff);
    inner_loop(&spreading);
  } else {
    IterativeMapSpreading spreading(other,stuff);
    inner_loop(&spreading);
  }
}

请注意，两个inner_loop（＆amp; spread）语句无法统一。实际上它们用不同的参数调用不同的函数。

模板类的工厂模式和模板类的新类型的默认参数

1 个答案: