Question

Polymorphic Enums？

在C ++中，我们经常使用多态来允许旧代码处理新代码   代码 - 例如，只要我们对a期望的接口进行子类化   函数，我们可以传入新类并期望它正常工作   使用在新类存在之前编写的代码。   不幸的是，对于枚举，你不能真正做到这一点，即使在那里   偶尔你会喜欢。（例如，如果你是   管理程序的设置，并将所有设置存储为   枚举值，然后从枚举，settings_t，可能是很好的   所有其他枚举都继承了，以便您可以存储每个枚举   设置列表中的新枚举。请注意，因为列表包含   不同类型的值，您不能使用模板。）

如果您需要这种行为，则必须将枚举存储为   整数，然后使用类型转换检索它们来分配   特别重视利息的设定。你甚至不会得到   dynamic_cast的好处是帮助您确保演员阵容   安全 - 你必须依赖不正确的值不可能的事实   存储在列表中。

我引用C++ programming tutorial。

任何人都可以更深入地解释，并通过一些例子说明多态Enum是如何工作的？在我有模板的情况下？

Answer 1

简单地说，enum只是一个命名的常量值，例如：

enum Settings
{
   setting_number_0,
   setting_number_1,
   setting_number_2,      
};

在上面的示例中，setting_number_X只是值X的命名常量，因为枚举值从0开始并单调增加。

保留这些，在某种类型的容器中提供了一个基本的整数存储类型，但仍然可以有些类型安全。

std::vector<Setting> app_settings;

// this works
app_settings.push_back(setting_number_0);

// this is a compile time failure, even though the underlying storage
// type for Setting is an integral value.  This keeps you from adding
// invalid settings types to your container (like 13 here)
app_settings.push_back(13);

// but you also cannot (directly) add valid setting values (like 1)
// as an integral, this is also a compile time failure.
app_settings.push_back(1);

现在，假设您要添加其他特定设置类型并将它们全部保存在容器中。

enum DisplaySettings
{
   // ...
};

enum EngineSettings
{
   // ...
};

现在，如果您想将所有设置保留在单个容器中，则无法安全。您可以将所有整数值存储在std::vector<int>或类似的容器中，但这会导致您无法确定哪些整数类型属于哪些设置枚举。此外，由于类型不同，您无法将它们存储在一个类型安全的容器中。

解决这个问题的正确方法是将设置的功能存储在容器中，如下所示：

#include <vector>
#include <iostream>

// This is our "base class" type so we can store lots of 
// different setting types in our container
class setting_action
{
public:
   // we enable the setting by calling our function
   void enable_setting()
   {
      setting_function_(this);
   }

protected:
   // This is a function pointer, and we're using it to get some
   // compile time polymorphism
   typedef void (*setting_function_type)(setting_action* setting);

   // these can only be constructed by derived types, and the derived
   // type will provide the polymorhpic behavior by means of the 
   // above function pointer and based on the derived type's handler
   setting_action(setting_function_type func)
      : setting_function_(func)
   {
   }

public:
   ~setting_action()
   {
   }

private:
   setting_function_type setting_function_;
};

// This is the derived type, and where most of the magic
// happens.  This is templated on our actual setting type
// that we define below    
template <class Setting>
class templated_setting_action
   : public setting_action
{
public:
   templated_setting_action(Setting setting)
      : setting_action(&templated_setting_action::enable_setting)
      , setting_(setting)
   {
   }

   // This function catches the "enable_setting" call from
   // our base class, and directs it to the handler functor
   // object that we've defined
   static void enable_setting(setting_action* base)
   {
      templated_setting_action<Setting>* local_this = 
         static_cast<templated_setting_action<Setting>*>(base);

      local_this->setting_();
   }

private:
   Setting setting_;
};

// this is just a shorthand way of creating the specialized types
template <class T>
setting_action* create_specialized_setting_action(T type)
{
   return
      new templated_setting_action<T>(type);
}

// Our actual settings:
// this one displays the user name    
struct display_user_name
{
   void operator()()
   {
      std::cout << "Chad.\n";
   }
};

// this one displays a short welcome message    
struct display_welcome_message
{
   void operator()()
   {
      std::cout << "Ahh, the magic of templates.  Welcome!\n";
   }
};

// now, we can have one container for ALL our application settings

std::vector<setting_action*> app_settings;

int main()
{
   // now we can add our settings to the container...
   app_settings.push_back(create_specialized_setting_action(display_user_name()));
   app_settings.push_back(create_specialized_setting_action(display_welcome_message()));

   // and individually enable them
   app_settings[0]->enable_setting();
   app_settings[1]->enable_setting();

   // also, need to delete each setting to avoid leaking the memory
   // left as an exercise for the reader :)
   return 0;
}

多态枚举

1 个答案: