如何将 std::generate/generate_n 与多态函数对象一起使用？

Question

我是 std::generate 的新手，并尝试构建一个使用它来初始化向量的程序。然而它的表现与我的期望不同。

我有一个抽象基类：

template <typename G>
class RandomAllele {
 public:
  RandomAllele() { /* empty */ }
  virtual ~RandomAllele() { /* empty */ }

  virtual G operator()() const = 0;
}; 

它的扩展方式（例如）：

class RandomInt : public RandomAllele<int> {
 public:
  RandomInt(int max) : max_(max) {}
  int operator()() const { return rand() % max_; }
 private:
  int max_;
};

我通过指针将继承类的实例传递给工厂类，然后将其用作 std::generate 的第三个参数：

template<typename G, typename F>
class IndividualFactory {
 public:
  IndividualFactory(int length, const RandomAllele<G> *random_allele)
      : length_(length), random_allele_(random_allele) { /* empty */ }

  individual_type *generate_random() const {
    std::vector<G> *chromosome = new std::vector<G>(length_);
    std::generate(chromosome->begin(), chromosome->end(), *random_allele_); */

    return new individual_type(chromosome);
  }
 private:
  int length_;
  RandomAllele<G> *random_allele_;
};

现在我收到错误说 RandomAllele 无法实例化，因为它是一个抽象类。当指针已经存在时，为什么generate需要实例化它？为什么它尝试使用基类而不是继承类RandomInt？

如果我将 std::generate 替换为：，则效果很好，

for(auto iter = chromosome->begin(); iter != chromosome->end(); ++iter)
  *iter = (*random_allele_)();

但我仍然希望了解为什么它的行为很奇怪，并且如果有办法做到这一点，我更愿意使用generate。

感谢您抽出时间，

里斯

Answer 1

正如其他人上面提到的，generate 和 generate_n 函数按值获取生成器对象，从而阻止您在此上下文中直接使用继承。

然而，您可以做的一个技巧是应用软件工程基本定理：

任何问题都可以通过添加另一层间接来解决

，而不是直接传入多态仿函数，而是传入一个包装仿函数，该包装仿函数存储指向该多态仿函数的指针，然后适当地转发调用。例如：

template <typename T> class IndirectFunctor {
public:
    explicit IndirectFunctor(RandomAllele<T>* f) : functor(f) {
         // Handled in initializer list
    }

    T operator() () const {
        return (*functor)();
    }

private:
    RandomAllele<T>* functor;
};

如果您随后将此对象传递给generate，如下所示：

RandomAllele<T>* functor = /* ... create an allele ... */
std::generate(begin, end, IndirectFunctor<T>(functor));

那么一切都会按预期工作。这样做的原因是，如果您按值复制 IndirectFunctor，那么您只需浅复制存储的指针，该指针仍将指向您想要的 RandomAllele称呼。这避免了您遇到的切片问题，因为它从不尝试通过基类指针直接复制 RandomAllele 类型的对象。它总是复制包装器对象，而包装器对象从不尝试复制 RandomAllele。

希望这有帮助！

Answer 2

std::generate 的生成器是按值传递的，因此是复制的。

Answer 3

一般来说，C++ 标准库实现静态多态性（模板），并且不支持函数对象的运行时多态性（虚拟方法）。这是因为它按值传递所有函数对象，假设它们是无状态或几乎无状态，这样通过指针或引用传递的附加间接方式将比按值传递更昂贵。

由于它是按值传递的，因此会导致切片，并且当您尝试使用 RandomAllele 时，它会认为您指的是那个确切的类，而不是它实际指向的任何派生类型。无需在 G 上进行模板化，只需直接在您想要的确切生成器函子类型上进行模板化即可。

Answer 4

问题是所有标准算法都按值获取参数，以符合传统的 C 约束。因此，这里的 std::generate() 算法按值获取函子。您的函子类型为 RandomAllele，属于抽象类型。是的，它是一个指向具体类型的指针，但该指针是一个抽象类型。在复制该对象时，算法调用 RandomAllele 的复制构造函数；即，算法构造抽象类型的实例。这是 C++ 语言所禁止的。

您可以告诉运行时环境不要太担心，如下所示：

RandomInt *cp = dynamic_cast<RandomInt*>(random_allele);
if( ! cp ) {
    // i thought the pointer is of RandomInt. It isn't. Err.
    std::terminate(); // or something
}
std::generate(chromosome->begin(), chromosome->end(), *cp);

Answer 5

原型是：

template <class ForwardIterator, class Generator>
void generate ( ForwardIterator first, ForwardIterator last, Generator gen );

因此 gen 是按值传递的，因此编译器尝试通过复制构造 RandomAllele，因此出现问题。

解决方案是使用信封来提供所需的间接：

template<class G>
class RandomAlleleEnvelope
{
public:
    RandomAlleleEnvelope(const RandomAllele<G>* ra)
        : ra_(ra)
    {}
      int operator()() const { return (*ra_)(); }
private:

    const RandomAllele<G>* ra_;
};

  std::generate<std::vector<int>::iterator,RandomAlleleEnvelope<int> >(chromosome->begin(), chromosome->end(), random_allele_); 

另请注意，还有另一种解决方案，定义您自己的生成以使用引用：

template <class ForwardIterator, class Generator>
  void referenceGenerate ( ForwardIterator first, ForwardIterator last, 
                           const Generator& gen )
{
  while (first != last)  *first++ = gen();
}
 referenceGenerate(chromosome->begin(), chromosome->end(), *random_allele_); 

我还认为以下应该工作，即使用标准生成并显式使其处理引用类型：

std::generate<std::vector<int>::iterator, const RandomAllele<int>& >
                   (chromosome->begin(), chromosome->end(), *random_allele_); 

我说应该是因为在 VS2010 上实例化失败。另一方面，如果我可以定义自己的：

  template <class ForwardIterator, class Generator>
  void myGenerate ( ForwardIterator first, ForwardIterator last, Generator gen )
  {
     while (first != last)  *first++ = gen();
  }
  myGenerate<std::vector<int>::iterator, const RandomAllele<int>& >
        (chromosome->begin(), chromosome->end(), *random_allele_); 

VS2010 会失败，因为它实现了 std::generate 是另一个 std::generate 的术语，它默认返回非引用参数。