如何限制类/结构，使其仅某些预定义对象可以存在？

Question

假设您的程序需要跟踪一年中的月份。每个月都有一个名称和长度（以天为单位）。显然，这是您想要在编译时定义的信息，并且您想要限制您的程序，以便在运行时不能定义其他月份信息。当然，您希望方便地访问月份数据，而不需要复杂的方法调用。此信息的典型用例松散是这样的：

Month m = GetRandomMonth();
if ( m == FEBRUARY )
    CreateAppointment(2011, m, 28);

// Iterating over all months would be optional, but a nice bonus
for (/* each month m*/)
    cout << "Month " << m.name << " has " << m.num_days << " days." << endl;

而不应该飞行的东西包括：（

Month m = Month("Jabruapril", 42);  // should give compiler error

Month m = MonthService().getInstance().getMonthByName("February");  // screw this

我故意使代码尽可能模糊，以表明我不限于任何特定的实现方法。）

解决这个问题最优雅的方法是什么？我添加了自己的问题以供公众审查，但欢迎其他解决方案。

Answer 1

怎么样：

class Month
{
public:
    static const Month JANUARY;
    static const Month FEBRUARY;
    ...

private:
    Month(const std::string &name, int days) : name(name), days(days) {}

    const std::string   name;
    const int           days;
};

const Month Month::JANUARY = Month("January", 31);
const Month Month::FEBRUARY = Month("February", 28);
...

Answer 2

将 Month 的构造函数设为私有，并公开静态函数调用 getMonth。

简而言之，让 Month 单例！嗯，这就是根据我从你的问题中了解到的内容。

--

编辑：

我想改进您的实施。由于 Months 不是必需的，所以我删除了它：

class Month
{
public:
    string name;
    int num_days;
public:
    static const Month JANUARY;
    static const Month FEBRUARY;
private:
    Month(string n, int nd) : name(n), num_days(nd) {}
};

const Month Month::JANUARY = Month("January", 31);
const Month Month::FEBRUARY = Month("February", 28);

Answer 3

如果不需要状态，最好是使用枚举。否则，您需要 Singleton 的变体，其中有许多该类的预定义实例，而不是不仅仅是一个。其关键是将构造函数声明为私有，以便外部各方无法实例化该类，并将该类的所有需要​​的实例定义为静态成员。

class Month {
  public:
    static const Month JANUARY(...);
    ...
    static const Month DECEMBER(...);

    // public API
private:
  Month(...);

    // private members
};

const Month Month::JANUARY = Month(...);
...
const Month Month::DECEMBER = Month(...);

Answer 4

我认为有几种方法可以看待这个问题：

1) Month 是一个枚举类型，有 12 个元素代表公历 12 个月的属性。由于 C++ 没有显式提供枚举类类型，因此我们将使用以下任一方法来伪造它：

• 私有构造函数和对实例的公共访问（数组、静态数据成员、全局变量或需要月份数字或的函数）名称并返回指针/引用）。这是一个修改后的单例。

• 公共构造函数，用于验证名称或月份编号，并填写类持有的内部知识的天数。这给出了类值语义。

请注意，为此目的，修改后的 Singleton（12 吨）实际上可能并不正确。您在标题中说“只有某些预定义对象可以存在”，但在代码中您编写了 Month m = GetRandomMonth();，这会创建一个新的 Month 对象，名为m。因此，不仅存在某些预定义的对象，您还可以在那里创建一个对象。看起来您想按值使用月份，而不仅仅是通过引用预定义对象。

为此，您需要 Month 拥有一个可访问的复制构造函数，并且您可能还需要一个赋值运算符。这意味着它不是 Twelveleton（即限制为该类型的 12 个对象），只是只有 12 个可能的不同的、不相等的值。类比一下 char 类型 - 只有 256 个可能的值（在我的实现中），但我可以轻松创建超过 256 个对象： char x[257] = {0};< /代码>。

