Finalized the implementation

Makefile

@@ -5,4 +5,4 @@ compile:
 	g++ *.cpp -O3 -c
 
 debug:
-	g++ *.cpp -g -std=c++17 -o calculator -lstdc++ -lm
+	g++ *.cpp -g -std=c++17 -o lottery -lstdc++ -lm

device_generator.cpp

@@ -0,0 +1,15 @@
+#include "device_generator.h"
+#include <random>
+
+DeviceGenerator::DeviceGenerator(int max_range, int num_entries): 
+    ImplGenerator{num_entries},
+    m_max_range{max_range}, m_num_entries{num_entries}
+{}
+
+int DeviceGenerator::get_next_num_internal()
+{
+    std::random_device rd;
+    std::uniform_int_distribution<int> dist(0, m_max_range);
+
+    return dist(rd);
+}

device_generator.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "impl_generator.h"
+
+class DeviceGenerator: public ImplGenerator
+{
+    public:
+    DeviceGenerator(int max_range, int num_entries);
+    int get_next_num_internal() override;
+
+    private:
+    int m_max_range;
+    int m_num_entries;
+};

generator.cpp

@@ -0,0 +1,34 @@
+#include "generator.h"
+#include "impl_generator.h"
+#include "input_parsing.h"
+#include "mersenne_generator.h"
+#include "device_generator.h"
+
+#include <memory>
+
+
+Generator::Generator(const ProgramOptions& options): m_options{options}
+{
+    if (m_options.seed != std::nullopt)
+    {
+        impl = std::make_unique<MersenneGenerator>(*m_options.seed, m_options.max_range,
+            m_options.num_entries);
+    }
+    else
+    {
+        impl= std::make_unique<DeviceGenerator>(m_options.max_range,
+            m_options.num_entries);
+    }
+}
+
+int Generator::get_next_num()
+{
+    if (impl->has_more_numbers())
+    {
+        return impl->get_next_num();
+    }
+    else
+    {
+        return NO_MORE_NUMBERS;
+    }
+}

generator.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include "impl_generator.h"
+
+#include <memory>
+
+class ProgramOptions;
+
+class Generator
+{
+    public:
+
+    static constexpr int NO_MORE_NUMBERS = -1;
+
+    Generator(const ProgramOptions& options);
+    ~Generator() = default;
+
+    int get_next_num();
+
+    private:
+    const ProgramOptions& m_options;
+    std::unique_ptr<ImplGenerator> impl = nullptr;
+
+};

impl_generator.cpp

@@ -0,0 +1,25 @@
+#include "impl_generator.h"
+
+ImplGenerator::ImplGenerator(int nr_entries)
+    : m_nr_entries{nr_entries}
+{}
+
+int ImplGenerator::get_next_num()
+{
+    int num;
+    do
+    {
+        num = get_next_num_internal();
+    }
+    while (already_generated_numbers.count(num) > 0);
+    
+    internal_counter++;
+
+    return num;
+}
+
+
+bool ImplGenerator::has_more_numbers()
+{
+    return internal_counter < m_nr_entries;
+}

impl_generator.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include <unordered_set>
+
+class ImplGenerator
+{
+    public:
+    ImplGenerator(int nr_entries);
+    bool has_more_numbers();
+    int get_next_num();
+
+    private:
+    int m_nr_entries;
+    int internal_counter = 0;
+    std::unordered_set<int> already_generated_numbers;
+
+    virtual int get_next_num_internal() = 0;
+};

input_parsing.cpp

@@ -45,5 +45,7 @@ ProgramOptions get_params(int argc, char *argv[])
 		}
 	}
 
-	return {max_range, num_entries, is_seed_specified ? std::optional<int>(seed): std::nullopt};
+	using return_type = std::optional<int>;
+
+	return {max_range, num_entries, is_seed_specified ? return_type(seed): std::nullopt};
 }	

main.cpp

@@ -1,10 +1,47 @@
 #include "input_parsing.h"
+#include "generator.h"
 
 #include <iostream>
-#include <stdlib.h>
+#include <vector>
 
 int main(int argc, char *argv[])
 {
 	auto parameters = get_params(argc, argv);
+	Generator gen(parameters);
+
+	std::cout << "Output:\n";
+	int num = gen.get_next_num();
+	std::vector<int> correct_guesses;
+	double accuracy = 1.0;
+
+	while(num != gen.NO_MORE_NUMBERS)
+	{
+		int user_guess;
+		std::cout << "What's your guess (max= " << parameters.max_range <<"): ";
+		std::cin >> user_guess;
+		
+		while (std::cin.fail() || user_guess < 0)
+		{
+			std::cin.clear();
+
+			std::cout << "Invalid number introduced\n";
+			std::cin >> user_guess;
+		}
+
+		std::cout << "Next\n";
+		correct_guesses.emplace_back(num);
+
+		accuracy -= abs(user_guess - num) / 100.;
+		num = gen.get_next_num();
+	}
+
+	std::cout << "Final results:\nCorrect guesses: ";
+	for(int v: correct_guesses)
+	{
+		std::cout << v << ", ";
+	}
+	std::cout << std::endl;
+
+	std::cout << "Accuracy: " << accuracy << "%\n";
 	return 0;
 }

mersenne_generator.cpp

@@ -0,0 +1,20 @@
+#include "mersenne_generator.h"
+#include <random>
+
+MersenneGenerator::MersenneGenerator(int seed, int max_range, int nr_entries)
+    : ImplGenerator{nr_entries}
+{
+    m_seed = seed;
+    m_max_range = max_range;
+    m_nr_entries = nr_entries; 
+}
+
+int MersenneGenerator::get_next_num_internal()
+{
+    std::mt19937 gen(m_seed); // mersenne_twister_engine seeded with rd()
+    std::uniform_int_distribution<> distrib(0, m_max_range);
+
+    internal_counter++;
+
+    return distrib(gen);
+}

mersenne_generator.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include "impl_generator.h"
+
+class MersenneGenerator: public ImplGenerator
+{
+    public:
+    MersenneGenerator(int seed, int max_range, int nr_entries);
+    int get_next_num_internal() override;
+
+    private:
+    int m_seed;
+    int m_max_range;
+    int m_nr_entries;
+
+    int internal_counter = 0;
+};