Question

请考虑以下代码：

struct Base
{
    ~Base() {}
    virtual double operator()(double x) const = 0;
};

template<typename F, typename G> struct Compose;  //forward declaration of Compose

struct Derived1 : public Base    //plus many more derived classes
{
    virtual double operator()(double x) const {return x;}
    template <typename F>
    Compose<Derived1,F> operator()(const F& f) const {return Compose<Derived1,F>(*this,f);}
};

template<typename F, typename G>
struct Compose : public Base
{
     Compose(const F &_f, const G &_g) : f(_f), g(_g) {}
     F f;
     G g;
     virtual double operator()(double x) const {return f(g(x));}
};

void test()
{
    Derived1 f,g;
    auto h=f(g);
}

这里的类组合需要两个派生类f，g并通过operator（）返回合成f（g（x））。

在某种程度上可以避免在每个派生类中使用显式定义，并在基类中添加一个函数吗？

编辑：更好地解释我在寻找的内容：原则上，我想在基类中添加如下内容

template<typename F> Compose<decltype(*this), F>
operator()(const F& f) {return Compose<decltype(*this), F>(*this,f);}

我试过这个，希望decltype（* this）自动插入派生类的类型。但它似乎不像这样......

解决方案：我终于遇到了这样做的方法，那就是通过CRTP。然后Base类采用

形式

template<typename Derived>
struct Base
{
    ~Base() {}
    virtual double operator()(double x) const = 0;

    template<typename F> Compose<Derived, F>
    operator()(const F& f) {return Compose<Derived, F>(static_cast<Derived const&>(*this),f);}
};

，派生类派生自

struct Derived1 : public Base<Derived1>

Answer 1

你的Base课程是纯粹的抽象，因此你不能这样做。您可以将Base类定义为具体类，然后在具体的Base类中定义重载的函数调用运算符。请参阅以下代码：

struct Base
{
    ~Base() {}
    virtual double operator()(double x) const {return x;}
};

struct Derived1 : public Base    //plus many more derived classes
{

};

int main()
{
  Derived1 d;
  double x = d(1);
  std::cout << x << std::endl;

  return 0;
}

Answer 2

鉴于您的Base是纯虚拟的，可以将模板功能移动到Base。所有派生类都必须实现double operator()(double x)无论如何都要实现委托。

此外，我使用了Base指针而不是实例，因为正如您所指出的那样，它在Compose结构中不起作用（可能希望更改其中的实现以减少泄漏。 ..）。

请注意，我从您的层次结构中取出了Compose（看起来它可以用于更通用的目的） - 随意将其重新放入（它将允许无限的组合）。

此外，我删除了所有const，因为struct需要为const对象提供默认的CTOR（随意将它们放入）。

我重命名了合成运算符，因为我的编译器被客户端代码中的另一个operator()蒙蔽了。

需要清理核心：

template <typename F, typename G> struct Compose
{
     Compose( F* _f,  G &_g) : f(_f), g(_g) {}
      F* f;
     G g;
     double operator()(double x)  {return (*f)(g(x));}
};

struct Base
{
    ~Base() {}
    virtual double operator()(double x) = 0;
    template <typename F> Compose<Base,F> composeMeWith(F& f)  {return Compose<Base,F>(this,f);}    
};

struct D1 : public Base 
{
    virtual double operator()(double x)  { return 1.0; }
};

struct D2 : public Base 
{
    virtual double operator()(double x)  { return 2.0; }
};

一些客户端代码：

#include <iostream>
using namespace std;

int main(int argc, char** argv) 
{
     D1 d1;
     D2 d2;

    auto ret1 = d1.composeMeWith(d2);
    auto ret2 = d2.composeMeWith(d1);

    cout << ret1(100.0) << endl;
    cout << ret2(100.0) << endl;
}

使用this-pointer在基类中的模板函数

2 个答案: