blocks|key|1450100|text|如上所述(Kai)或执行以下操作。实际上枚举是“枚举”，您想要做的是拥有一个集合，因此您应该真正使用stl::set|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1450101|enum+AnimalFlags
{
++++HasClaws+=+1,
++++CanFly+=2,
++++EatsFish+=+4,
++++Endangered+=+8
};

int+main(void)
{
++++AnimalFlags+seahawk;
++++//seahawk=+CanFly+%7C+EatsFish+%7C+Endangered;
++++seahawk=+static_cast<AnimalFlags>(CanFly+%7C+EatsFish+%7C+Endangered);
}|code-block|syntax|javascript|1450102|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|$]]

As above(Kai) or do the following. Really enums are "Enumerations", what you want to do is have a set, therefore you should really use stl::set

<pre><code>enum AnimalFlags
{
 HasClaws = 1,
 CanFly =2,
 EatsFish = 4,
 Endangered = 8
};

int main(void)
{
 AnimalFlags seahawk;
 //seahawk= CanFly | EatsFish | Endangered;
 seahawk= static_cast&lt;AnimalFlags&gt;(CanFly | EatsFish | Endangered);
}
</code></pre>

blocks|key|1450140|text|“正确”的方法是为枚举定义位运算符，如下所示：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1450141|enum+AnimalFlags
{
++++HasClaws+++=+1,
++++CanFly+++++=+2,
++++EatsFish+++=+4,
++++Endangered+=+8
};

inline+AnimalFlags+operator%7C(AnimalFlags+a,+AnimalFlags+b)
{
++++return+static_cast<AnimalFlags>(static_cast<int>(a)+%7C+static_cast<int>(b));
}|code-block|syntax|javascript|1450142|等。其余的位运算符。如果枚举范围超过int范围，请根据需要进行修改。|1450143|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

The "correct" way is to define bit operators for the enum, as:

<pre><code>enum AnimalFlags
{
 HasClaws = 1,
 CanFly = 2,
 EatsFish = 4,
 Endangered = 8
};

inline AnimalFlags operator|(AnimalFlags a, AnimalFlags b)
{
 return static_cast&lt;AnimalFlags&gt;(static_cast&lt;int&gt;(a) | static_cast&lt;int&gt;(b));
}
</code></pre>

Etc. rest of the bit operators. Modify as needed if the enum range exceeds int range.

blocks|key|1450216|text|最简单的方法是使用标准库类bitset，如here所示。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1450217|要以类型安全的方式模拟C#特性，必须在位集周围编写一个模板包装器，将int参数替换为作为模板的类型参数给定的枚举。类似于：|1450218|++++template+<class+T,+int+N>
class+FlagSet
{

++++bitset<N>+bits;

++++FlagSet(T+enumVal)
++++{
++++++++bits.set(enumVal);
++++}

++++//+etc.
};

enum+MyFlags
{
++++FLAG_ONE,
++++FLAG_TWO
};

FlagSet<MyFlags,+2>+myFlag;|code-block|syntax|javascript|1450219|entityMap|0|LINK|mutability|MUTABLE|url|http://www.cppreference.com/wiki/stl/bitset/start|1|http://www.java2s.com/Tutorial/Cpp/0360__bitset/Usebitsetwithenumtogether.htm^0|D|6|0|L|4|1|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]|$A|Y|B|Z|1|10]]|C|$]]|$1|D|3|E|5|6|7|11|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|12|8|@]|9|@]|C|$I|J]]|$1|K|3|-4|5|6|7|13|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]|S|$5|N|O|P|C|$Q|T]]]]

Easiest way to do this as shown <a href="http://www.java2s.com/Tutorial/Cpp/0360__bitset/Usebitsetwithenumtogether.htm" rel="noreferrer">here</a>, using the standard library class <a href="http://www.cppreference.com/wiki/stl/bitset/start" rel="noreferrer">bitset</a>.

To emulate the C# feature in a type-safe way, you'd have to write a template wrapper around the bitset, replacing the int arguments with an enum given as a type parameter to the template. Something like:

<pre><code> template &lt;class T, int N&gt;
class FlagSet
{

 bitset&lt;N&gt; bits;

