我想要能够限制一个C++函数，使其只能接受以下参数：
std::vector<T>
std::vector<std::vector<T>>
std::vector<std::vector<std::vector<T>>>
...

template<typename T>
requires IsVectorInt<T>
auto foo(T t)
{
}
int main()
{
    std::vector<int> intvec {1, 2, 3};
    std::vector<std::vector<int>> vecofvec {{1, 2}, {1, 3}};
    foo(intvec);
    foo(vecofvec);
}

template<class, template<class...> class>
inline constexpr bool is_specialization = false;
template<template<class...> class T, class... Args>
inline constexpr bool is_specialization<T<Args...>, T> = true;
template<class T>
concept IsVector = is_specialization<T, std::vector>;
template<class T>
concept IsVectorInt = IsVector<T> && std::is_same_v<int, typename T::value_type>;
template<typename T>
requires IsVector<T>
auto foo(T t)
{
}
int main()
{
    std::vector<int> intvec {1, 2, 3};
    std::vector<std::string> vecofstr {"bar", "baz"};
    std::vector<std::vector<int>> vecofvec {{1, 2}, {1, 3}};
    foo(intvec);
    foo(vecofvec);
    foo(vecofstr); // 我希望这一行无法编译通过
}

<details>
<summary>英文:</summary>
I would like to be able to constrain a C++ function such that the only arguments it can accept are:

and so on, accepting an arbitrarily nested std::vector, but with a specific type T
I would like the following to compile:

So far I have managed to constrain a function using concepts to only accept either:
`std::vector<T>` where T could itself be another std::vector\<U\>
or:
`std::vector<int>`, this however, does not accept any nested vectors.
My code is shown below:

</details>
# 答案1
**得分**: 4
如果您的目标是检测算术类型的向量或嵌套向量，这里提供了一个使用递归实现的特性的提案：
```c++
#include <iostream>
#include <type_traits>
#include <vector>
template <typename T>
struct NestedVector : public std::false_type {};
template <typename T>
struct NestedVector<std::vector<T>>
    : public std::conditional_t<std::is_arithmetic<T>::value ||
                                NestedVector<T>::value,
                                std::true_type, std::false_type> {};
// C++<20版本
template <typename T, std::enable_if_t<NestedVector<T>::value, bool> = true>
void foo(T t) {}
// C++20版本
// template <typename T>
// requires NestedVector<T>::value
// void foo(T t) {}
int main() {
    std::vector<int> intvec{1, 2, 3};
    std::vector<std::string> vecofstr{"bar", "baz"};
    std::vector<std::vector<int>> vecofvec{{1, 2}, {1, 3}};
    foo(intvec);
    foo(vecofvec);
    // foo(vecofstr);  // 不适用
}

// 用于获取最内层类型的特性
template <typename T>
struct inner_type
{
    using type = T;
};
// 特化
template <typename T>
struct inner_type<std::vector<T>>
{
    using type = typename inner_type<T>::type;
};
// 为了方便使用的别名
template<typename T>
using inner_type_t = typename inner_type<T>::type;
template<typename T>
auto foo(std::vector<T> t)
{ 
    static_assert(std::is_arithmetic_v<inner_type_t<T>>);
}  
int main()
{
    std::vector<int> intvec {1, 2, 3};
    std::vector<std::vector<int>> vecofvec {{1, 2}, {1, 3}};
    foo(intvec);       // 正常工作
    foo(vecofvec);     // 正常工作
    std::vector<std::string> vecofstr{"bar", "baz"};
    // foo(vecofstr);  // 预期失败
}

template<typename T>
auto foo(std::vector<T> t) requires(std::is_arithmetic_v<inner_type_t<T>>)
{ 
}