我怎样才能用静态变量 (C++） 干掉这些函数

我很欣赏你的C方法，但在这里C++人们喜欢类。(-：例如，它们允许您通过抽象常量值来不重复自己。对于三个不同的步骤常量，您有相同的代码：1、2 和 3，因此您可以使用如下所示的内容为它们创建模板：

#include <vector>
constexpr long long SIEVE_MAX = 10000;
template <int ADDER_INCREASE>
class GenericSieve
{
    static std::vector<bool> Sieve;
    static std::vector<bool> populated_sieve()
    {
        int number = 0;
        int adder = 1;
        std::vector<bool> sieve(SIEVE_MAX);
        for (int i = 0; i < SIEVE_MAX; i++)
        {
            if (i == number)
            {
                sieve[i] = true;
                number += adder;
                adder += ADDER_INCREASE;
            }
            else
            {
                sieve[i] = false;
            }
        }
        return sieve;
    }
public:
    static bool belongs(long long n)
    {
        if (Sieve.size() == 0)
        {
            Sieve = populated_sieve();
        }
        return Sieve.at(n);
    }
};
template<int inc>
std::vector<bool> GenericSieve<inc>::Sieve;
// define a sieve for every number you like
using TriangularSieve = GenericSieve<1>;
using SquareSieve = GenericSieve<2>;
using PentagonalSieve = GenericSieve<3>;
// define functions if you will
bool isTriangleNumber(long long int n)
{
    return TriangularSieve::belongs(n);
}
bool isSquareNumber(long long int n)
{
    return SquareSieve::belongs(n);
}
bool isPentagonalNumber(long long int n)
{
    return PentagonalSieve::belongs(n);
}

如您所见，我主要使用您的代码，但现在它都是模板化类的静态函数。

模板确实是一种分解代码的方法，例如：

template <std::size_t N>
constexpr std::array<bool, N> make_sieve(std::size_t ADDER_INCREASE)
{
    std::size_t number = 0;
    std::size_t adder = 1;
    std::array<bool, N> sieve{};
    for (std::size_t i = 0; i < N; i++)
    {
        if (i == number)
        {
            sieve[i] = true;
            number += adder;
            adder += ADDER_INCREASE;
        }
        else
        {
            sieve[i] = false;
        }
    }
    return sieve;
}
template <std::size_t N, std::size_t Sieve>
constexpr bool belongs(long long n)
{
    constexpr auto sieve = make_sieve<N>(Sieve);
    return sieve[n];
}
constexpr std::size_t SIEVE_MAX = 10'000;
constexpr bool isTriangleNumber(long long int n) { return belongs<SIEVE_MAX, 1>(n); }
constexpr bool isSquareNumber(long long int n) { return belongs<SIEVE_MAX, 2>(n); }
constexpr bool isPentagonalNumber(long long int n) { return belongs<SIEVE_MAX, 3>(n); }

演示

(我本来更喜欢std::bitset，但缺少一些 constexpr 方法:((
(如果你不能使用constexpr，static const auto sieve = make_sieve<N>(Sieve);只允许计算一次，没有你的init标志(。

void doInit(bool& initialized, bool* sieve, int adderIncrease) {
  if (!initialized) {
    populateFigurateSieve(sieve, adderIncrease);
    initialized = true;
  }
}

然后，使用与之前调用populateFigurateSieve相同的参数调用它，只是您还在前面传递了 initialized 变量。

通过将初始化检查移动到函数而不是每次重复 90% 的检查，在每个函数中节省 2 行。

遵循 DRY 原则的最佳方法是尝试查看类似的代码有哪些共同点。在这里，我注意到您正在对每个函数执行相同的初始化检查，主要区别在于您如何调用populateFigurateSieve函数。然后，我通过参数化差异来制作函数，同时保持相似之处的相同一般结构。

编辑：更好的是，你不需要初始化的变量。您可以让它创建并返回一个数组，而不是传递指向填充函数的指针：

#include <array>
// ...
std::array<bool, SIEVE_MAX> populateFigurateSieve(const int ADDER_INCREASE) {
  std::array<bool, SIEVE_MAX> sieve {};
  // ... (Your code should still work...,)
  return sieve;
}
// ...
// When making the sieve in the function:
static std::array<bool, SIEVE_MAX> sieve = populateFigurateSieve( /* Required value here */);
// No longer need initialized variable
// ....