C++11 可变元组的实现
我一直在尝试在通用模板和结构上使用可变元组。其思想是获得可变元组的最大值和和。到目前为止,我能够获得所需的结果,但必须使用全局静态变量。我已经在下面发布了实现的代码C++11 可变元组的实现,c++11,tuples,C++11,Tuples,我一直在尝试在通用模板和结构上使用可变元组。其思想是获得可变元组的最大值和和。到目前为止,我能够获得所需的结果,但必须使用全局静态变量。我已经在下面发布了实现的代码 #include <iomanip> #include <complex> #include <cmath> #include <tuple> #include <string> #include <iostream&g
#include <iomanip>
#include <complex>
#include <cmath>
#include <tuple>
#include <string>
#include <iostream>
using namespace std;
using namespace std::complex_literals;
template<typename T>
static T max;
template<typename T>
static T sum;
template<typename T>
static T average;
template <typename T, typename Tuple, std::size_t N>
struct Calculator
{
static void maximum(const Tuple& pack)
{
Calculator<T, Tuple, N - 1>::maximum(pack);
T packValue = get<N - 1>(pack);
if (packValue > max<T>)
{
//T max = get<0>(pack);
//Try the above instead of the below code to calculate max
max<T> = get<N - 1>(pack);
}
}
static void summation(const Tuple& pack)
{
Calculator<T, Tuple, N - 1>::summation(pack);
T packValue = get<N - 1>(pack);
sum<T> += packValue;
}
static void averager(const Tuple& pack)
{
average<T> = sum<T> / N;
}
};
template<typename T, typename Tuple>
struct Calculator<T, Tuple, 1>
{
static void maximum(const Tuple& pack)
{
//T max = get<0>(pack);
//Try the above instead of the below code to calculate max
max<T> = get<0>(pack);
}
static void summation(const Tuple& pack)
{
sum<T> = get<0>(pack);
}
};
int main()
{
tuple<double, double, double, double, double, double, double> t1 = make_tuple(16565.256, 45.539, 0.25, 1000.25, 1.25036, 35.66, 210.20);
Calculator<double, tuple<double, double, double, double, double, double, double>, 7>::maximum(t1);
cout << "Maximum is: " << max<double> << endl;
Calculator<double, tuple<double, double, double, double, double, double, double>, 7>::summation(t1);
cout << "Total Sum is: " << sum<double> << endl;
Calculator<double, tuple<double, double, double, double, double, double, double>, 7>::averager(t1);
cout << "Average is: " << average<double> << endl;
std::complex<int> c2(22, 3);
std::complex<int> ci(15, 41);
tuple<std::complex<int>, std::complex<int> > ct1 = make_tuple(ci, c2);
Calculator< std::complex<int>, tuple<std::complex<int>, std::complex<int> >, 2>::summation(ct1);
cout << "Summation of complex numbers is: " << sum<std::complex<int>> << endl;
}
#包括
#包括
#包括
#包括
#包括
#包括
使用名称空间std;
使用名称空间std::complex_文本;
模板
静态T最大值;
模板
静态T和;
模板
静态T均值;
模板
结构计算器
{
静态无效最大值(常量元组和块)
{
计算器::最大(包);
T packValue=get(pack);
如果(packValue>max)
{
//T max=获取(包);
//请尝试上面的代码而不是下面的代码来计算最大值
max=get(pack);
}
}
静态无效总和(常量元组和包)
{
计算器:求和(包);
T packValue=get(pack);
总和+=packValue;
}
静态无效平均器(常量元组和块)
{
平均值=总和/N;
}
};
模板
结构计算器
{
静态无效最大值(常量元组和块)
{
//T max=获取(包);
//请尝试上面的代码而不是下面的代码来计算最大值
max=get(pack);
}
静态无效总和(常量元组和包)
{
求和=获取(包);
}
};
int main()
{
元组t1=make_元组(16565.256,45.539,0.251000.25,1.25036,35.66210.20);
计算器:最大值(t1);
您可以使用变量模板,因此您至少有C++14。在C++14中,您可以使用索引序列
作为提取所有元组项并将递归函数重写为非递归的简单方法:
template <typename T, typename Tuple, std::size_t N>
struct Calculator
{
template<size_t ... Indices>
static T maxHelper(const Tuple& pack, std::index_sequence<Indices...>) {
return std::max( {std::get<Indices>(pack)...} );
} // [1]
static T maximum(const Tuple& pack) {
return maxHelper(pack, std::make_index_sequence<N>{});
}
template<size_t ... Indices>
static T sumHelper(const Tuple& t, std::index_sequence<Indices...>) {
T arr[] = { std::get<Indices>(t)... }; // [2]
return std::accumulate(arr,arr+N,T{}); // [3]
}
static T summation(const Tuple& pack) {
return sumHelper(pack,std::make_index_sequence<N>{});
}
};
这类问题可能更适合于感谢您提供详细的替代解决方案。刚开始使用可变元组和可变模板,但遇到了一些问题。此解决方案有助于提高我对主题的理解。非常感谢。
template<class ... Args>
auto maxValue(std::tuple<Args...> t) {
return std::apply( [](auto&&... args) { return std::max({args...}); },t);
}
template<class ... Args>
auto sumValue(std::tuple<Args...> t) {
return std::apply( [](auto&&... args){ return (args + ...);} , t);
}