将模板变量传递到C 中的模板函数

Passing Template Variable to Template Function in C++14

本文关键字:函数 变量      更新时间:2023-10-16

我正在编写一个编译器,该编译器将C 编译为我的C 代码有类型问题。该语言本来是懒惰的,所以我们有一个懒惰的价值包装器,块。这是其中的一部分,以及有问题的代码:

#include <functional>
#include <memory>
template<class T>
class Chunk
{
public:
    Chunk();
    Chunk(std::function<T()> f);
    T operator()();
    std::function<T()> f_;
private:
    std::shared_ptr<T> cache_;
};
template<class T>
T Chunk<T>::operator()()
{
    if(cache_ == nullptr)
        cache_ = std::make_shared<T>(f_());
    return *cache_;
}
template<class T, class F>
T operator*(Chunk<T> t1, Chunk<F> t2)
{
    return t1() * t2();
}
template<class T, class... Args>
T apply(Chunk<std::function<T(Args...)>> c, Args... as)
{
    return c()(as...);
}
template<class F>
auto toChunk(F f) -> Chunk<decltype(f())>
{
    return Chunk<decltype(f())>(f);
}
template<class T, class F>
struct ops
{
    static const auto multiply =
        toChunk([]() { return ops::multiply_; });
    static const auto multiply_(Chunk<T> x, Chunk<F> y) -> decltype(x * y)
    {
        return x * y;
    }
};
int main()
{
    Chunk<double> t = toChunk([]() { return 1.0; });
    Chunk<float> f = toChunk([]() { return 2.0f; });
    apply(ops::multiply, t, f);
    return 0;
}

我无法找到multiply的定义,可以在没有used without template parameters错误的情况下进行此工作。(这里可能有第二个问题,因为multiply_不是std::function,但是编译器首先违反了模板参数。)

我可以为每对类型的类型写很多过载,但这真的很丑陋。我尝试使乘数变量变量无模板类,即使我使用的是C 14,在multiply_上获得了cannot resolve address of overloaded function,并具有此替代定义:

template<class T, class F>
auto multiply_(Chunk<T> x, Chunk<F> y) -> decltype(x * y)
{
    return x * y;
}
template<class T, class F>
Chunk<decltype(multiply_)> multiply = toChunk([]() { return multiply_; });

当然,我将ops::multiply更改为multiply。有什么建议来克服这一点?

ops是类模板的名称。要在其定义之外参考类模板的成员,您需要指定模板参数。

如果解决此错误,将会有更多。

我最终使用了完全不同的解决方案。我通过添加第二个定义来超载apply

template<class F, class... Args>
auto apply(F f, Args... as) -> decltype(f(as...))
{
    return f(as...);
}

并将其重写为简单:

auto multiply = [](auto x, auto y) { return x * y; };

因此,我们的库函数不会在懒惰的包装器中,而用户定义的功能(无法使用我们的语言中的模板)。