 FlagSet(T enumVal)
 {
 bits.set(enumVal);
 }

 // etc.
};

enum MyFlags
{
 FLAG_ONE,
 FLAG_TWO
};

FlagSet&lt;MyFlags, 2&gt; myFlag;
</code></pre>

blocks|key|1450285|text|注意(也有点离题)：另一种制作唯一标志的方法是使用位移位。我，我自己，发现这更容易阅读。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1450286|enum+Flags
{
++++A+=+1+<<+0,+//+binary+0001
++++B+=+1+<<+1,+//+binary+0010
++++C+=+1+<<+2,+//+binary+0100
++++D+=+1+<<+3++//+binary+1000
};|code-block|syntax|javascript|1450287|它可以将值保存到int，因此，在大多数情况下，32个标志可以清楚地反映在移位量中。|1450288|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Note (also a bit off topic): Another way to make unique flags can be done using a bit shift. I, myself, find this easier to read.
<pre><code>enum Flags
{
 A = 1 &lt;&lt; 0, // binary 0001
 B = 1 &lt;&lt; 1, // binary 0010
 C = 1 &lt;&lt; 2, // binary 0100
 D = 1 &lt;&lt; 3 // binary 1000
};
</code></pre>
It can hold values up to an int so that is, most of the time, 32 flags which is clearly reflected in the shift amount.

blocks|key|1450346|text|注意:如果你在Windows环境中工作，在winnt.h中定义了一个DEFINE_ENUM_FLAG_OPERATORS宏，它会为你完成这项工作。因此，在这种情况下，您可以这样做：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1450347|enum+AnimalFlags
{
++++HasClaws+=+1,
++++CanFly+=2,
++++EatsFish+=+4,
++++Endangered+=+8
};
DEFINE_ENUM_FLAG_OPERATORS(AnimalFlags)

seahawk.flags+=+CanFly+%7C+EatsFish+%7C+Endangered;|code-block|syntax|javascript|1450348|entityMap^0|Y|Q|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

Note if you are working in Windows environment, there is a <code>DEFINE_ENUM_FLAG_OPERATORS</code> macro defined in winnt.h that does the job for you. So in this case, you can do this:

<pre><code>enum AnimalFlags
{
 HasClaws = 1,
 CanFly =2,
 EatsFish = 4,
 Endangered = 8
};
DEFINE_ENUM_FLAG_OPERATORS(AnimalFlags)

seahawk.flags = CanFly | EatsFish | Endangered;
</code></pre>

blocks|key|1450385|text|对于像我这样的懒人，这里有一个模板化的解决方案来复制和粘贴：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1450386|template<class+T>+inline+T+operator~+(T+a)+{+return+(T)~(int)a;+}
template<class+T>+inline+T+operator%7C+(T+a,+T+b)+{+return+(T)((int)a+%7C+(int)b);+}
template<class+T>+inline+T+operator&+(T+a,+T+b)+{+return+(T)((int)a+&+(int)b);+}
template<class+T>+inline+T+operator%5E+(T+a,+T+b)+{+return+(T)((int)a+%5E+(int)b);+}
template<class+T>+inline+T&+operator%7C=+(T&+a,+T+b)+{+return+(T&)((int&)a+%7C=+(int)b);+}
template<class+T>+inline+T&+operator&=+(T&+a,+T+b)+{+return+(T&)((int&)a+&=+(int)b);+}
template<class+T>+inline+T&+operator%5E=+(T&+a,+T+b)+{+return+(T&)((int&)a+%5E=+(int)b);+}|code-block|syntax|javascript|1450387|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|$]]

For lazy people like me, here is templated solution to copy&amp;paste:

<pre><code>template&lt;class T&gt; inline T operator~ (T a) { return (T)~(int)a; }
template&lt;class T&gt; inline T operator| (T a, T b) { return (T)((int)a | (int)b); }
template&lt;class T&gt; inline T operator&amp; (T a, T b) { return (T)((int)a &amp; (int)b); }
template&lt;class T&gt; inline T operator^ (T a, T b) { return (T)((int)a ^ (int)b); }
template&lt;class T&gt; inline T&amp; operator|= (T&amp; a, T b) { return (T&amp;)((int&amp;)a |= (int)b); }
template&lt;class T&gt; inline T&amp; operator&amp;= (T&amp; a, T b) { return (T&amp;)((int&amp;)a &amp;= (int)b); }
template&lt;class T&gt; inline T&amp; operator^= (T&amp; a, T b) { return (T&amp;)((int&amp;)a ^= (int)b); }
</code></pre>

