C++ 调用自身的模板函数会导致；实例化深度超过最大值900“；

我试图创建一个函数，该函数接受lambda函数回调和一些

候选素数

，它们可以是

集合

或

向量

，但它给出了错误：

模板实例化深度超过最大值900

模板
void iter_可行的_素数(
常量素数和候选素数，常量uint32更大的素数，uint8索引，函数cb
) {
向量下一个候选素数；
for（const uint32\u t p：候选素数）{
//更新下一个\u候选\u素数
}
如果（索引==0）{
//找不到有效的素数元组
返回；
}
for（const uint32\u t p:next\u候选者\u素数）{
iter可行素数（下一个候选素数，p，索引-1，[&]（标准：：向量小素数）{
较小的素数。推回（p）；
cb（较小的_素数）；
});
}
}

我认为问题在于函数使用lambda来调用自己，而编译器不理解函数本身只是有一个lambda回调类型

我怎样才能解决这个问题

---

我试图将

index

设置为模板参数，但没有效果，因为编译器似乎不明白它永远不会到达

index=-1

，并向我抱怨

-1

没有定义。但理想情况下，我不希望

索引
成为模板参数。
事实上lambda具有唯一的类型，因此必须实例化无限递归

解决这个问题的一种方法是给出一个唯一的类型，或者是一个自定义functor，或者是一个类型擦除类型，如
std:：function

template<class PrimeIter>
void iter_feasable_primes(
  const PrimeIter& candidate_primes,
  uint32_t larger_prime,
  uint8_t index,
  std::function<void(std::vector<uint32_t>)> cb)
{
  std::vector<uint32_t> next_candidate_primes;
  for (const uint32_t p : candidate_primes) {
    // Updates next_candidate_primes
  }
  if (index == 0) {
    // No valid tuples of primes were found
    return;
  }
  for (const uint32_t p : next_candidate_primes) {
    iter_feasable_primes(next_candidate_primes, p, index - 1, [&](std::vector<uint32_t> smaller_primes) {
      smaller_primes.push_back(p);
      cb(smaller_primes);
    });
  }
}

模板
void iter_可行的_素数(
常量素数和候选素数，
uint32\u t更大的素数，
uint8_t索引，
std:：函数（cb）
{
向量下一个候选素数；
for（const uint32\u t p：候选素数）{
//更新下一个\u候选\u素数
}
如果（索引==0）{
//找不到有效的素数元组
返回；
}
for（const uint32\u t p:next\u候选者\u素数）{
iter可行素数（下一个候选素数，p，索引-1，[&]（标准：：向量小素数）{
较小的素数。推回（p）；
cb（较小的_素数）；
});
}
}
事实上，lambda具有唯一的类型，因此必须实例化无限递归

解决这个问题的一种方法是给出一个唯一的类型，或者是一个自定义functor，或者是一个类型擦除类型，如
std:：function

template<class PrimeIter>
void iter_feasable_primes(
  const PrimeIter& candidate_primes,
  uint32_t larger_prime,
  uint8_t index,
  std::function<void(std::vector<uint32_t>)> cb)
{
  std::vector<uint32_t> next_candidate_primes;
  for (const uint32_t p : candidate_primes) {
    // Updates next_candidate_primes
  }
  if (index == 0) {
    // No valid tuples of primes were found
    return;
  }
  for (const uint32_t p : next_candidate_primes) {
    iter_feasable_primes(next_candidate_primes, p, index - 1, [&](std::vector<uint32_t> smaller_primes) {
      smaller_primes.push_back(p);
      cb(smaller_primes);
    });
  }
}

模板
void iter_可行的_素数(
常量素数和候选素数，
uint32\u t更大的素数，
uint8_t索引，
std:：函数（cb）
{
向量下一个候选素数；
for（const uint32\u t p：候选素数）{
//更新下一个\u候选\u素数
}
如果（索引==0）{
//找不到有效的素数元组
返回；
}
for（const uint32\u t p:next\u候选者\u素数）{
iter可行素数（下一个候选素数，p，索引-1，[&]（标准：：向量小素数）{
较小的素数。推回（p）；
cb（较小的_素数）；
});
}
}