我在Project Euler中遇到了一个问题,包括找到Triangle,Square,Pentagonal,......,八角形数字,所以我正在尝试创建这个实用程序来验证每种数字。我决定为每组数字创建快速访问的筛子,我将它存储在一个静态数组中。我能够制作一个能生成每个筛子的通用函数,但这使得每个验证函数都非常相似。由于他们使用静态bool数组的方式,我没有看到避免重复这些函数中的代码的好方法。你有什么想法来干这个?
#ifndef FIGURATE_NUMBERS
#define FIGURATE_NUMBERS
#define SIEVE_MAX 10000
void populateFigurateSieve(bool* sieve, const int ADDER_INCREASE)
{
int number = 0;
int adder = 1;
for (int i = 0; i < SIEVE_MAX; i++)
{
if (i == number)
{
sieve[i] = true;
number += adder;
adder += ADDER_INCREASE;
}
else
{
sieve[i] = false;
}
}
return;
}
bool isTriangleNumber(long long int n)
{
static bool triangleNumberSieve[SIEVE_MAX];
static bool initialized = false;
if (!initialized)
{
populateFigurateSieve(triangleNumberSieve, 1);
initialized = true;
}
return triangleNumberSieve[n];
}
bool isSquareNumber(long long int n)
{
static bool squareNumberSieve[SIEVE_MAX];
static bool initialized = false;
if (!initialized)
{
populateFigurateSieve(squareNumberSieve, 2);
initialized = true;
}
return squareNumberSieve[n];
}
bool isPentagonalNumber(long long int n)
{
static bool pentagonalNumberSieve[SIEVE_MAX];
static bool initialized = false;
if (!initialized)
{
populateFigurateSieve(pentagonalNumberSieve, 3);
initialized = true;
}
return pentagonalNumberSieve[n];
}
#endif
我很欣赏你的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
函数。然后我通过参数化差异来实现该功能,同时保持相同的一般结构。
编辑:更好的是,您不需要初始化变量。您可以让它创建并返回一个数组,而不是将指针传递给populate函数:
#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
// ....