blocks|key|1450450|text|您混淆了对象和对象集合。具体地说，您会混淆二进制标志和二进制标志集。正确的解决方案应该如下所示：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1450451|//+These+are+individual+flags
enum+AnimalFlag+//+Flag,+not+Flags
{
++++HasClaws+=+0,
++++CanFly,
++++EatsFish,
++++Endangered
};

class+AnimalFlagSet
{
++++int+m_Flags;

++public:

++++AnimalFlagSet()+:+m_Flags(0)+{+}

++++void+Set(+AnimalFlag+flag+)+{+m_Flags+%7C=+(1+<<+flag);+}

++++void+Clear(+AnimalFlag+flag+)+{+m_Flags+&=+~+(1+<<+flag);+}

++++bool+Get(+AnimalFlag+flag+)+const+{+return+(m_Flags+>>+flag)+&+1;+}

};|code-block|syntax|javascript|1450452|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|$]]

You are confusing objects and collections of objects. Specifically, you are confusing binary flags with sets of binary flags. A proper solution would look like this:

<pre><code>// These are individual flags
enum AnimalFlag // Flag, not Flags
{
 HasClaws = 0,
 CanFly,
 EatsFish,
 Endangered
};

class AnimalFlagSet
{
 int m_Flags;

 public:

 AnimalFlagSet() : m_Flags(0) { }

 void Set( AnimalFlag flag ) { m_Flags |= (1 &lt;&lt; flag); }

 void Clear( AnimalFlag flag ) { m_Flags &amp;= ~ (1 &lt;&lt; flag); }

 bool Get( AnimalFlag flag ) const { return (m_Flags &gt;&gt; flag) &amp; 1; }

};
</code></pre>

blocks|key|1450498|text|我发现自己在问同样的问题，并想出了一个基于C%2B%2B11的通用解决方案，类似于索鲁的解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1450499|template+<typename+TENUM>
class+FlagSet+{

private:
++++using+TUNDER+=+typename+std::underlying_type<TENUM>::type;
++++std::bitset<std::numeric_limits<TUNDER>::max()>+m_flags;

public:
++++FlagSet()+=+default;

++++template+<typename...+ARGS>
++++FlagSet(TENUM+f,+ARGS...+args)+:+FlagSet(args...)
++++{+++
++++++++set(f);
++++}+++
++++FlagSet&+set(TENUM+f)
++++{+++
++++++++m_flags.set(static_cast<TUNDER>(f));
++++++++return+*this;
++++}+++
++++bool+test(TENUM+f)
++++{+++
++++++++return+m_flags.test(static_cast<TUNDER>(f));
++++}+++
++++FlagSet&+operator%7C=(TENUM+f)
++++{+++
++++++++return+set(f);
++++}+++
};|code-block|syntax|javascript|1450500|界面可以改进以满足用户的口味。然后可以像这样使用它：|1450501|FlagSet<Flags>+flags{Flags::FLAG_A,+Flags::FLAG_C};
flags+%7C=+Flags::FLAG_D;|1450502|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|$]]

I found myself asking the same question and came up with a generic C++11 based solution, similar to soru's:

<pre><code>template &lt;typename TENUM&gt;
class FlagSet {

private:
 using TUNDER = typename std::underlying_type&lt;TENUM&gt;::type;
 std::bitset&lt;std::numeric_limits&lt;TUNDER&gt;::max()&gt; m_flags;

public:
 FlagSet() = default;

 template &lt;typename... ARGS&gt;
 FlagSet(TENUM f, ARGS... args) : FlagSet(args...)
 { 
 set(f);
 } 
 FlagSet&amp; set(TENUM f)
 { 
 m_flags.set(static_cast&lt;TUNDER&gt;(f));
 return *this;
 } 
 bool test(TENUM f)
 { 
 return m_flags.test(static_cast&lt;TUNDER&gt;(f));
 } 
 FlagSet&amp; operator|=(TENUM f)
 { 
 return set(f);
 } 
};
</code></pre>

