处理一般情况混合类型和非类型的可变参数模板

所以我试图做一个类型特征，说明两个"外部"类类型是否相同。

即。std::vector<int>和std::vector<double>一样，我不在乎我的类型特征的任何内部争论。

我在尝试为此制作泛型类型特征时遇到的一个问题是，我只知道如何将类型化的可变参数模板与非类型化的模板分开处理，这似乎阻止了我将其设为泛型。

是否可以处理类型化和非类型化模板参数的任何排列？

以下是我实现的内容(包括失败的示例(：

// g++ -std=c++17
#include <iostream>
#include <vector>
#include <array>
#include <type_traits>
// If the outer types don't match
template <typename, typename>
struct is_outer_type_same : std::false_type {};

// if the arguments of the compared Type contains only types
// ie. std::vector<int,std::allocator<int>>
// (the inner arguments are also types)
template <template<typename...> typename OuterType,
typename... InnerTypes1,
typename... InnerTypes2
>
struct is_outer_type_same < OuterType<InnerTypes1...>,
OuterType<InnerTypes2...>
>
: std::true_type {};

// if the arguments of the compared Type contains only non-types
// eg. SomeClassName<4,5,2>
template <template<auto...> typename OuterType,
auto... InnerVariables1,
auto... InnerVariables2
>
struct is_outer_type_same < OuterType<InnerVariables1...>,
OuterType<InnerVariables2...>
>
: std::true_type {};

// if the arguments of the compared Type contains a single
// typed-argument followed by some non-typed arguments
// ie. std::array<int, 4>
template <template<typename, auto...> typename OuterType,
typename InnerType1, auto... InnerVariables1,
typename InnerType2, auto... InnerVariables2
>
struct is_outer_type_same < OuterType<InnerType1, InnerVariables1...>,
OuterType<InnerType2, InnerVariables2...>
>
: std::true_type {};

// For any outer types whose arguments have the pattern:
// single variable argument followed by a sequence of typed arguments:
template <template<auto, typename...> typename OuterType,
auto InnerVariable1, typename... InnerTypes1,
auto InnerVariable2, typename... InnerTypes2
>
struct is_outer_type_same < OuterType<InnerVariable1, InnerTypes1...>, 
OuterType<InnerVariable2, InnerTypes2...>
>
: std::true_type {};

// This is to make it neater to evaluate:
template <typename S, typename T>
inline constexpr bool is_outer_type_same_v
= is_outer_type_same<S,T>::value;

// Example type that fails to be handled
// correctly by the above struct templates: 
template <typename A, typename B, int C>
struct ExampleType
{
A data1;
B data2;
const int data3 = C;
};

int main ()
{   
// Examples to show where it fails:
std::cout << "Fails to find match for ExampleType: "
<< is_outer_type_same_v<ExampleType<double,int,2>,
ExampleType<double,int,2>>
<< std::endl << std::endl

// Examples to show where it works:
<< "Finds correctly: " << std::endl

<< std::endl << "Matches for std::vector: "
<< is_outer_type_same_v<std::vector<int>,
std::vector<double>>
<< is_outer_type_same_v<std::vector<std::vector<int>>,
std::vector<double>>
<< is_outer_type_same_v<std::vector<std::array<int,3>>,
std::vector<double>>

<< std::endl << "Mismatches for std::vector: "
<< is_outer_type_same_v<int,
std::vector<int>>
<< is_outer_type_same_v<std::array<int, 3>,
std::vector<int>>
<< is_outer_type_same_v<std::array<std::vector<int>, 3>,
std::vector<int>>

<< std::endl << "Matches for std::array: "
<< is_outer_type_same_v<std::array<int, 3>,
std::array<double, 7>>
<< is_outer_type_same_v<std::array<std::vector<int>, 7>,
std::array<double, 2>>
<< is_outer_type_same_v<std::array<std::array<int,3>, 8>,
std::array<std::vector<double>, 5>>

<< std::endl << "Mismatches for std::array: "
<< is_outer_type_same_v<int,
std::array<int,2>>
<< is_outer_type_same_v<std::vector<int>,
std::array<int,8>>
<< is_outer_type_same_v<std::vector<std::array<int,3>>,
std::array<int,2>>
<< std::endl;
return 0;
}