blocks|key|165435|text|不，他们不能。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|165436|我可以理解，C%2B%2B11中强类型枚举的enum+class部分似乎暗示您的enum也具有class特征，但事实并非如此。我有根据的猜测是，关键字的选择受到了我们在C%2B%2B11之前用于获取作用域枚举的模式的启发：|offset|length|style|CODE|165437|class+Foo+{
public:
++enum+{BAR,+BAZ};
};|code-block|syntax|javascript|165438|然而，这只是语法。再说一次，enum+class不是class。|165439|entityMap^0|0|I|A|10|4|17|5|0|0|E|A|Q|5|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@$D|S|E|T|F|G]|$D|U|E|V|F|G]|$D|W|E|X|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|Y|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|Z|8|@$D|10|E|11|F|G]|$D|12|E|13|F|G]]|9|@]|A|$]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|P|$]]

No, they can't.

I can understand that the <code>enum class</code> part for strongly typed enums in C++11 might seem to imply that your <code>enum</code> has <code>class</code> traits too, but it's not the case. My educated guess is that the choice of the keywords was inspired by the pattern we used before C++11 to get scoped enums:

<pre><code>class Foo {
public:
 enum {BAR, BAZ};
};
</code></pre>

However, that's just syntax. Again, <code>enum class</code> is not a <code>class</code>.

blocks|key|165481|text|专注于问题的描述而不是标题，一个可能的答案是|type|unstyled|depth|inlineStyleRanges|entityRanges|data|165482|struct+LowLevelMouseEvent+{
++++enum+Enum+{
++++++++mouse_event_uninitialized+=+-2000000000,+//+generate+crash+if+try+to+use+it+uninitialized.
++++++++mouse_event_unknown+=+0,
++++++++mouse_event_unimplemented,
++++++++mouse_event_unnecessary,
++++++++mouse_event_move,
++++++++mouse_event_left_down,
++++++++mouse_event_left_up,
++++++++mouse_event_right_down,
++++++++mouse_event_right_up,
++++++++mouse_event_middle_down,
++++++++mouse_event_middle_up,
++++++++mouse_event_wheel
++++};
++++static+const+char*+ToStr+(const+type::LowLevelMouseEvent::Enum&+event)
++++{
++++++++switch+(event)+{
++++++++++++case+mouse_event_unknown:+++++++++return+"unknown";
++++++++++++case+mouse_event_unimplemented:+++return+"unimplemented";
++++++++++++case+mouse_event_unnecessary:+++++return+"unnecessary";
++++++++++++case+mouse_event_move:++++++++++++return+"move";
++++++++++++case+mouse_event_left_down:+++++++return+"left+down";
++++++++++++case+mouse_event_left_up:+++++++++return+"left+up";
++++++++++++case+mouse_event_right_down:++++++return+"right+down";
++++++++++++case+mouse_event_right_up:++++++++return+"right+up";
++++++++++++case+mouse_event_middle_down:+++++return+"middle+down";
++++++++++++case+mouse_event_middle_up:+++++++return+"middle+up";
++++++++++++case+mouse_event_wheel:+++++++++++return+"wheel";
++++++++++++default:
++++++++++++++++Assert+(false);
++++++++++++++++break;
++++++++}
++++++++return+"";
++++}
};|code-block|syntax|javascript|165483|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Concentrating on the description of the question instead of the title a possible answer is 

<pre><code>struct LowLevelMouseEvent {
 enum Enum {
 mouse_event_uninitialized = -2000000000, // generate crash if try to use it uninitialized.
 mouse_event_unknown = 0,
 mouse_event_unimplemented,
 mouse_event_unnecessary,
 mouse_event_move,
 mouse_event_left_down,
 mouse_event_left_up,
 mouse_event_right_down,
 mouse_event_right_up,
 mouse_event_middle_down,
 mouse_event_middle_up,
 mouse_event_wheel
 };
 static const char* ToStr (const type::LowLevelMouseEvent::Enum&amp; event)
 {
 switch (event) {
 case mouse_event_unknown: return "unknown";
 case mouse_event_unimplemented: return "unimplemented";
 case mouse_event_unnecessary: return "unnecessary";
 case mouse_event_move: return "move";
 case mouse_event_left_down: return "left down";
 case mouse_event_left_up: return "left up";
 case mouse_event_right_down: return "right down";
 case mouse_event_right_up: return "right up";
 case mouse_event_middle_down: return "middle down";
 case mouse_event_middle_up: return "middle up";
 case mouse_event_wheel: return "wheel";
 default:
 Assert (false);
 break;
 }
 return "";
 }
};
</code></pre>