The interface can be improved to taste. Then it can be used like so:

<pre><code>FlagSet&lt;Flags&gt; flags{Flags::FLAG_A, Flags::FLAG_C};
flags |= Flags::FLAG_D;
</code></pre>

blocks|key|1235789|text|C%2B%2B标准明确规定了这一点，请参阅"17.5.2.1.3位掩码类型“小节：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1235790|http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3485.pdf|offset|length|1235791|给出这个“模板”，你会得到：|1235792|enum+AnimalFlags+:+unsigned+int
{
++++HasClaws+=+1,
++++CanFly+=+2,
++++EatsFish+=+4,
++++Endangered+=+8
};

constexpr+AnimalFlags+operator%7C(AnimalFlags+X,+AnimalFlags+Y)+{
++++return+static_cast<AnimalFlags>(
++++++++static_cast<unsigned+int>(X)+%7C+static_cast<unsigned+int>(Y));
}

AnimalFlags&+operator%7C=(AnimalFlags&+X,+AnimalFlags+Y)+{
++++X+=+X+%7C+Y;+return+X;
}|code-block|syntax|javascript|1235793|对于其他运算符也是类似的。还要注意"constexpr"，如果您希望编译器能够在编译时执行运算符，则需要使用它。|1235794|如果你使用的是C%2B%2B/CLI，并且想要赋值给ref类的枚举成员，你需要改用跟踪引用：|1235795|AnimalFlags%25+operator%7C=(AnimalFlags%25+X,+AnimalFlags+Y)+{
++++X+=+X+%7C+Y;+return+X;
}|1235796|注意:此示例不完整，请参阅"17.5.2.1.3位掩码类型“小节以获取完整的运算符集。|1235797|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|1T|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|12|8|@]|9|@$D|13|E|14|1|15]]|A|$]]|$1|F|3|G|5|6|7|16|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|17|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|18|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|19|8|@]|9|@]|A|$]]|$1|Q|3|R|5|J|7|1A|8|@]|9|@]|A|$K|L]]|$1|S|3|T|5|6|7|1B|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|1C|8|@]|9|@]|A|$]]]|V|$W|$5|X|Y|Z|A|$10|C]]]]

The C++ standard explicitly talks about this, see section "17.5.2.1.3 Bitmask types":

<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3485.pdf" rel="noreferrer">http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3485.pdf</a>

Given this "template" you get:

<pre><code>enum AnimalFlags : unsigned int
{
 HasClaws = 1,
 CanFly = 2,
 EatsFish = 4,
 Endangered = 8
};

constexpr AnimalFlags operator|(AnimalFlags X, AnimalFlags Y) {
 return static_cast&lt;AnimalFlags&gt;(
 static_cast&lt;unsigned int&gt;(X) | static_cast&lt;unsigned int&gt;(Y));
}

AnimalFlags&amp; operator|=(AnimalFlags&amp; X, AnimalFlags Y) {
 X = X | Y; return X;
}
</code></pre>

And similar for the other operators.
Also note the "constexpr", it is needed if you want the compiler to be able to execute the operators compile time.

If you are using C++/CLI and want to able assign to enum members of ref classes you need to use tracking references instead:

<pre><code>AnimalFlags% operator|=(AnimalFlags% X, AnimalFlags Y) {
 X = X | Y; return X;
}
</code></pre>

NOTE: This sample is not complete, see section "17.5.2.1.3 Bitmask types" for a complete set of operators.

blocks|key|1235885|text|我想详细介绍一下Uliwitness+answer，他修复了C%2B%2B98的代码并使用了Safe+Bool+idiom，因为在C%2B%2B11以下的C%2B%2B版本中缺少std::underlying_type<>模板和explicit关键字。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1235886|我还对它进行了修改，以便枚举值可以是连续的，而不需要任何显式赋值，因此您可以|1235887|enum+AnimalFlags_
{
++++HasClaws,
++++CanFly,
++++EatsFish,
++++Endangered
};
typedef+FlagsEnum<AnimalFlags_>+AnimalFlags;

