Prime Sieve class or overloaded function? - c++

Question

Currently I have two functions:
One takes the number of primes to generate.
The second takes the upper limit of primes to generate.
They are coded (In C++) as such:
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;
}
And:
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;
}
Where the following types are defined:
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;
(Feel free to use them if you like, or not. A find-replace will take care of that. I use them to make the code read more how I think)
I am trying to make these into one "function" that is overloaded, but they two have similar arguments. I'm worried that the choice between them will come down to type alone, which will lead to hard-to-debug problems.
My second option would be to create a class, but I'm quite embarrassed to say.., I've never used classes before. At all. So I have no idea how to do it, and the documentation is a little... sparse?
Anyway, if someone would mind helping me out a little bit, it would be greatly appreciated. Documentation is always helpful, and any pointers are welcome as well.
EDIT
As I said, my section option is a class. I'm just entirely sure how to make a class to combine these two.

Answer 1

Never give the same name to functions with different semantics. Overloading is not purposed for that. And these two both take an integer number, if you could overload them how would you tell which function is called at erato_sieve(5)?
Give them different names, e.g. erato_sieve_up_to and erato_sieve_count.
Well, if you still want to make things worse (please don't), you can overload them (please don't), just make them expect different types of arguments. For example, wrap an integer into a class and pass that class, something like
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
And call it like
my_list = erato_sieve(CountWrapper(5));
But once again: please don't!
To group the functions, you can define them as static methods of a class:
class PrimeGenerator {
public:
static prime_list EratoSieveUpTo(ul_it upper_limit) {
// body
}
static prime_list EratoSieveAmount(ul_it MAX) {
// body
}
};
and call the functions like
list1 = PrimeGenerator::EratoSieveUpTo(5);
list2 = PrimeGenerator::EratoSieveAmount(10);

Answer 2

If you want to create overloaded functions, you need a different argument list for each function definition. In the case the actual used arguments are of same type, the following trick can be used:
typedef struct {} flag_type_1;
typedef struct {} flag_type_2;
...
typedef struct {} flag_type_n;
prime_list erato_sieve(ul_it boundary, flag_type_1) { ... }
prime_list erato_sieve(ul_it boundary, flag_type_2) { ... }
...
prime_list erato_sieve(ul_it boundary, flag_type_n) { ... }
The idea is that each typedef-ed structure is of different type signature. This creates completely unrelated argument list for each function overload. Also, as the types are dummy holder, you don't care about the content. That's why you only need to include type in the argument list of the function definition.
I picked this up a while back from Channel 9. Pretty neat trick.

Answer 3

This isn't a direct answer to your question, but it will help answer your question.
You appear to be attempting to implement the Sieve of Eratosthenes. The basic algorithm for that sieve is below:
1) Create a list of numbers from 2 to N (N is the maximum value you are looking for)
2) Start at 2, and eliminate all other even numbers (they are non-prime) less than or equal to N
3) Move to the next non-eliminated number.
4) Eliminate all multiples of that number less than or equal to N.
5) Repeat steps 3 and 4 until you reach the square root of N.
Translating that into C++ code, it would look something like this (not optimized):
std::vector<unsigned int> sieve_of_eratosthenes(unsigned int maximum)
{
std::vector<unsigned int> results; // this is your result set
std::vector<bool> tests(maximum + 1); // this will be your "number list"
// initialize the tests vector
for (unsigned int i = 0; i <= maximum; ++i)
{
if (i == 0 || i == 1)
tests[i] = false;
else
tests[i] = true;
}
// eliminate all even numbers but 2
for (unsigned int i = 4; i <= maximum; i += 2)
{
tests[i] = false;
}
// start with 3 and go to root of maximum
unsigned int i = 3;
while (i * i <= maximum)
{
for (unsigned int j = i + i; j <= maximum; j += i)
{
tests[j] = false;
}
// find the next non-eliminated value
unsigned int k = i + 1;
while (!tests[k])
{
k++;
}
i = k;
}
// create your results list
for (unsigned int j = 0; j <= maximum; ++j)
{
if (tests[j])
{
results.push_back(j);
}
}
return results;
}
Example
Since the sieve requires a maximum value, you do not want to provide a number of primes for this algorithm. There are other prime generating algorithms that do that, but the Sieve of Eratosthenes does not.