Return to Answer

I however, do not trust the built in types and have decided to stick to <cstdint>, I have put in the std::s before these types and also decided to std:: rather than using namespace std, which I'm sure is a subject that has been discussed enough already

I however, do not trust the built in types and have decided to stick to <cstdint>, I have put in the std::s before these types and also decided to std:: rather than using namespace std, which I'm sure is a subject that has been discussed enough already

#pragma once
#include "stdafx.h"
#include <random>
#include <vector>
#include "IRandom.h"
namespace ConsoleApplicationCpp
{
 class Random : public IRandom
 {
 std::mt19937 randomNumberGenerator;
 std::uniform_real_distribution<std::double_t> realDistribution;
 std::uniform_int_distribution<std::int32_t> byteDistribution;
 public:
 Random(std::uint_least32_t seed);
 Random() : Random(std::_Random_device()) {};
 std::int32_t Next() override;
 std::int32_t Next(std::int32_t maxValue) override;
 std::int32_t Next(std::int32_t minValue, std::int32_t maxValue) override;
 std::double_t NextDouble() override;
 std::double_t NextDouble(std::double_t minValue, std::double_t maxValue) override;
 void NextBytes(std::vector<std::uint8_t>& buffer) override;
 };
}

#include "stdafx.h"
#include <cstdint>
#include <random>
#include "Random.h"
namespace ConsoleApplicationCpp
{
 Random::Random(std::uint_least32_t seed)
 : randomNumberGenerator(seed),
 realDistribution(),
 byteDistribution(0, 256)
 {
 }
 std::int32_t Random::Next()
 {
 return this->Next(0, std::numeric_limits<std::int32_t>::max());
 }
 std::int32_t Random::Next(std::int32_t maxValue)
 {
 return this->Next(0, maxValue);
 }
 std::int32_t Random::Next(std::int32_t minValue, std::int32_t maxValue)
 {
 if (minValue < 0 || maxValue < minValue)
 {
 throw 
 std::invalid_argument("minValue and maxValue must be non-negative. maxValue must be greater than minvalue");
 }
 std::uniform_int_distribution<std::int32_t> distribution(minValue, maxValue);
 return distribution(this->randomNumberGenerator);
 }
 std::double_t Random::NextDouble()
 {
 return this->realDistribution(this->randomNumberGenerator);
 }
 std::double_t Random::NextDouble(std::double_t minValue, std::double_t maxValue)
 {
 if (minValue < 0.0 || maxValue < minValue)
 {
 throw
 std::invalid_argument("minValue and maxValue must be non-negative. maxValue must be greater than minvalue");
 }
 std::uniform_real_distribution<std::double_t> distribution(minValue, minValue);
 return distribution(this->randomNumberGenerator);
 }
 void Random::NextBytes(std::vector<std::uint8_t>& buffer)
 {
 for (auto &i : buffer)
 {
 i = static_cast<std::uint8_t>(byteDistribution(this->randomNumberGenerator));
 }
 }
}

#pragma once
#include "stdafx.h"
#include <random>
#include <vector>
#include "IRandom.h"
namespace ConsoleApplicationCpp
{
 class Random : public IRandom
 {
 std::mt19937 randomNumberGenerator;
 std::uniform_int_distribution<std::int32_t> byteDistribution;
 public:
 Random(std::uint_least32_t seed);
 Random() : Random(std::_Random_device()) {};
 std::int32_t Next() override;
 std::int32_t Next(std::int32_t maxValue) override;
 std::int32_t Next(std::int32_t minValue, std::int32_t maxValue) override;
 std::double_t NextDouble() override;
 std::double_t NextDouble(std::double_t minValue, std::double_t maxValue) override;
 void NextBytes(std::vector<std::uint8_t>& buffer) override;
 };
}

