Question

我在此网站上遇到了以下代码（如下）

https://www.modernescpp.com/index.php/c-insights-variadic-templates

但是此声明/定义仅适用于整数，我想编写一个可与其他类型（如float，double，std :: strings和用户定义的类型，这些类型重载“ +”运算符）一起使用的版本。但是我在努力写一个。

请注意，提到的站点具有基于可变参数函数模板的解决方案，该解决方案可与包括浮点类型在内的不同数据类型一起使用（尚未尝试使用用户定义的类型）。我正在寻找基于可变参数模板类的解决方案。这纯粹是出于学习目的。

有人可以帮我解决这个问题吗？

#include<iostream>

template<int...>
struct add;

template<>
struct add<>
{
  static constexpr int value = 0;
};

template<int i, int... tail>
struct add<i, tail...>
{
  static constexpr int value = i + add<tail...>::value;
};

int main()
{
    std::cout << add<1,2,3,4>::value;
}

我写了这个但是被卡住了

template<typename ...>
struct add;

template<typename T, typename... args>
struct add<T, args...>
{
    static constexpr T value = ??//T();//what to write here?
};

谢谢。

Answer 1

那下面的东西呢？

#include <iostream>

template <typename T, T...>
struct add
{ static constexpr T value = 0; };

template <typename T, T head, T ... tail>
struct add<T, head, tail...>
{ static constexpr T value = head + add<T, tail...>::value; };

int main()
 {
    std::cout << add<int, 1, 2, 3, 4>::value << std::endl;
    std::cout << add<long, 10l, 20l, 30l, 40l>::value << std::endl;
 }

或者，也许更好，继承自std::integral_constant

template <typename T, T...>
struct add : public std::integral_constant<T, T{0}>
{ };

template <typename T, T head, T ... tail>
struct add<T, head, tail...>
   : public std::integral_constant<T, head + add<T, tail...>::value>
{ };

如果可以使用C ++ 17，则不再需要递归，但是可以使用模板折叠。

template <typename T, T... Is>
struct add : public std::integral_constant<T, (... + Is)>
 { };

C ++ 17还为您提供了使用typename T作为值来摆脱auto类型参数的机会。

问题就变成了：value考虑到模板值可能是不同类型是哪种类型？

我想std::common_type是这个问题的解决方案，所以

#include <iostream>
#include <type_traits>

template <auto ... Is>
struct add :
   public std::integral_constant<std::common_type_t<decltype(Is)...>,
                                 (... + Is)>
 { };

int main()
 {
    std::cout << add<1, 2, 3, 4>::value << std::endl;
    std::cout << add<10l, 20l, 30l, 40l>::value << std::endl;
 }

或者，也许只是使用decltype((... + Is))

template <auto ... Is>
struct add :
   public std::integral_constant<decltype((... + Is)), (... + Is)>
 { };

非主题：原始的add可以如下简化

template <int...>
struct add
 { static constexpr int value = 0; };

template <int i, int... tail>
struct add<i, tail...>
 { static constexpr int value = i + add<tail...>::value; };

我的意思是：不是两个专业，而是一个主要版本（这是递归的基础情况）和一个专业化（递归情况）。

或者至少，我认为这有点简化。

Answer 2

我会假设您出于任何原因都不想编写简单的fold-expression。

我们需要类型为T的实际值作为（非类型）模板参数。最简单的方法是使用auto作为其类型：

template<auto ...>
struct add;

template<auto t>
struct add<t>
{
    static constexpr auto value = t;
};

template<auto t, auto... args>
struct add<t, args...>
{
    static constexpr auto value = t + add<args...>::value;
};

演示：

#include <iostream>
#include <string>
int main()
{
    std::cout << add<1, 2, 3>::value << '\n';
    std::cout << add<1u, 2, -4>::value << '\n';
}

Answer 3

对于非整数类型并进行一些修改，这样做也是可能！

非类型的模板，非模板的参数应为整数类型或具有链接的引用/指针或更多有限的可能性。可以在Template parameters and template arguments上阅读完整列表。

由于浮动类型不能以模板非类型，非模板参数/参数的形式出现，所以最好的下一个选择是通过引用获取它们。

所以struct变成：

template<auto& ...>
struct add{
    static constexpr auto value = 0;
};
template<auto& first, auto& ... others>
struct add<first, others...>{
    static constexpr auto value = first + add<others ...>::value;
};

值应首先存储为常量（带有链接），因此应存储在main()之前：

const auto v1 = 12; //int
const auto v2 = 54L; //long
const auto v3 = 3.25242; //double
const auto v4 = 75.7256L; //long double

那么它们可以在任何地方使用：

#include <iostream>
int main(){
    std::cout << add<v1, v2, v3, v4>::value << std::endl;
}

可能的输出：

144.978

它不仅适用于（混合）整数类型和（混合）浮点类型，而且还适用于任何自定义类型，只要自定义类型满足特定属性，包括具有constexpr构造函数和operator +。它还必须具有某种类型转换运算符或其他方式才能实现类似的功能。例如，可以使用以下类型：

class custom_type{
    const float v;
    //this one works too but the first is better for the purpose.
    //float v;
public:
    template<typename T>
    constexpr custom_type(T v_):v(v_){}
    template<typename T>
    constexpr auto operator +(T o)const{
        return o + 7345 + v ;
    }
    //this one works but the next one is  better for the purpose.
    //operator auto()const{
    //this one works too but the next one is more clear.
    //constexpr operator auto()const{
    template<typename T>
    constexpr operator T()const{
        return v;
    }
};

将它们放在一起：

template<auto& ...>
struct add{
    static constexpr auto value = 0;
};
template<auto& first, auto& ... others>
struct add<first, others...>{
    static constexpr auto value = first + add<others ...>::value;
};

class custom_type{
    const float v;
public:
    template<typename T>
    constexpr custom_type(T v_):v(v_){}
    template<typename T>
    constexpr auto operator +(T o)const{
        return o + 7345 + v ;
    }
    template<typename T>
    constexpr operator T()const{
        return v;
    }
};

const auto v1 = 12; //int
const auto v2 = 54L; //long
const auto v3 = 3.25242; //double
const auto v4 = 75.7256L; //long double
const custom_type v5 = 34.234; //custom_type

#include <iostream>
int main(){
    std::cout << add<v1, v2, v3, v4, v5>::value << std::endl;
}

可能的输出：

7524.21

请注意，对于低于17的C ++版本，struct add只能接受单一类型的参数，对于类型double来说，就像：

template<const double& ...>
struct add{
    static constexpr double value = 0;
};
template<const double& first, const double& ... others>
struct add<first, others...>{
    static constexpr double value = first + add<others ...>::value;
};

和常量：

const double v1 = 12;
const double v2 = 54L;
const double v3 = 3.25242;
const double v4 = 75.7256l;

祝你好运！

如何编写计算整数和的可变参数模板类的通用版本

3 个答案: