6

我有一个特质类，我需要多次专门化（和部分专门化）。

一些部分专业重叠：

template< typename T > struct C { };
template< typename T1, typename T2 > struct TRAIT { };

template< typename T > struct TRAIT< T, T > { };
template< typename T1, typename T2 > struct TRAIT< C<T1>, C<T2> > { };

int main( ) {
    // ERROR! could be both TRAIT<T,T>   [with T = C<int>]
    //                  and TRAIT<T1,T2> [with T1 = T2 = int]
    TRAIT< C<int>, C<int> > foo;
    return 0;
};

我应该如何使用工作代码获得相同的结果？

enable_if我对and发疯了is_same，我什至不再确定这是正确的方法......

4

3 回答 3

6

如果你不能避免重叠专业化，你最好的选择是澄清你所有的重叠。您需要为

template< typename T> struct TRAIT< C<T>, C<T> > { };

...但是，正如其他人在评论中所说，最好尽可能避免重叠。正如其他人所说，问题可能不是重叠的专业，这可能不是解决问题的最佳方法。

于 2010-12-06T21:29:37.103 回答
1

诀窍是创建一个帮助类型，告诉你某事是否是C<Foo>：

template <typename T> struct C {};

template <typename T> struct is_C {
  static bool const value = false;
};
template <typename T> struct is_C<C<T>> {
  static bool const value = true;
};

你在正确的轨道上，enable_if但is_same似乎是一个死胡同：

#include <type_traits>

template <typename T1, typename T2, typename Enabled = void> struct Trait {
  static char const test = 'D'; // default
};

template <typename T> struct Trait<
    T,
    T,
    typename std::enable_if<!is_C<T>::value >::type
> {
  static char const test = 'N'; // non-C
};

template <typename T1, typename T2> struct Trait<
    T1,
    T2,
    typename std::enable_if< is_C<T1>::value && is_C<T2>::value >::type
> {
  static char const test = 'C'; // some C
};

您现在可以轻松测试：

#include <iostream>

int main() {
  Trait< C<int>, C<float> > foo1a;
  Trait< C<int>, C<int> > foo1b;
  Trait< int, int > foo2;
  Trait< int, float > foo3;
  std::cout << "Trait<C<int>,C<float>> : " << foo1a.test << std::endl; // prints 'C'
  std::cout << "Trait<C<int>,C<int>> : " << foo1b.test << std::endl; // prints 'C'
  std::cout << "Trait<int,int> : " << foo2.test << std::endl; // prints 'N'
  std::cout << "Trait<int,float> : " << foo3.test << std::endl; // prints 'D'
  return 0;
}

如果您希望您的专业化仅使用参数之一是 aC或您喜欢的任何参数，您可以轻松地更改它。

于 2012-01-07T19:01:49.857 回答
0

尝试：

template< typename T > struct C { };
template< typename T1, typename T2 = T1> struct TRAIT { };
                              // ^^^^^^^^^
                              // Default Type is T1

int main( )
{
        TRAIT<C<int> >         foo1;
        TRAIT<C<int>, C<int> > foo2;

        foo1 = foo2;
        return 0;
};
于 2010-12-06T21:55:40.417 回答