2) Month 是表示月份的通用类型。在公历中实际使用只有 12 个这种类型的值（如果您对闰年的二月使用不同的值，则为 13 个），但如果您想创建 Month(" Jabruapril", 42)（虚构），或月份("Nisan", 30)（希伯来语），或月份("十二月", 30)（朱利安改革之前的罗马历法），因为您认为该类定义的属性将帮助您完成您正在做的事情，那么欢迎您。检查月份是否是有效的公历月份以及获取公历月份是与创建一般月份不同的问题。

(1) 和 (2) 中的每一个都可能是正确的设计。

如果 Month 类中内置了很多采用公历的逻辑，那么 (2) 不太可能有任何用处，如果您尝试使用该类，它只会给出错误的答案在希伯来历中。由于公历永远不会改变（我们都真诚地希望），因此在使用无效公历月份的情况下使类可测试的里程并不多。老实说，我无法预测如果日历确实发生变化，它会如何变化，因此我无法编写测试来确保我的代码已准备好进行更改。所以 (1) 可能就是您想要的。

如果 Month 本身并没有做很多事情，它只是将一些东西组合在一起组成一年，并且日历智能位于其他地方，那么 (2) 可能会有用 - 您或其他人将重用它来实现其他日历。原则上，我赞成为我的类的用户提供尽可能多的灵活性，尽管在实践中有时它会给类带来不合理的单元测试负担。

Answer 5

这是我自己的解决方案：

class Month
{
public:
    string name;
    int num_days;
private:
    Month(string n, int nd) : name(n), num_days(nd) {}
    friend class Months;
};

class Months
{
public:
    static const Month JANUARY;
    static const Month FEBRUARY;
    // ...
private:
    Months() {}
};

const Month Months::JANUARY = Month("January", 31);
const Month Months::FEBRUARY = Month("February", 28);
// ...

bool operator==(const Month& lhs, const Month& rhs)
{
    return lhs.name == rhs.name;
}

int main()
{
    cout << Months::JANUARY.name << " " << Months::JANUARY.num_days << endl;
    Month m = Months::FEBRUARY;
    if ( m == Months::FEBRUARY )
        cout << m.name << " " << m.num_days << endl;
    return 0;
}

这似乎工作得很好，尽管我无法迭代几个月。不过，可以通过将 Month 对象放入数组中并将各个月份定义为对数组元素的引用来解决此问题。

Answer 6

这是一个带有枚举类的解决方案（需要 C++11）。我只用了两个月的时间来保持代码简短。这个设计没有使用面向对象的范式，结果简单得多，即使是初学者也能理解。 C++ 是一种多范式语言。针对给定问题采用最​​简单的解决方案而不是专注于某一特定范式是值得的。

注意：这是第一个正确考虑这一事实的答案，即二月的天数根据年份而变化。每月的天数不能是月份“对象”的静态属性，因为它取决于年份。人们必须使用方法或函数来获取每月的天数。

#include <ostream>
#include <cassert>
#include <iostream>

enum class Month {
  January, February
};

// conversion to stream to get name as string, for example
inline std::ostream& operator<<(std::ostream& os, Month m) {
  switch (m) {
    case Month::January: os << "January"; break;
    case Month::February: os << "February"; break;
    default: assert(false); // never arrive here
  }
  return os;
}

inline unsigned leap_days(int year) {
  return 0; // TODO, returns extra days for leap years
}

inline unsigned days(Month m, int year) {
  switch (m) {
    case Month::January: return 31;
    case Month::February: return 27 + leap_days(year);
  }
  assert(false); // never arrive here
  return 0;
}

// allows to iterate over months with a range-based for loop
// like so: for(Month m : months) { ... }
constexpr Month months[] = { Month::January, Month::February };

int main() {
    for (Month m : months) {
        std::cout << "month " << m << " has " << days(m, 2019) << std::endl;
    }
}