seahawk.flags+=+AnimalFlags()+%7C+CanFly+%7C+EatsFish+%7C+Endangered;|code-block|syntax|javascript|1235888|然后，您可以使用以下命令获取原始标志值|1235889|seahawk.flags.value();|1235890|这是代码。|1235891|template+<typename+EnumType,+typename+Underlying+=+int>
class+FlagsEnum
{
++++typedef+Underlying+FlagsEnum::*+RestrictedBool;

public:
++++FlagsEnum()+:+m_flags(Underlying())+{}

++++FlagsEnum(EnumType+singleFlag):
++++++++m_flags(1+<<+singleFlag)
++++{}

++++FlagsEnum(const+FlagsEnum&+original):
++++++++m_flags(original.m_flags)
++++{}

++++FlagsEnum&+operator+%7C=(const+FlagsEnum&+f)+{
++++++++m_flags+%7C=+f.m_flags;
++++++++return+*this;
++++}

++++FlagsEnum&+operator+&=(const+FlagsEnum&+f)+{
++++++++m_flags+&=+f.m_flags;
++++++++return+*this;
++++}

++++friend+FlagsEnum+operator+%7C(const+FlagsEnum&+f1,+const+FlagsEnum&+f2)+{
++++++++return+FlagsEnum(f1)+%7C=+f2;
++++}

++++friend+FlagsEnum+operator+&(const+FlagsEnum&+f1,+const+FlagsEnum&+f2)+{
++++++++return+FlagsEnum(f1)+&=+f2;
++++}

++++FlagsEnum+operator+~()+const+{
++++++++FlagsEnum+result(*this);
++++++++result.m_flags+=+~result.m_flags;
++++++++return+result;
++++}

++++operator+RestrictedBool()+const+{
++++++++return+m_flags+?+&FlagsEnum::m_flags+:+0;
++++}

++++Underlying+value()+const+{
++++++++return+m_flags;
++++}

protected:
++++Underlying++m_flags;
};|1235892|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/33971769/566849|1|https://en.wikibooks.org/wiki/More_C%252B%252B_Idioms/Safe_bool^0|25|M|2U|8|8|H|0|16|F|1|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@$9|15|A|16|B|C]|$9|17|A|18|B|C]]|D|@$9|19|A|1A|1|1B]|$9|1C|A|1D|1|1E]]|E|$]]|$1|F|3|G|5|6|7|1F|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|1G|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1H|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|1I|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|1J|8|@]|D|@]|E|$]]|$1|S|3|T|5|J|7|1K|8|@]|D|@]|E|$K|L]]|$1|U|3|-4|5|6|7|1L|8|@]|D|@]|E|$]]]|V|$W|$5|X|Y|Z|E|$10|11]]|12|$5|X|Y|Z|E|$10|13]]]]

I'd like to elaborate on <a href="https://stackoverflow.com/a/33971769/566849">Uliwitness answer</a>, fixing his code for C++98 and using the <a href="https://en.wikibooks.org/wiki/More_C%2B%2B_Idioms/Safe_bool" rel="nofollow noreferrer">Safe Bool idiom</a>, for lack of the <code>std::underlying_type&lt;&gt;</code> template and the <code>explicit</code> keyword in C++ versions below C++11.

I also modified it so that the enum values can be sequential without any explicit assignment, so you can have

<pre><code>enum AnimalFlags_
{
 HasClaws,
 CanFly,
 EatsFish,
 Endangered
};
typedef FlagsEnum&lt;AnimalFlags_&gt; AnimalFlags;

seahawk.flags = AnimalFlags() | CanFly | EatsFish | Endangered;
</code></pre>

You can then get the raw flags value with

<pre><code>seahawk.flags.value();
</code></pre>

Here's the code.

<pre><code>template &lt;typename EnumType, typename Underlying = int&gt;
class FlagsEnum
{
 typedef Underlying FlagsEnum::* RestrictedBool;

public:
 FlagsEnum() : m_flags(Underlying()) {}

 FlagsEnum(EnumType singleFlag):
 m_flags(1 &lt;&lt; singleFlag)
 {}

