Question

我有一组这样的结构类：

template<typename T>
struct Foo {
    T x_;
    T y_;
    constexpr Foo(T x, T y) : x_{x}, y_{y} {}
};

template<typename T, typename U, template<U> class Func>
class Bar {
private:
    Foo<T> foo_;
    Func<U> func_
    size_t n_;
public:
    Bar(Foo<T> foo, size_t n, Func<U> func) :
      foo_{foo},
      n_{n},
      func_{func}
    {}
};

我正在尝试为此类模板创建演绎指南...

// Doesn't compile
template<typename T, typename U, template<U> class Func>
Bar(Foo<T>, U, Func<U>)->
Bar<T,U,Func>;

// Doesn't compile
template<typename T, typename U, template<U> class Func>
Bar(Foo<T>, U, Func)->
Bar<T,U,Func>;

当模板参数恰好是模板本身，而模板参数将是函数指针，函数对象，函子或类将存储的lambda时，我不确定该语法是否正确。

当我尝试在U中使用Func<>时，它指出“ type name不允许” ，如果我将其删除，则只是{{1} }，没有任何模板参数，它指出，“缺少模板模板参数'Func'的参数列表” ...

我对Func的预期用途如下：

Bar

编辑-此部分适用于用户：piotr-skotnicki

注意：上面是一个伪代码，其签名与我的类的表示相同...现在，我再次可以访问我的IDE，这是“真实”源代码。

Integrator.h

template<typename T>
constexpr T funcA(T x) {
    return x;
}

template<typename T>
constexpr T funcB(T x) {
    return x*x;
}

int main() {
    Bar bar1{Foo{1.0, 3.0}, 1000, funcA<double>}; 
    Bar bar2{Foo{3.7, 4.0}, 500, funcB<float>};

    return 0;
}

main.cpp

#pragma once

//#include <type_traits>

template <typename Field>
struct Limits {
    Field lower;
    Field upper;

    constexpr Limits(Field a = 0, Field b = 0) : 
        lower{ a < b ? a : b }, 
        upper{ a < b ? b : a }
    {}
};    

template <typename LimitType, typename Func>
class Integrator {       
    //static_assert(std::is_invocable_v<Func&>, "Invalid callable");
private:
    Limits<LimitType> limits_;
    size_t step_size_;
    Func integrand_;

public:
    Integrator(Limits<LimitType> limits, size_t stepSize, Func integrand) :
        limits_{ limits },
        step_size_{ stepSize },
        integrand_{ integrand }
    {}

    constexpr auto evaluate() {
        auto distance = limits_.upper - limits_.lower;     
        auto dx = distance / step_size_;       
        return calculate(dx);
    }        

private:
    template<typename ValueType>
    constexpr auto calculate(ValueType dx) {
        ValueType result = 0.0;
        for (size_t i = 0; i < step_size_; ++i) {
            auto dy = integrand_(limits_.lower + i * dx);
            auto area = dy * dx;
            result += area;
        }
        return result;
    }

};

//template <typename LimitType, typename Func>
//Integrator(Limits<LimitType>, size_t, Func)
//->Integrator<LimitType, Func>;

以前，Visual Studio抱怨无法推断出模板参数#include <iostream> #include <exception> #include "Integrator.h" double funcE(double x) { return x; } template <typename T> constexpr T funcA_t(T x) { return x; } // This Works! int main() { try { std::cout << "Integration of f(x) = x from a=3.0 to b=5.0\nwith an expected output of 8\n"; Integrator integratorA{ Limits{3.0, 5.0}, 10000, funcA }; std::cout << integratorA.evaluate() << '\n'; } catch (const std::exception& e) { std::cerr << e.what() << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } // This was failing to compile... but now seems to work for some reason... int main() { try { std::cout << "Integration of f(x) = x from a=3.0 to b=5.0\nwith an expected output of 8\n"; Integrator integratorA{ Limits{3.0, 5.0}, 10000, funcA_t<double> }; std::cout << integratorA.evaluate() << '\n'; } catch (const std::exception& e) { std::cerr << e.what() << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; } // Same as above... Integrator integrator{ Limits{3.0, 5.0}, 10000, &funcA_t<double> }; // wasn't compiling... ...，我也不知道为什么...

我不知道发生了什么...也许Visual Studio正在起作用...它现在似乎正在工作...很奇怪...

Answer 1

首先，下面的语法：

template <typename T, typename U, template <U> class Func>

并不意味着Func将具有单个 type 模板参数，与U实例本身的第二个模板参数Bar相同。

这意味着Func是一个类模板，它采用类型为U的 non-type 模板参数。如果Func需要类型模板参数，则应为：

template <typename T, typename U, template <typename> class Func>
//                                          ~~~~~~~^

以及匹配的推论指南：

template <typename T, typename U, template <typename> class Func>
Bar(Foo<T>, U, Func<U>) -> Bar<T, U, Func>;

但是，Func仍然是 template 模板参数，并且仅接受别名/类/结构模板，并且永远不会与函数指针类型或lambda表达式匹配。如果您打算将任何可调用对象存储在Bar实例中，请使用任何类型作为模板参数，并让推导指南推断出它是：

template <typename T, typename U, typename Func>
//                                ~~~~~~~^

为了确保它可以被类型为U的（左值）参数调用，只需放置一个static_assert之类的约束即可：

#include <type_traits>

template <typename T, typename U, typename Func>
class Bar {
    static_assert(std::is_invocable_v<Func&, U&>, "Invalid callable");
private:
    Foo<T> foo_;
    Func func_;
    U n_;
public:
    Bar(Foo<T> foo, U n, Func func) :
      foo_{foo},
      func_{func},
      n_{n}
    {}
};

DEMO

还请注意，您不需要明确的推论指南，因为该指南会从构造函数中隐式生成。

但是，如果您事先不知道将U用作Func的参数，那么在构造函数定义或构造函数定义中都不应将其视为问题。类定义本身。这清楚地表明该参数将从某个外部来源提供，并且您将在某个地方知道和能够验证其是否适合可调用对象。

当然，您不应尝试推断可调用对象的确切签名。在实践中这是没有用的，并且很可能意味着您的设计存在缺陷。

也就是说，一旦您最终知道使用了哪种类型的参数，就在其中放置一个static_assert，例如：

template <typename ValueType>
constexpr auto calculate(ValueType dx) {
    static_assert(std::is_invocable_v<Func&, ValueType&>, "Invalid value type");
    ValueType result = 0.0;
    // ...
    return result;
}

或者，您可以使用calculate或std::enable_if_t使requires对SFINAE友好：

template <typename ValueType>
constexpr auto calculate(ValueType dx)
    -> std::enable_if_t<std::is_invocable_v<Func&, ValueType&>, ValueType> {
    ValueType result = 0.0;
    // ...
    return result;
}

模板模板参数的推论指南

1 个答案: