c++ - 如何使一个函数的返回类型与另一个函数的返回类型相同？

Question

我们的学习书上有一道关于对象函数的题。有一段c++的代码，题目要我们填空。代码如下

template <typename Arg, typename Ret> 
class FuncObj {
public:
    typedef Arg argType;
    typedef Ret retType;
    virtual Ret operator()(Arg) = 0;
};

class DivideBy : public FuncObj<int, double> {
protected:
    int divisor;
public:
    DivideBy(int d) {
        this->divisor = d;
    }
    double operator()(int x) {
        return x/((double)divisor);
    }
};

class Truncate : public FuncObj<double, int> {
public:
    int operator()(double x) {
        return (int) x;
    }
};

template < typename Ftype , typename Gtype >
class Compose : public FuncObj <typename Gtype :: argType, typename Ftype :: retType > {
protected:
    Ftype *f; Gtype *g;
public:
    Compose(Ftype f,Gtype g) {
    --------- =f;
    --------- =g; 
    }

    ---------- operator()(____________x) {
        return (_________)((________)(__________)); }
};

理想的结果是

void main() {
    DivideBy *d = new DivideBy(2);
    Truncate *t = new Truncate();
    Compose<DivideBy, Truncate> *c1 = new Compose<DivideBy,Truncate>(d,t);
    Compose<Truncate, DivideBy> *c2 = new Compose<Truncate, DivideBy>(t,d);
    cout << (*c1)(100.7) << endl; // Prints 50.0 
    cout << (*c2)(11) << endl; // Prints 5
}

我真的不知道如何完成这段代码，那么我们应该使用 c++ 的什么特性或概念来完成这段代码呢？如果有关于这个主题的进一步研究的链接，请写下来。谢谢。

Answer 1

这段代码很糟糕(如果这是 Material 的平均质量，学习书也很糟糕)。

首先，void main()不是 main 的有效签名.应该是int main()在这种情况下。二、如果Compose应该用指针构造，那么它的构造函数应该声明为Compose(Ftype* f, Gtype* g) , 不是 Compose(Ftype f, Gtype g) .三、代码应包含<iostream>和前缀 cout和 endl与 std:: (或使用 using namespace std ，但这仍然很糟糕)。最后，所有new应该有对应的delete ，但更好的做法是使用智能指针，或者根本不使用指针。

不管怎么说，填空还是比较简单的。
构造函数应该这样写:

Compose(Ftype f,Gtype g) {
    this->f = f;
    this->g = g;
}

...这很糟糕，因为它强制使用 this->不需要时(以不同方式命名参数，或使用成员初始化列表)。
调用操作符会这样写:

typename Ftype::retType operator()(typename Gtype::argType x) {
    return (*f)((*g)(x));
}

参数类型和返回类型是传递给基类的类型FuncObj作为模板参数，然后调用简单地组成 f和 g .

Demo .

不使用任何指针的更好代码如下所示:

template<typename Ftype, typename Gtype>
class Compose : public FuncObj<typename Gtype::argType, typename Ftype::retType> {
protected:
    Ftype f;
    Gtype g;
public:
    Compose(Ftype f, Gtype g)
    : f(f), g(g) {
    }

    typename Ftype::retType operator()(typename Gtype::argType x) {
        return f(g(x));
    }
};

int main() {
    auto d = DivideBy(2);
    auto t = Truncate();
    auto c1 = Compose(d, t);
    auto c2 = Compose(t, d);
    std::cout << c1(100.7) << "\n";
    std::cout << c2(11) << "\n";
}

Demo .

而不是使用类似 Java 的初始化 Type *var = new Type(args); ，只需使用值( auto var = Type(args); 或 Type var(args) )。 C++ 不是 Java。
请注意，您甚至不需要为 Compose 指定模板参数。 : 它们是从构造函数参数中推导出来的。