 FlagsEnum(const FlagsEnum&amp; original):
 m_flags(original.m_flags)
 {}

 FlagsEnum&amp; operator |=(const FlagsEnum&amp; f) {
 m_flags |= f.m_flags;
 return *this;
 }

 FlagsEnum&amp; operator &amp;=(const FlagsEnum&amp; f) {
 m_flags &amp;= f.m_flags;
 return *this;
 }

 friend FlagsEnum operator |(const FlagsEnum&amp; f1, const FlagsEnum&amp; f2) {
 return FlagsEnum(f1) |= f2;
 }

 friend FlagsEnum operator &amp;(const FlagsEnum&amp; f1, const FlagsEnum&amp; f2) {
 return FlagsEnum(f1) &amp;= f2;
 }

 FlagsEnum operator ~() const {
 FlagsEnum result(*this);
 result.m_flags = ~result.m_flags;
 return result;
 }

 operator RestrictedBool() const {
 return m_flags ? &amp;FlagsEnum::m_flags : 0;
 }

 Underlying value() const {
 return m_flags;
 }

protected:
 Underlying m_flags;
};
</code></pre>

blocks|key|1450679|text|只有句法上的糖。没有额外的元数据。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1450680|namespace+UserRole+//+grupy
{+
++++constexpr+uint8_t+dea+=+1;
++++constexpr+uint8_t+red+=+2;
++++constexpr+uint8_t+stu+=+4;
++++constexpr+uint8_t+kie+=+8;
++++constexpr+uint8_t+adm+=+16;
++++constexpr+uint8_t+mas+=+32;
}|code-block|syntax|javascript|1450681|整型上的标志运算符是有效的。|1450682|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Only syntactic sugar. No additional metadata. 

<pre><code>namespace UserRole // grupy
{ 
 constexpr uint8_t dea = 1;
 constexpr uint8_t red = 2;
 constexpr uint8_t stu = 4;
 constexpr uint8_t kie = 8;
 constexpr uint8_t adm = 16;
 constexpr uint8_t mas = 32;
}
</code></pre>

Flag operators on integral type just works.

blocks|key|1450724|text|也许就像Objective-C的NS_OPTIONS一样。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1450725|#define+ENUM(T1,+T2)+\
enum+class+T1+:+T2;+\
inline+T1+operator~+(T1+a)+{+return+(T1)~(int)a;+}+\
inline+T1+operator%7C+(T1+a,+T1+b)+{+return+static_cast<T1>((static_cast<T2>(a)+%7C+static_cast<T2>(b)));+}+\
inline+T1+operator&+(T1+a,+T1+b)+{+return+static_cast<T1>((static_cast<T2>(a)+&+static_cast<T2>(b)));+}+\
inline+T1+operator%5E+(T1+a,+T1+b)+{+return+static_cast<T1>((static_cast<T2>(a)+%5E+static_cast<T2>(b)));+}+\
inline+T1&+operator%7C=+(T1&+a,+T1+b)+{+return+reinterpret_cast<T1&>((reinterpret_cast<T2&>(a)+%7C=+static_cast<T2>(b)));+}+\
inline+T1&+operator&=+(T1&+a,+T1+b)+{+return+reinterpret_cast<T1&>((reinterpret_cast<T2&>(a)+&=+static_cast<T2>(b)));+}+\
inline+T1&+operator%5E=+(T1&+a,+T1+b)+{+return+reinterpret_cast<T1&>((reinterpret_cast<T2&>(a)+%5E=+static_cast<T2>(b)));+}+\
enum+class+T1+:+T2

ENUM(Options,+short)+{
++++FIRST++=+1+<<+0,
++++SECOND+=+1+<<+1,
++++THIRD++=+1+<<+2,
++++FOURTH+=+1+<<+3
};

auto+options+=+Options::FIRST+%7C+Options::SECOND;
options+%7C=+Options::THIRD;
if+((options+&+Options::SECOND)+==+Options::SECOND)
++++cout+<<+"Contains+second+option."+<<+endl;
if+((options+&+Options::THIRD)+==+Options::THIRD)
++++cout+<<+"Contains+third+option."+<<+endl;
return+0;