#include "stdafx.h"
#include <cstdint>
#include <random>
#include "Random.h"
namespace ConsoleApplicationCpp
{
 Random::Random(std::uint_least32_t seed)
 : randomNumberGenerator(seed),
 byteDistribution(0, 256)
 {
 }
 std::int32_t Random::Next()
 {
 return this->Next(0, std::numeric_limits<std::int32_t>::max());
 }
 std::int32_t Random::Next(std::int32_t maxValue)
 {
 return this->Next(0, maxValue);
 }
 std::int32_t Random::Next(std::int32_t minValue, std::int32_t maxValue)
 {
 if (minValue < 0 || maxValue < minValue)
 {
 throw 
 std::invalid_argument("minValue and maxValue must be non-negative. maxValue must be greater than minvalue");
 }
 std::uniform_int_distribution<std::int32_t> distribution(minValue, maxValue);
 return distribution(this->randomNumberGenerator);
 }
 std::double_t Random::NextDouble()
 {
 return this->NextDouble(0.0, 1.0);
 }
 std::double_t Random::NextDouble(std::double_t minValue, std::double_t maxValue)
 {
 if (minValue < 0.0 || maxValue < minValue)
 {
 throw
 std::invalid_argument("minValue and maxValue must be non-negative. maxValue must be greater than minvalue");
 }
 std::uniform_real_distribution<std::double_t> distribution(minValue, maxValue);
 return distribution(this->randomNumberGenerator);
 }
 void Random::NextBytes(std::vector<std::uint8_t>& buffer)
 {
 for (auto &i : buffer)
 {
 i = static_cast<std::uint8_t>(byteDistribution(this->randomNumberGenerator));
 }
 }
}

#include "stdafx.h"
#include <cstdint>
#include <random>
#include "Random.h"
namespace ConsoleApplicationCpp
{
 Random::Random(std::uint_least32_t seed)
 : randomNumberGenerator(seed),
 realDistribution(),
 byteDistribution(0, 256)
 {
 }
 std::int32_t Random::Next()
 {
 return this->Next(0, std::numeric_limits<std::int32_t>::max());
 }
 std::int32_t Random::Next(std::int32_t maxValue)
 {
 return this->Next(0, maxValue);
 }
 std::int32_t Random::Next(std::int32_t minValue, std::int32_t maxValue)
 {
 if (minValue < 0 || maxValue < minValue)
 {
 throw 
 std::invalid_argument("minValue and maxValue must be non-negative. maxValue must be greater than minvalue");
 }
 std::uniform_int_distribution<std::int32_t> distribution(minValue, maxValue);
 return distribution(this->randomNumberGenerator);
 }
 std::double_t Random::NextDouble()
 {
 return this->realDistribution(this->randomNumberGenerator);
 }
 std::double_t Random::NextDouble(std::double_t minValue, std::double_t maxValue)
 {
 if (maxValue < minValue)
 {
 throw
 std::invalid_argument("maxValue must be greater than minvalue");
 }
 std::uniform_real_distribution<std::double_t> distribution(minValue, minValue);
 return this->realDistribution(this->randomNumberGenerator);
 }
 void Random::NextBytes(std::vector<std::uint8_t>& buffer)
 {
 for (auto &i : buffer)
 {
 i = static_cast<std::uint8_t>(byteDistribution(this->randomNumberGenerator));
 }
 }
}

#include "stdafx.h"
#include <cstdint>
#include <random>
#include "Random.h"
namespace ConsoleApplicationCpp
{
 Random::Random(std::uint_least32_t seed)
 : randomNumberGenerator(seed),
 realDistribution(),
 byteDistribution(0, 256)
 {
 }
 std::int32_t Random::Next()
 {
 return this->Next(0, std::numeric_limits<std::int32_t>::max());
 }
 std::int32_t Random::Next(std::int32_t maxValue)
 {
 return this->Next(0, maxValue);
 }
 std::int32_t Random::Next(std::int32_t minValue, std::int32_t maxValue)
 {
 if (minValue < 0 || maxValue < minValue)
 {
 throw 
 std::invalid_argument("minValue and maxValue must be non-negative. maxValue must be greater than minvalue");
 }
 std::uniform_int_distribution<std::int32_t> distribution(minValue, maxValue);
 return distribution(this->randomNumberGenerator);
 }
 std::double_t Random::NextDouble()
 {
 return this->realDistribution(this->randomNumberGenerator);
 }
 std::double_t Random::NextDouble(std::double_t minValue, std::double_t maxValue)
 {
 if (minValue < 0.0 || maxValue < minValue)
 {
 throw
 std::invalid_argument("minValue and maxValue must be non-negative. maxValue must be greater than minvalue");
 }
 std::uniform_real_distribution<std::double_t> distribution(minValue, minValue);
 return distribution(this->randomNumberGenerator);
 }
 void Random::NextBytes(std::vector<std::uint8_t>& buffer)
 {
 for (auto &i : buffer)
 {
 i = static_cast<std::uint8_t>(byteDistribution(this->randomNumberGenerator));
 }
 }
}