c++ - Prime Sieve 类还是重载函数？

Question

目前我有两个功能:

• 一个需要生成素数的数量。
• 第二个取素数上限生成。

它们是这样编码的(在 C++ 中):

prime_list erato_sieve(ul_it upper_limit)
{
    prime_list primes;
    if (upper_limit < 2)
        return primes;
    primes.push_back(2); // Initialize Array, and add 2 since its unique.

    for (uit i = 3; i <= upper_limit; i += 2) // Only count odd numbers
    {
        flag is_prime = true;
        for (uit j = 0; j < primes.size(); ++j)
        {
            if ((i % primes[j]) == 0)
            {
                is_prime = false;
                break;
            }
        }
        if (is_prime)
        {
            primes.push_back(i);
        }
    }
    return primes;
}

和:

prime_list erato_sieve_num(ul_it MAX)
{
    prime_list primes;
    if (MAX == 0)
        return primes;
    primes.push_back(2); // Initialize Array, and add 2 since its unique.

    uit i = 3;
    while (primes.size() < MAX) // Only count odd numbers
    {
        flag is_prime = true;
        for (uit j = 0; j < primes.size(); ++j)
        {
            if ((i % primes[j]) == 0)
            {
                is_prime = false;
                break;
            }
        }
        if (is_prime)
        {
            primes.push_back(i);
        }
        ++i;
    }
    return primes;
}

其中定义了以下类型:

typedef bool flag;
typedef unsigned int uit;
typedef unsigned long int ul_it;
typedef unsigned long long int ull_it;
typedef long long int ll_it;
typedef long double ld;

typedef std::vector<ull_it> prime_list;

(如果你喜欢或不喜欢，请随意使用它们。查找替换将解决这个问题。我使用它们来使代码更符合我的想法)

我试图将它们变成一个重载的“函数”，但它们两个具有相似的参数。我担心它们之间的选择会归结为单独类型，这会导致难以调试的问题。

我的第二个选择是创建一个类，但我很尴尬地说..，我以前从未使用过类。完全没有。所以我不知道该怎么做，文档有点……稀疏？

无论如何，如果有人愿意帮助我一点点，我将不胜感激。文档总是有帮助的，也欢迎任何指点。

编辑

正如我所说，我的部分选项是一个类。我完全确定如何创建一个类来将这两者结合起来。

Answer 1

切勿为具有不同语义的函数赋予相同的名称。重载不是为此目的。这两个都采用整数，如果您可以重载它们，您将如何判断在 erato_sieve(5) 调用了哪个函数？

给他们不同的名字，例如erato_sieve_up_to 和 erato_sieve_count。

好吧，如果你仍然想让事情变得更糟(请不要)，你可以重载它们(请不要)，只是让他们期待不同类型的参数。例如，将一个整数包装到一个类中并传递该类，例如

class CountWrapper {
 public:
  CountWrapper(int n) { n_ = n; }
  operator int() { return n_; }
 private:
  int n_;
};

prime_list erato_sieve(const CountWrapper& MAX) {
  // function's body stays the same

并称它为

my_list = erato_sieve(CountWrapper(5));

但再一次:请不要!

要对函数进行分组，您可以将它们定义为类的静态方法:

class PrimeGenerator {
 public:
  static prime_list EratoSieveUpTo(ul_it upper_limit) {
    // body
  }

  static prime_list EratoSieveAmount(ul_it MAX) {
    // body
  }
};

然后像这样调用函数

list1 = PrimeGenerator::EratoSieveUpTo(5);
list2 = PrimeGenerator::EratoSieveAmount(10);