Question

我想为给定类型实例化模板函数。

template <typename T>
void foo(T arg1, float arg2, T * arg3) { ... }
...
template void foo<int>(int arg1, float arg2, int * arg3);
template void foo<float>(float arg1, float arg2, float * arg3);
...

有没有办法更自动地做到这一点？因此，例如，每次更改参数列表时，我都不需要对每种类型进行更改。

@edit

我能想到的最好的

#define RUN_MACRO( X ) \
X( float ) \
X( int )

#define INSTANTIATE(type) template void Foo<type>(type, float, type* );
RUN_MACRO( INSTANTIATE )

Answer 1

您可能会将过载变为仿函数

template <typename T>
struct foo_impl
{
    void operator ()(T, float, T*) const;
};

然后在cpp文件中你可以实例化它们

template <typename T>
void foo_impl<T>::operator ()(T arg1, float arg2, T* arg3) const
{
    // Your code
}

// instantiations where you provide only T
template struct foo_impl<int>;
template struct foo_impl<float>;

因此要拥有“相同”的接口，您可以创建处理重载的实例：

template <typename ... Ts>
struct foo_overload : foo_impl<Ts>...
{
    using foo_impl<Ts>::operator()...; // C++17
};

constexpr static foo_overload<int, float> foo;

在C ++ 17之前，您必须使用递归来使用：/

来进行可变参数

template <typename ... Ts>
struct foo_overload;

template <typename T>
struct foo_overload<T> : foo_impl<T>
{
    using foo_impl<T>::operator();
};

template <typename T, typename ... Ts>
struct foo_overload<T, Ts...> : foo_impl<T>, foo_overload<Ts...>
{
    using foo_impl<T>::operator();
    using foo_overload<Ts...>::operator();
};

Demo

但实际上我会保持标题（这是你的界面）简单：

void foo(int arg1, float arg2, int* arg3);
void foo(float arg1, float arg2, float* arg3);

和cpp：

template <typename T>
void foo_impl(T arg1, float arg2, T* arg3) { ... }

void foo(int arg1, float arg2, int* arg3) { foo_impl(arg1, arg2, arg3); }
void foo(float arg1, float arg2, float* arg3) { foo_impl(arg1, arg2, arg3);}

不同类型的模板函数的实例化

1 个答案: