Шаблоны с переменным числом аргументов

#include <iostream>
using namespace std;
 
static long double sum = 0;
 
template <class T>
long double sum_values(const T& value)
{
    sum+=value;
    return value;
}
 
template <class T, class... Args>
long double sum_values(const T& value, const Args&... args) // возвращает сумму аргументов
{
    sum+=value;
    sum_values(args...);
    return sum;
}
 
int main()
{
    cout<<sum_values(10, 2, 4, 4, 30.002)<<endl;;
    return 0;
}

#include <iostream>
#include <utility>
 
template <class T>
T sum(T&& t)
{
    return t;
}
 
template <class T, class... Args>
auto sum(T&& t, Args&&... args)
    -> decltype(t + sum(std::forward<Args>(args)...))
{
    return t + sum(std::forward<Args>(args)...);
}
 
int main()
{
    std::cout << sum(3.14, 1) << std::endl;
    return 0;
}

std::forward<Args>(args)...)

#include <iostream>
#include <utility>
 
template <class T>
T sum(T&& t)
{
    return t;
}
 
template <class T, class... Args>
T sum(T&& t, Args&&... args)
{
    return t + sum(std::forward<Args>(args)...);
}
 
int main()
{
    std::cout << sum(3.14, 1, 5) << std::endl;
    return 0;
}

int main()
{
    int n = 10;
    cout<<sum(10+1, 2, 3)<<endl;
    //cout<<sum(10+1, n, 3)<<endl; //ошибка
    return 0;
}

#include <iostream>
#include <utility>
 
template <class T>
struct GetValue
{
    static constexpr T value = T();
};
 
template <class T>
struct GetValue<T&>
{
    static constexpr T value = T();
};
 
template <class T, class U>
struct Add
{
    using type = decltype(GetValue<T>::value + GetValue<U>::value);
};
 
template <class T>
struct Add<T, void>
{
    using type = T;
};
 
template <class... Args>
struct TypeAfterAdding;
 
template <>
struct TypeAfterAdding<>
{
    using type = void;
};
 
template <class T, class... Args>
struct TypeAfterAdding<T, Args...>
{
    using type = typename Add<T, typename TypeAfterAdding<Args...>::type>::type;
};
 
template <class T>
T sum(T&& t)
{
    return t;
}
 
template <class T, class... Args>
auto sum(T&& t, Args&&... args)
    -> typename TypeAfterAdding<T, Args...>::type
{
    return t + sum(std::forward<Args>(args)...);
}
 
int main()
{
    int n = 15;
    std::cout << sum(3.14, 4, n) << std::endl;
    return 0;
}

#include <iostream>
#include <utility>
#include <tuple>
 
template <size_t Index, typename ... Args>
struct Sum;
 
template <size_t Index, typename ... Args>
struct Sum {
    static auto compute (const std::tuple <Args ...>& t) -> decltype (std::get<Index>(t) + std::get<Index - 1>(t)) {
        return std::get<Index>(t) + Sum <Index - 1, Args ...> :: compute (t);
    }
};
 
template <typename ... Args>
struct Sum <0, Args ...> {
    static auto compute (const std::tuple <Args ...>& t) -> decltype (std::get<0>(t)) {
        return std::get<0>(t);
    }
};
 
template <typename T, typename ... Args>
T sum (const Args& ... args) {
    return Sum <sizeof ...(Args) - 1, Args ...> :: compute (std::tuple<Args ...>(args...));   
}
 
int main () {
    std::cout << sum <int> (1., 2., 23.23, 2.9, 23.9f) << std::endl;
}

#include <iostream>
 
template<typename T>
T sum(T&& t)
{
   return t;
}
 
template<typename T, typename... Args>
typename std::common_type<T, Args...>::type sum(T&& t, Args&&... args)
{
   return t + sum(std::forward<Args>(args)...);
}
 
int main()
{
   std::cout << sum(1, 1.2, 3.5, 4) << std::endl;
}