Unexpected stack overflow when using recursive template metaprogramming in C++20
I'm writing unit tests and I'm trying to implement I've hit a wall trying to I've searched everywhere and can't find a clear answer. I'm relatively new to this, so bear with me. I'm working with a stack overflow behavior when trying to implement a recursive template metaprogram that calculates Fibonacci numbers at compile time using C++20. The code works for small values, but as I try to compute `Fibonacci<30>::value`, I get a stack overflow during the compilation process. Here’s the code snippet I've been working with: ```cpp template<int N> struct Fibonacci { static constexpr int value = Fibonacci<N - 1>::value + Fibonacci<N - 2>::value; }; template<> struct Fibonacci<0> { static constexpr int value = 0; }; template<> struct Fibonacci<1> { static constexpr int value = 1; }; int main() { constexpr int result = Fibonacci<30>::value; return 0; } ``` When I compile this with g++ (version 10.2.0) using the `-std=c++20` flag, I get the behavior: ``` behavior: stack overflow in template instantiation ``` I've read that C++20 introduces concepts and more efficient ways to deal with template metaprogramming, but I’m not sure how to implement those in my case. Also, I tried using the `constexpr` keyword but it seems that the recursion depth is still causing issues. How can I optimize or refactor this code to avoid the stack overflow while still computing Fibonacci numbers at compile time? Has anyone else encountered this? My development environment is Windows. How would you solve this? I'm working on a microservice that needs to handle this. This issue appeared after updating to C++ LTS. This is part of a larger microservice I'm building. Cheers for any assistance!