//+Output:
//+Contains+second+option.+
//+Contains+third+option.|code-block|syntax|javascript|1450726|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|$]]

Maybe like NS_OPTIONS of Objective-C.

<pre><code>#define ENUM(T1, T2) \
enum class T1 : T2; \
inline T1 operator~ (T1 a) { return (T1)~(int)a; } \
inline T1 operator| (T1 a, T1 b) { return static_cast&lt;T1&gt;((static_cast&lt;T2&gt;(a) | static_cast&lt;T2&gt;(b))); } \
inline T1 operator&amp; (T1 a, T1 b) { return static_cast&lt;T1&gt;((static_cast&lt;T2&gt;(a) &amp; static_cast&lt;T2&gt;(b))); } \
inline T1 operator^ (T1 a, T1 b) { return static_cast&lt;T1&gt;((static_cast&lt;T2&gt;(a) ^ static_cast&lt;T2&gt;(b))); } \
inline T1&amp; operator|= (T1&amp; a, T1 b) { return reinterpret_cast&lt;T1&amp;&gt;((reinterpret_cast&lt;T2&amp;&gt;(a) |= static_cast&lt;T2&gt;(b))); } \
inline T1&amp; operator&amp;= (T1&amp; a, T1 b) { return reinterpret_cast&lt;T1&amp;&gt;((reinterpret_cast&lt;T2&amp;&gt;(a) &amp;= static_cast&lt;T2&gt;(b))); } \
inline T1&amp; operator^= (T1&amp; a, T1 b) { return reinterpret_cast&lt;T1&amp;&gt;((reinterpret_cast&lt;T2&amp;&gt;(a) ^= static_cast&lt;T2&gt;(b))); } \
enum class T1 : T2

ENUM(Options, short) {
 FIRST = 1 &lt;&lt; 0,
 SECOND = 1 &lt;&lt; 1,
 THIRD = 1 &lt;&lt; 2,
 FOURTH = 1 &lt;&lt; 3
};

auto options = Options::FIRST | Options::SECOND;
options |= Options::THIRD;
if ((options &amp; Options::SECOND) == Options::SECOND)
 cout &lt;&lt; "Contains second option." &lt;&lt; endl;
if ((options &amp; Options::THIRD) == Options::THIRD)
 cout &lt;&lt; "Contains third option." &lt;&lt; endl;
return 0;

// Output:
// Contains second option. 
// Contains third option.
</code></pre>

blocks|key|1236010|text|@Xaqq提供了一种非常好的类型安全方法，可以通过flag_set类使用枚举标志here。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1236011|我用GitHub发布了代码，用法如下：|1236012|#include+"flag_set.hpp"

enum+class+AnimalFlags+:+uint8_t+{
++++HAS_CLAWS,
++++CAN_FLY,
++++EATS_FISH,
++++ENDANGERED,
++++_
};

int+main()
{
++++flag_set<AnimalFlags>+seahawkFlags(AnimalFlags::HAS_CLAWS
+++++++++++++++++++++++++++++++++++++++%7C+AnimalFlags::EATS_FISH
+++++++++++++++++++++++++++++++++++++++%7C+AnimalFlags::ENDANGERED);

++++if+(seahawkFlags+&+AnimalFlags::ENDANGERED)
++++++++cout+<<+"Seahawk+is+endangered";
}|code-block|syntax|javascript|1236013|entityMap|0|LINK|mutability|MUTABLE|url|https://codereview.stackexchange.com/questions/96146/c-flagset-typesafe-usage-of-enumeration-as-bitset-bitmask|1|https://github.com/mrts/flag-set-cpp^0|P|8|14|4|0|0|2|6|1|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@$9|Z|A|10|1|11]]|E|$]]|$1|F|3|G|5|6|7|12|8|@]|D|@$9|13|A|14|1|15]]|E|$]]|$1|H|3|I|5|J|7|16|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|17|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]|U|$5|P|Q|R|E|$S|V]]]]

@Xaqq has provided a really nice type-safe way to use enum flags <a href="https://codereview.stackexchange.com/questions/96146/c-flagset-typesafe-usage-of-enumeration-as-bitset-bitmask">here</a> by a <code>flag_set</code> class.

