如何在SFINAE模板定义中获得底层数据的类型?

Question

假设我有一个库函数int foo( const T& )

:

std::vector<A> c1;
std::list<B>() c2;
auto a1 = foo(c1);  // ok
auto a2 = foo(c2);  // ok too
std::map<int, float> c3;
auto a3 = foo( c3 ); // this must fail 

首先，我写了一个trait类来定义允许的容器:

template <typename T>               struct IsContainer                    : std::false_type { };
template <typename T,std::size_t N> struct IsContainer<std::array<T,N>>   : std::true_type  { };
template <typename... Ts>           struct IsContainer<std::vector<Ts...>>: std::true_type  { };
template <typename... Ts>           struct IsContainer<std::list<Ts...  >>: std::true_type  { };

现在,"Sfinae"功能:

template<
typename U,
typename std::enable_if<IsContainer<U>::value, U>::type* = nullptr
>
auto foo( const U& data )
{
// ... call some other function
return bar(data);
}

工作好。

旁注:bar()实际上在私有命名空间中，也可以从其他代码调用。相反，foo()是API的一部分。

但是现在我想根据容器内的类型改变行为即在foo()内:

• 调用bar1(data)如果参数是std::vector<A>或std::list<A>和

• 如果参数是std::vector<B>或std::list<B>，则调用bar2(data)

这里是

struct A {}; // dummy here, but concrete type in my case
struct B {};
template<
typename U,
typename std::enable_if<
( IsContainer<U>::value, U>::type* = nullptr && std::is_same<U::value_type,A> )
>
auto foo( const U& data )
{
// ... call some other function
return bar1(data);
}
template<
typename U,
typename std::enable_if<
( IsContainer<U>::value, U>::type* = nullptr && std::is_same<U::value_type,B> )
>
auto foo( const U& data )
{
// ... call some other function
return bar2(data);
}

bar1()和bar2()(dummy)定义为:

template<typename T>
int bar1( const T& t )
{
return 42;
}
template<typename T>
int bar2( const T& t )
{
return 43;
}

可以正常工作，如下所示

现在我真正的问题是:类型A和B实际上是由一些底层类型模板化的:

template<typename T>
struct A
{
T data;
}
template<typename T>
struct B
{
T data;
}

我希望能够建立这个:

int main()
{
std::vector<A<int>> a;
std::list<B<float>> b;
std::cout << foo(a) << 'n';   // print 42
std::cout << foo(b) << 'n';   // print 43
}

我的问题是:我不知道如何"提取"。所包含的类型:我试过了:

template<
typename U,
typename F,
typename std::enable_if<
( IsContainer<U>::value && std::is_same<typename U::value_type,A<F>>::value ),U
>::type* = nullptr
>   
auto foo( const U& data )
{
return bar1(data);
}
template<
typename U,
typename F,
typename std::enable_if<
( IsContainer<U>::value && std::is_same<typename U::value_type,B<F>>::value ), U
>::type* = nullptr
>   
auto foo( const U& data )
{
return bar2(data);
}

但是这不能构建:

template argument deduction/substitution failed:
main.cpp:63:21: note:  couldn't deduce template parameter 'F'

问:我怎样才能使这个工作?

旁注:如果可能的话，请只使用c++ 14(或17)，目前我宁愿避免使用c++ 20。

Answer 1

有一个简单的解决方案:以与定义IsContainer完全相同的方式定义IsA:

template<class> struct IsA : std::false_type {};
template<class T> struct IsA<A<T>> : std::true_type {};

然后写

IsContainer<U>::value && IsA<typename U::value_type>::value

根据你确切的用例，你甚至可能不需要第一个特征，因为对于U = std::map<...>,IsA<typename U::value_type>::value无论如何都会是false。

Answer 2

您可以为isA/isB定义特征:

template <typename T> struct IsA : std::false_type { };
template <typename T> struct IsA<A<T>> : std::true_type  { };
template <typename T> struct IsB : std::false_type { };
template <typename T> struct IsB<B<T>> : std::true_type  { };

和SFINAE。

另一种可能是标签调度:

template<typename T> int bar1( const T& t ) { return 42; }
template<typename T> int bar2( const T& t ) { return 43; }
template <typename T> struct Tag{};
template<typename T, typename U>
int bar(const T& t, Tag<A<T>>) { return bar1(t); }
template<typename T, typename U>
int bar(const T& t, Tag<B<U>>) { return bar2(t); }
template<
typename T,
typename std::enable_if<IsContainer<T>::value>::type* = nullptr
>
auto foo( const U& data ) -> decltype(bar(data, Tag<typename T::value_type>{}))
{
// ... call some other function
return bar(data, Tag<typename T::value_type>{});
}