例如,要将pair < int , float >
镜像到pair < float , int >
,我可以创建这样的模板函数:
template<class AB,class BA>
void mirror(const AB& ab,BA& ba){
ba.first=ab.second;
ba.second=ab.first;
}
int main(){
pair<int,float> ab;
ab.first=3;
ab.second=2.0;
pair<float,int> ba;
mirror<decltype(ab),decltype(ba)>(ab,ba);
printf("%d\n",ba.second);
return 0;
}
但是这种方法无法处理另一对中的一对,例如:
pair < bool , pair< int , float > >
至pair < pair < float , int > , bool >
:
pair<bool,pair<int,float> > a_bc;
pair<pair<float,int>,bool> cb_a;
mirror<decltype(a_bc),decltype(cb_a)>(a_bc,cb_a);
pair < pair < A , B >, pair < C , D > >
至pair < pair < D , C > , pair< B , A > >
:
pair<pair<A,B>,pair<C,D> > ab_cd;
pair<pair<D,C>,pair<B,A> > dc_ba;
mirror<decltype(ab_cd),decltype(dc_ba)>(ab_cd,dc_ba)
是否可以编写镜像模板函数(例如:2个镜像函数模板,一个用于对,另一个用于非对,然后使用递归)函数,它们可以处理上面的所有情况?
答案 0 :(得分:7)
您可以创建2个重载:
template<typename T>
constexpr const T& mirror(const T& t)
{
return t;
}
template<class A, class B>
constexpr auto mirror(const std::pair<A, B>& p)
{
return std::make_pair(mirror(p.second), mirror(p.first));
}
答案 1 :(得分:3)
template<typename T1, typename T2, typename S1, typename S2> std::pair<std::pair<S2, S1>, std::pair<T2, T1>>
mirror(const std::pair<std::pair<T1, T2>, std::pair<S1, S2>>& p)
{
return std::pair<std::pair<S2, S1>, std::pair<T2, T1>>(mirror(p.second),
mirror(p.first));
}
template<typename T1, typename T2, typename S> std::pair<S, std::pair<T2, T1>>
mirror(const std::pair<std::pair<T1, T2>, S>& p)
{
return std::pair<S, std::pair<T2, T1>>(p.second, mirror(p.first));
}
template<typename T, typename S1, typename S2> std::pair<std::pair<S2, S1>, T>
mirror(const std::pair<T, std::pair<S1, S2>>& p)
{
return std::pair<std::pair<S2, S1>, T>(mirror(p.second), p.first);
}
template<typename T, typename S> std::pair<S, T>
mirror(const std::pair<T, S>& p)
{
return std::pair<S, T>(p.second, p.first);
}
int main() {
pair<bool, pair<int, float> > a_bc;
pair<pair<float, int>, bool> cb_a = mirror(a_bc);
pair<pair<int, double>, pair<bool, pair<char, float>>> ab__c_de;
pair<pair<pair<char, float>, bool>, pair<double, int>> de_c__ab = mirror(ab__c_de);
}
答案 2 :(得分:0)
您可以在pair
课程中实施,例如
pair<B, A> swap() {
pair<B, A> tmp;
tmp->first = this->second;
tmp->second = this->first;
return tmp;
}
并在需要时调用它。
答案 3 :(得分:0)
尝试使用函数模板重载来支持对的嵌套镜像:
template<class AB,class BA>
void mirror(const AB& ab,BA& ba){
ba = ab;
}
template<class A,class B,class C,class D>
void mirror(const pair<A, B>& a, pair<C, D>& b){
mirror(a.first, b.second);
mirror(a.second, b.first);
}