blocks|key|4671494|text|虽然“你不能”的答案在技术上是正确的，但我相信你可以使用以下想法来实现你正在寻找的行为：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4671495|我假设你想要写下这样的代码：|4671496|Fruit+f+=+Fruit::Strawberry;
f.IsYellow();|code-block|syntax|javascript|4671497|您希望代码看起来像这样：|4671498|enum+class+Fruit+:+uint8_t
{
++Apple,+
++Pear,
++Banana,
++Strawberry,

++bool+IsYellow()+{+return+this+==+Banana;+}
};|4671499|但当然，它不能工作，因为枚举不能有方法(+'this‘在上面的上下文中没有任何意义)|4671500|但是，如果使用包含非类枚举的普通类和包含该类型的值的单个成员变量的概念，则可以非常接近所需的语法/行为/类型安全性。即：|4671501|class+Fruit
{
public:
++enum+Value+:+uint8_t
++{
++++Apple,
++++Pear,
++++Banana,
++++Strawberry
++};

++Fruit()+=+default;
++constexpr+Fruit(Value+aFruit)+:+value(aFruit)+{+}

#if+Enable+switch(fruit)+use+case:
++//+Allow+switch+and+comparisons.
++constexpr+operator+Value()+const+{+return+value;+}

++//+Prevent+usage:+if(fruit)
++explicit+operator+bool()+=+delete;++++++++
#else
++constexpr+bool+operator==(Fruit+a)+const+{+return+value+==+a.value;+}
++constexpr+bool+operator!=(Fruit+a)+const+{+return+value+!=+a.value;+}
#endif

++constexpr+bool+IsYellow()+const+{+return+value+==+Banana;+}

private:
++Value+value;
};|4671502|现在你可以写下：|4671503|Fruit+f+=+Fruit::Strawberry;
f.IsYellow();|4671504|编译器会阻止类似这样的事情发生：|4671505|Fruit+f+=+1;++//+Compile+time+error.|4671506|您可以很容易地添加这样的方法：|4671507|Fruit+f("Apple");|4671508|和|4671509|f.ToString();|4671510|可以被支持。|4671511|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1C|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1D|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|1E|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|1F|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|1G|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|1H|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|1I|8|@]|9|@]|A|$]]|$1|Q|3|R|5|F|7|1J|8|@]|9|@]|A|$G|H]]|$1|S|3|T|5|6|7|1K|8|@]|9|@]|A|$]]|$1|U|3|V|5|F|7|1L|8|@]|9|@]|A|$G|H]]|$1|W|3|X|5|6|7|1M|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|F|7|1N|8|@]|9|@]|A|$G|H]]|$1|10|3|11|5|6|7|1O|8|@]|9|@]|A|$]]|$1|12|3|13|5|F|7|1P|8|@]|9|@]|A|$G|H]]|$1|14|3|15|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|16|3|17|5|F|7|1R|8|@]|9|@]|A|$G|H]]|$1|18|3|19|5|6|7|1S|8|@]|9|@]|A|$]]|$1|1A|3|-4|5|6|7|1T|8|@]|9|@]|A|$]]]|1B|$]]

While the answer that &quot;you can't&quot; is technically correct, I believe you may be able to achieve the behavior you're looking for using the following idea:
I imagine that you want to write something like:
<pre><code>Fruit f = Fruit::Strawberry;
f.IsYellow();
</code></pre>
And you were hoping that the code looks something like this:
<pre><code>enum class Fruit : uint8_t
{
 Apple, 
 Pear,
 Banana,
 Strawberry,

 bool IsYellow() { return this == Banana; }
};
</code></pre>
But of course, it doesn't work, because enums can't have methods (and 'this' doesn't mean anything in the above context)
However, if you use the idea of a normal class containing a non-class enum and a single member variable that contains a value of that type, you can get extremely close to the syntax/behavior/type safety that you want. i.e.:
<pre><code>class Fruit
{
public:
 enum Value : uint8_t
 {
 Apple,
 Pear,
 Banana,
 Strawberry
 };

 Fruit() = default;
 constexpr Fruit(Value aFruit) : value(aFruit) { }

#if Enable switch(fruit) use case:
 // Allow switch and comparisons.
 constexpr operator Value() const { return value; }

 // Prevent usage: if(fruit)
 explicit operator bool() = delete; 
#else
 constexpr bool operator==(Fruit a) const { return value == a.value; }
 constexpr bool operator!=(Fruit a) const { return value != a.value; }
#endif

 constexpr bool IsYellow() const { return value == Banana; }

private:
 Value value;
};
</code></pre>
Now you can write:
<pre><code>Fruit f = Fruit::Strawberry;
f.IsYellow();
</code></pre>
And the compiler will prevent things like:
<pre><code>Fruit f = 1; // Compile time error.
</code></pre>
You could easily add methods such that:
<pre><code>Fruit f(&quot;Apple&quot;);
</code></pre>
and
<pre><code>f.ToString();
</code></pre>
can be supported.

blocks|key|165637|text|它可能不能满足您的所有需求，但是使用非成员运算符，您仍然可以获得很多乐趣。例如：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|165638|#include+<iostream>

enum+class+security_level
{
++++none,+low,+medium,+high
};

static+bool+operator!(security_level+s)+{+return+s+==+security_level::none;+}

static+security_level&+operator%2B%2B(security_level&+s)
{
++++switch(s)
++++{
++++++++case+security_level::none:+s+=+security_level::low;+break;
++++++++case+security_level::low:+s+=+security_level::medium;+break;
++++++++case+security_level::medium:+s+=+security_level::high;+break;
++++++++case+security_level::high:+break;
++++}
++++return+s;
}

static+std::ostream+&+operator<<(std::ostream+&o,+security_level+s)
{
++++switch(s)
++++{
++++++++case+security_level::none:+return+o+<<+"none";
++++++++case+security_level::low:+return+o+<<+"low";
++++++++case+security_level::medium:+return+o+<<+"medium";
++++++++case+security_level::high:+return+o+<<+"high";
++++}
}|code-block|syntax|javascript|165639|这允许像这样的代码|165640|security_level+l+=+security_level::none;+++
if(!!l)+{+std::cout+<<+"has+a+security+level:+"+<<+l+<<+std::endl;+}+//+not+reached
%2B%2B%2B%2Bl;
if(!!l)+{+std::cout+<<+"has+a+security+level:+"+<<+l+<<+std::endl;+}+//+reached:+"medium"|165641|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

It may not fulfill all your needs, but with non-member operators you can still have a lot of fun. For example:

<pre><code>#include &lt;iostream&gt;

enum class security_level
{
 none, low, medium, high
};

static bool operator!(security_level s) { return s == security_level::none; }

static security_level&amp; operator++(security_level&amp; s)
{
 switch(s)
 {
 case security_level::none: s = security_level::low; break;
 case security_level::low: s = security_level::medium; break;
 case security_level::medium: s = security_level::high; break;
 case security_level::high: break;
 }
 return s;
}

static std::ostream &amp; operator&lt;&lt;(std::ostream &amp;o, security_level s)
{
 switch(s)
 {
 case security_level::none: return o &lt;&lt; "none";
 case security_level::low: return o &lt;&lt; "low";
 case security_level::medium: return o &lt;&lt; "medium";
 case security_level::high: return o &lt;&lt; "high";
 }
}
</code></pre>

This allows code like

<pre><code>security_level l = security_level::none; 
if(!!l) { std::cout &lt;&lt; "has a security level: " &lt;&lt; l &lt;&lt; std::endl; } // not reached
++++l;
if(!!l) { std::cout &lt;&lt; "has a security level: " &lt;&lt; l &lt;&lt; std::endl; } // reached: "medium"
</code></pre>

I have an enum class with two values, and I want to create a method which receives a value
and returns the other one. I also want to maintain type safety(that's why I use enum class instead of enums).

<a href="http://www.cplusplus.com/doc/tutorial/other_data_types/" rel="noreferrer">http://www.cplusplus.com/doc/tutorial/other_data_types/</a> doesn't mention anything about methods
However, I was under the impression that any type of class can have methods.

Can a C++ enum class have methods?

编译器

我有一个具有两个值的枚举类，我想创建一个接收一个值并返回另一个值的方法。我还想维护类型安全(这就是我使用枚举类而不是枚举的原因)。没有提到任何关于方法的东西，但是，我的印象是任何类型的类都可以有方法。

问C++枚举类可以有方法吗？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C++枚举类可以有方法吗？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C++枚举类可以有方法吗？
EN