C++ 比较模板类中的枚举-安全吗？

下面的例子说明了一个简单的问题。编译时，编译器会适当地（？）报告一个警告（我们正在将

barfoo:：bar

与

barfoo:：bar

进行比较），现在给定

bar

是一个枚举-我可以安全地忽略此警告吗

#include <iostream>

using namespace std;
struct foo
{
};

template <typename bob = int>
struct barfoo
{
  enum bar { ONE, TWO, THREE };

  bar action() const { return TWO; }
};

template <barfoo<>::bar eAction = barfoo<>::ONE>
struct IsAction
{
  template <typename bf>
  static bool check(bf const& cState)
  {
    return cState.action() == eAction;
  }  
};

int main(void)
{
  barfoo<foo> c;

  cout << IsAction<>::check(c) << endl;

  return 0;
}

#包括
使用名称空间std；
结构foo
{
};
模板
结构barfoo
{
枚举条{1，2，3}；
bar action（）常量{return TWO；}
};
模板
结构分解
{
模板
静态布尔检查（bf常量和cState）
{
返回cState.action（）==eAction；
}  
};
内部主（空）
{
巴福c；
cout枚举的数字表示形式将是相同的，因此直接比较它们是安全的（甚至可以在它们之间进行强制转换，尽管您可能需要通过
int
来满足编译器的要求）。如果要使警告静音，一种方法是在进行比较之前将它们都强制转换为int:
（int）cState.action==（int）eAction
。您可以为枚举添加一个模板化的
运算符==
，以便自动执行此操作-但目前还不确定

或者，根据您定义“不将枚举移到外部”的方式，您可以从用于保存枚举定义的非模板基类派生，如在
中，我将其移到外部，但移到基类：

struct barenum
{ 
   enum bar { ONE, TWO, THREE };

 protected: // because we are going to derive from it without a virtual destructor
   ~barenum() {}
};

template <typename bob = int>
struct barfoo : barenum
{
  bar action() const { return TWO; }
};

struct-barenum
{ 
枚举条{1，2，3}；
受保护：//因为我们将在没有虚拟析构函数的情况下从它派生
~barenum（）{}
};
模板
结构barfoo:barenum
{
bar action（）常量{return TWO；}
};
是否将枚举移动到barfoo count的父级

#include <iostream>

using namespace std;
struct foo
{
};

struct barfoobase
{
  enum bar { ONE, TWO, THREE };
};

template <typename bob = int>
struct barfoo : public barfoobase
{
  bar action() const { return TWO; }
};

template <barfoobase::bar eAction = barfoobase::ONE>
struct IsAction
{
  template <typename bf>
  static bool check(bf const& cState)
  {
    return cState.action() == eAction;
  }  
};

int main(void)
{
  barfoo<foo> c;

  cout << IsAction<>::check(c) << endl;

  return 0;
}

#包括
使用名称空间std；
结构foo
{
};
结构barfoobase
{
枚举条{1，2，3}；
};
模板
结构barfoo:公共barfoobase
{
bar action（）常量{return TWO；}
};
模板
结构分解
{
模板
静态布尔检查（bf常量和cState）
{
返回cState.action（）==eAction；
}  
};
内部主（空）
{
巴福c；
我想模板化的
操作符==
会有同样的问题吗，我认为派生是最干净的答案…谢谢。我的意思是你可以做一个
模板bool操作符==（const barfoo:：bar&，const barfoo:：bar&）
。有点吓人，但我认为它会起作用……啊，我以为你指的是枚举中的
操作符==
，哦……嗯……是的，我不喜欢上面的
操作符==
：）我已经使用了派生，它很好——我正在等待时间间隔，然后才能接受答案……）@Nim，你的意思是什么？唯一的区别是b在C++中代码< >结构> <代码> >代码>类<代码>，是<代码>结构> <代码>默认为<代码>公共<代码>可见性，而<代码>类< /代码>默认为<代码>私下< /代码> >visibility@bdonlan，对不起，我没有指定
public
继承，这就是为什么我删除了我的评论：）他明确地写道：“有没有一种方法可以满足使用编译器而不将枚举移到外部？。@Frerich，我认为除非我将其转换为int，否则这也是最好的选择-这符合我正在做的事情，所以我们采用了这种方法。@CashCow，很抱歉，我不能接受你的答案，因为@bdonlan首先提到了这一点。@French by“课外”假设他指的是全局范围或名称空间范围，而不是基类范围。我们中的3个人给出了相同的答案可能表明这是一个好答案？