I published the code in <a href="https://github.com/mrts/flag-set-cpp" rel="nofollow noreferrer">GitHub</a>, usage is as follows:

<pre class="lang-cpp prettyprint-override"><code>#include "flag_set.hpp"

enum class AnimalFlags : uint8_t {
 HAS_CLAWS,
 CAN_FLY,
 EATS_FISH,
 ENDANGERED,
 _
};

int main()
{
 flag_set&lt;AnimalFlags&gt; seahawkFlags(AnimalFlags::HAS_CLAWS
 | AnimalFlags::EATS_FISH
 | AnimalFlags::ENDANGERED);

 if (seahawkFlags &amp; AnimalFlags::ENDANGERED)
 cout &lt;&lt; "Seahawk is endangered";
}
</code></pre>

blocks|key|1236074|text|您可以按如下方式使用struct：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1236075|struct+UiFlags2+{
++++static+const+int
++++FULLSCREEN+=+0x00000004,+++++++++++++++//api+16
++++HIDE_NAVIGATION+=+0x00000002,++++++++++//api+14
++++LAYOUT_HIDE_NAVIGATION+=+0x00000200,+++//api+16
++++LAYOUT_FULLSCREEN+=+0x00000400,++++++++//api+16
++++LAYOUT_STABLE+=+0x00000100,++++++++++++//api+16
++++IMMERSIVE_STICKY+=+0x00001000;+++++++++//api+19
};|code-block|syntax|javascript|1236076|并按如下方式使用：|1236077|int+flags+=+UiFlags2::FULLSCREEN+%7C+UiFlags2::HIDE_NAVIGATION;|1236078|所以你不需要int类型转换，它是直接可用的。|offset|length|style|CODE|1236079|而且，它像enum+class一样是作用域分离的|1236080|entityMap^0|0|0|0|0|6|3|0|5|A|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|Y|8|@$M|Z|N|10|O|P]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|11|8|@$M|12|N|13|O|P]]|9|@]|A|$]]|$1|S|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|T|$]]

You can use struct as follow:
<pre><code>struct UiFlags2 {
 static const int
 FULLSCREEN = 0x00000004, //api 16
 HIDE_NAVIGATION = 0x00000002, //api 14
 LAYOUT_HIDE_NAVIGATION = 0x00000200, //api 16
 LAYOUT_FULLSCREEN = 0x00000400, //api 16
 LAYOUT_STABLE = 0x00000100, //api 16
 IMMERSIVE_STICKY = 0x00001000; //api 19
};
</code></pre>
and use as this:
<pre><code>int flags = UiFlags2::FULLSCREEN | UiFlags2::HIDE_NAVIGATION;
</code></pre>
So you don't need to <code>int</code> casting and it is directly usable. 
Also it is scope separated like <code>enum class</code>

Treating <code>enum</code>s as flags works nicely in C# via the <code>[Flags]</code> attribute, but what's the best way to do this in C++?

For example, I'd like to write:

<pre><code>enum AnimalFlags
{
 HasClaws = 1,
 CanFly =2,
 EatsFish = 4,
 Endangered = 8
};

seahawk.flags = CanFly | EatsFish | Endangered;
</code></pre>

However, I get compiler errors regarding <code>int</code>/<code>enum</code> conversions. Is there a nicer way to express this than just blunt casting? Preferably, I don't want to rely on constructs from 3rd party libraries such as boost or Qt.

EDIT: As indicated in the answers, I can avoid the compiler error by declaring <code>seahawk.flags</code> as <code>int</code>. However, I'd like to have some mechanism to enforce type safety, so someone can't write <code>seahawk.flags = HasMaximizeButton</code>.

How to use enums as flags in C++?

Objective-C

编译器

Windows

通过[Flags]属性将enum作为标志在C#中工作得很好，但是在C++中做这件事的最佳方法是什么呢？例如，我想这样写：enum AnimalFlags{    HasClaws = 1,    CanFly =2,    EatsFish = 4,    Endangered = 8};seahawk.flags =...

问如何在C++中使用枚举作为标志？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在C++中使用枚举作为标志？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在C++中使用枚举作为标志？
EN