C++ 如何制作c++；编译时计算程序递归级别更深？

我有一个程序，可以在编译时计算N以下的所有素数。例如，如果我设置N=20，我将得到{2,3,5,7,11,13,17,19}，如果N=10，我将得到{2,3,5,7} 我试过N=1499，它有效，但不超过1499。如果N=1500，则会出现“致命错误C1202递归类型或函数依赖项上下文太复杂”

PS：我正在使用vs2019和c++17、调试模式和X86

有没有办法把N扩大到10000或更多？（适用于msvc和gcc） 这是我的密码

#include <cstdlib>
#include <cstdio>
#include <utility>
 
static const int N = 1499;

constexpr bool IsPrime(int n)
{
    if (n > 6)
    {
        if (n % 6 != 1 && n % 6 != 5)
        {
            return false;
        }

        for (int i = 5; i * i < n; ++i)
        {
            if (n % i == 0)
            {
                return false;
            }
        }

        return true;
    }
    else if (n == 2 || n == 3 || n == 5)
    {
        return true;
    }
    else
    {
        return false;
    }
}

template <size_t...V>
struct is_prime_t
{
    bool is_prime[sizeof...(V)] = {
        IsPrime(V)...
    };
};

template <size_t...V>
constexpr is_prime_t <V...> GetIsPrime_T(std::index_sequence<V...>)
{
    return is_prime_t<V...>();
};

static constexpr auto is_prime_list = GetIsPrime_T(std::make_index_sequence<N>());

constexpr auto GetNextPrime(int prime)
{
    for (int i = prime - 1; i >= 0; --i)
    {
        if (is_prime_list.is_prime[i]) return i;
    }

    return 0;
}

template <size_t...V>
struct prime_list_t
{
    size_t prime_list[sizeof...(V)] = {
        V...
    };
};

template <bool, size_t N, size_t... Primes>
struct prime_sequence_helper_with_checker;

template <size_t N, size_t... Primes>
struct prime_sequence_helper
{
    typedef typename prime_sequence_helper_with_checker<IsPrime(N), N, Primes...>::type type;
};

template <size_t... Primes>
struct prime_sequence_helper<0, Primes...>
{
    typedef typename prime_list_t<Primes...> type;
};

template <size_t N>
struct prime_sequence
{
    typedef typename prime_sequence_helper<N>::type type;
};

template <bool, size_t N, size_t... Primes>
struct prime_sequence_helper_with_checker;

template <size_t N, size_t... Primes>
struct prime_sequence_helper_with_checker<true, N, Primes...>
{
    //typedef typename prime_sequence_helper<N - 1, N, Primes...>::type type;
    typedef typename prime_sequence_helper<GetNextPrime(N), N, Primes...>::type type;
};

template <size_t N, size_t... Primes>
struct prime_sequence_helper_with_checker<false, N, Primes...>
{
    //typedef typename prime_sequence_helper<N - 1, Primes...>::type type;
    typedef typename prime_sequence_helper<GetNextPrime(N), Primes...>::type type;
};

template <size_t N>
constexpr auto GetPrimeList_T()
{
    return prime_sequence<N>::type();
}


int main()
{    
    constexpr auto prime_list = GetPrimeList_T<N>();

    system("pause");
    return 0;
}

#包括
#包括
#包括
静态常数int N=1499；
constexpr bool IsPrime（int n）
{
如果（n>6）
{
如果（n%6！=1&&n%6！=5）
{
返回false；
}
对于（int i=5；i*i=0；--i）
{
if（is_prime_list.is_prime[i]）返回i；
}
返回0；
}
模板
结构素数列表
{
大小素数列表[sizeof…（V）]={
v
};
};
模板
结构素数\u序列\u助手\u与\u检查器；
模板
结构素数\序列\辅助对象
{
typedef typename prime_sequence_helper_with_checker:：type type；
};
模板
结构素数\序列\辅助对象
{
typedef typename prime_list_t type；
};
模板
结构素数序列
{
typedef typename prime_sequence_helper:：type type；
};
模板
结构素数\u序列\u助手\u与\u检查器；
模板
结构素数\u序列\u辅助对象\u和\u检查器
{
//typedef typename prime_sequence_helper:：type type；
typedef typename prime_sequence_helper:：type type；
};
模板
结构素数\u序列\u辅助对象\u和\u检查器
{
//typedef typename prime_sequence_helper:：type type；
typedef typename prime_sequence_helper:：type type；
};
模板
constexpr auto GetPrimeList_T（）
{
返回prime_序列：：type（）；
}
int main（）
{    
constexpr auto prime_list=GetPrimeList_T（）；
系统（“暂停”）；
返回0；
}

您可以通过以下方式避免太深的递归。。。避免递归：

constexpr bool IsPrime(int n)
{
    if (n > 6)
    {
        if (n % 6 != 1 && n % 6 != 5)
        {
            return false;
        }

        for (int i = 5; i * i < n; ++i)
        {
            if (n % i == 0)
            {
                return false;
            }
        }

        return true;
    }
    else if (n == 2 || n == 3 || n == 5)
    {
        return true;
    }
    else
    {
        return false;
    }
}

template <std::size_t... Is>
constexpr auto get_primes(std::index_sequence<Is...>)
{
    constexpr auto res = [](){
        constexpr bool is_prime[sizeof...(Is)] = { IsPrime(Is)... };
        std::array<std::size_t, std::count(std::begin(is_prime), std::end(is_prime), true)> res{};

        std::size_t index = 0;
        for (std::size_t i = 0; i != sizeof...(Is); ++i) {
            if (is_prime[i]) res[index++] = i;
        }
        return res;
    }();
    return res;
}

constexpr bool IsPrime（int n）
{
如果（n>6）
{
如果（n%6！=1&&n%6！=5）
{
返回false；
}
对于（int i=5；i*i

---

您可以尝试使用ErastoThenes筛选，当它不起作用时，您会看到什么行为？

5

是一个素数。可能重复