sをフラグとして扱うことenumは、属性を介してC＃でうまく機能し[Flags]ますが、C ++でこれを行うための最良の方法は何ですか？
たとえば、私は次のように書きたいと思います。
enum AnimalFlags
{
HasClaws = 1,
CanFly =2,
EatsFish = 4,
Endangered = 8
};
seahawk.flags = CanFly | EatsFish | Endangered;
intただし、 /enum変換に関してコンパイラエラーが発生します。鈍いキャストよりもこれを表現するためのより良い方法はありますか？できれば、boostやQtなどのサードパーティライブラリの構成に依存したくありません。
seahawk.flags編集：回答に示されているように、として宣言することでコンパイラエラーを回避できますint。しかし、型安全性を強制するためのメカニズムが欲しいので、誰かが書くことはできませんseahawk.flags = HasMaximizeButton。
「正しい」方法は、列挙型のビット演算子を次のように定義することです。
enum AnimalFlags
{
HasClaws = 1,
CanFly = 2,
EatsFish = 4,
Endangered = 8
};
inline AnimalFlags operator|(AnimalFlags a, AnimalFlags b)
{
return static_cast<AnimalFlags>(static_cast<int>(a) | static_cast<int>(b));
}
残りのビット演算子など。enum範囲がint範囲を超える場合は、必要に応じて変更します。
注（これも少し話題から外れています）：一意のフラグを作成する別の方法は、ビットシフトを使用して実行できます。私自身、これは読みやすいと思います。
enum Flags
{
A = 1 << 0, // binary 0001
B = 1 << 1, // binary 0010
C = 1 << 2, // binary 0100
D = 1 << 3 // binary 1000
};
intまでの値を保持できるため、ほとんどの場合、シフト量に明確に反映される32個のフラグです。
Windows環境で作業している場合はDEFINE_ENUM_FLAG_OPERATORS、winnt.hで定義されたマクロが自動的に機能することに注意してください。したがって、この場合、これを行うことができます：
enum AnimalFlags
{
HasClaws = 1,
CanFly =2,
EatsFish = 4,
Endangered = 8
};
DEFINE_ENUM_FLAG_OPERATORS(AnimalFlags)
seahawk.flags = CanFly | EatsFish | Endangered;
私のような怠惰な人々のために、ここにコピー＆ペーストするためのテンプレート化されたソリューションがあります：
template<class T> inline T operator~ (T a) { return (T)~(int)a; }
template<class T> inline T operator| (T a, T b) { return (T)((int)a | (int)b); }
template<class T> inline T operator& (T a, T b) { return (T)((int)a & (int)b); }
template<class T> inline T operator^ (T a, T b) { return (T)((int)a ^ (int)b); }
template<class T> inline T& operator|= (T& a, T b) { return (T&)((int&)a |= (int)b); }
template<class T> inline T& operator&= (T& a, T b) { return (T&)((int&)a &= (int)b); }
template<class T> inline T& operator^= (T& a, T b) { return (T&)((int&)a ^= (int)b); }
seahawk.flags変数はどのタイプですか？
標準のC++では、列挙はタイプセーフではありません。それらは事実上整数です。
AnimalFlagsは変数のタイプであってはなりません。変数はintである必要があり、エラーはなくなります。
他の人が提案したように16進値を入れる必要はありません。違いはありません。
列挙値はデフォルトでint型です。したがって、確実にビット単位で組み合わせるか、それらを組み合わせて組み合わせ、結果をintに格納することができます。
enum型は、intの制限されたサブセットであり、その値は列挙値の1つです。したがって、その範囲外の新しい値を作成する場合、列挙型の変数にキャストせずにその値を割り当てることはできません。
必要に応じて列挙値の型を変更することもできますが、この質問には意味がありません。
編集：ポスターは、型の安全性に関心があり、int型内に存在してはならない値を望んでいないと述べました。
ただし、AnimalFlags型の変数内にAnimalFlagsの範囲外の値を配置することは、型上安全ではありません。
int型の内部でも、範囲外の値をチェックする安全な方法があります...
int iFlags = HasClaws | CanFly;
//InvalidAnimalFlagMaxValue-1 gives you a value of all the bits
// smaller than itself set to 1
//This check makes sure that no other bits are set.
assert(iFlags & ~(InvalidAnimalFlagMaxValue-1) == 0);
enum AnimalFlags {
HasClaws = 1,
CanFly =2,
EatsFish = 4,
Endangered = 8,
// put new enum values above here
InvalidAnimalFlagMaxValue = 16
};
上記は、値が1、2、4、または8の別の列挙型から無効なフラグを設定することを妨げるものではありません。
絶対的な型の安全性が必要な場合は、std :: setを作成し、その中に各フラグを格納するだけです。スペース効率は良くありませんが、タイプセーフであり、bitflagintと同じ機能を提供します。
C ++ 0x注：強く型付けされた列挙型
C ++ 0xでは、最終的にタイプセーフな列挙値を使用できます。
enum class AnimalFlags {
CanFly = 2,
HasClaws = 4
};
if(CanFly == 2) { }//Compiling error
現在受け入れられているエイドロンの答えは危険すぎると思います。コンパイラのオプティマイザは、列挙型で可能な値について想定を行う可能性があり、無効な値でガベージが返される可能性があります。そして通常、フラグ列挙型で可能なすべての順列を定義することは誰も望んでいません。
Brian R. Bondyが以下に述べているように、C ++ 11を使用している場合（誰もがそうすべきですが、それはとても良いことです）、これをより簡単に行うことができますenum class。
enum class ObjectType : uint32_t
{
ANIMAL = (1 << 0),
VEGETABLE = (1 << 1),
MINERAL = (1 << 2)
};
constexpr enum ObjectType operator |( const enum ObjectType selfValue, const enum ObjectType inValue )
{
return (enum ObjectType)(uint32_t(selfValue) | uint32_t(inValue));
}
// ... add more operators here.
enum classこれにより、列挙型の型を指定して安定したサイズと値の範囲を確保し、を使用して列挙型からintなどへの自動ダウンキャストを禁止しconstexpr、演算子のコードがインライン化され、通常の数値と同じ速さになるように使用します。
11より前のC++方言で立ち往生している人々のために
C ++ 11をサポートしないコンパイラで立ち往生している場合は、クラスでint型をラップして、ビット単位の演算子とその列挙型の型のみを使用して値を設定できるようにします。
template<class ENUM,class UNDERLYING=typename std::underlying_type<ENUM>::type>
class SafeEnum
{
public:
SafeEnum() : mFlags(0) {}
SafeEnum( ENUM singleFlag ) : mFlags(singleFlag) {}
SafeEnum( const SafeEnum& original ) : mFlags(original.mFlags) {}
SafeEnum& operator |=( ENUM addValue ) { mFlags |= addValue; return *this; }
SafeEnum operator |( ENUM addValue ) { SafeEnum result(*this); result |= addValue; return result; }
SafeEnum& operator &=( ENUM maskValue ) { mFlags &= maskValue; return *this; }
SafeEnum operator &( ENUM maskValue ) { SafeEnum result(*this); result &= maskValue; return result; }
SafeEnum operator ~() { SafeEnum result(*this); result.mFlags = ~result.mFlags; return result; }
explicit operator bool() { return mFlags != 0; }
protected:
UNDERLYING mFlags;
};
これは、通常の列挙型+typedefとほとんど同じように定義できます。
enum TFlags_
{
EFlagsNone = 0,
EFlagOne = (1 << 0),
EFlagTwo = (1 << 1),
EFlagThree = (1 << 2),
EFlagFour = (1 << 3)
};
typedef SafeEnum<enum TFlags_> TFlags;
また、使用法も同様です。
TFlags myFlags;
myFlags |= EFlagTwo;
myFlags |= EFlagThree;
if( myFlags & EFlagTwo )
std::cout << "flag 2 is set" << std::endl;
if( (myFlags & EFlagFour) == EFlagsNone )
std::cout << "flag 4 is not set" << std::endl;
enum foo : typeまた、2番目のテンプレートパラメータ（つまり、）を使用して、バイナリ安定型列挙型（C ++ 11など）の基になる型をオーバーライドすることもできますtypedef SafeEnum<enum TFlags_,uint8_t> TFlags;。
operator boolオーバーライドをC++11のキーワードでマークしてexplicit、int変換が発生しないようにしました。これは、フラグのセットを書き出すときに0または1に折りたたまれる可能性があるためです。C ++ 11を使用できない場合は、そのオーバーロードを省略し、使用例の最初の条件を。として書き直します(myFlags & EFlagTwo) == EFlagTwo。
ここに示すように、標準ライブラリクラスのビットセットを使用してこれを行う最も簡単な方法。
タイプセーフな方法でC＃機能をエミュレートするには、ビットセットの周りにテンプレートラッパーを記述し、int引数をテンプレートのタイプパラメーターとして指定された列挙型に置き換える必要があります。何かのようなもの：
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;
私の意見では、これまでのところ理想的な答えはありません。理想的には、私は解決策を期待します：
==および演算子を!=サポートします（つまり）=&&=||=~a & bif (a & b)...これまでのところ、ほとんどのソリューションはポイント2または3に該当します。私の意見ではWebDancerは終わりですが、ポイント3で失敗するため、列挙型ごとに繰り返す必要があります。
私が提案するソリューションは、WebDancerの一般化されたバージョンであり、ポイント3にも対応しています。
#include <cstdint>
#include <type_traits>
template<typename T = typename std::enable_if<std::is_enum<T>::value, T>::type>
class auto_bool
{
T val_;
public:
constexpr auto_bool(T val) : val_(val) {}
constexpr operator T() const { return val_; }
constexpr explicit operator bool() const
{
return static_cast<std::underlying_type_t<T>>(val_) != 0;
}
};
template <typename T = typename std::enable_if<std::is_enum<T>::value, T>::type>
constexpr auto_bool<T> operator&(T lhs, T rhs)
{
return static_cast<T>(
static_cast<typename std::underlying_type<T>::type>(lhs) &
static_cast<typename std::underlying_type<T>::type>(rhs));
}
template <typename T = typename std::enable_if<std::is_enum<T>::value, T>::type>
constexpr T operator|(T lhs, T rhs)
{
return static_cast<T>(
static_cast<typename std::underlying_type<T>::type>(lhs) |
static_cast<typename std::underlying_type<T>::type>(rhs));
}
enum class AnimalFlags : uint8_t
{
HasClaws = 1,
CanFly = 2,
EatsFish = 4,
Endangered = 8
};
enum class PlantFlags : uint8_t
{
HasLeaves = 1,
HasFlowers = 2,
HasFruit = 4,
HasThorns = 8
};
int main()
{
AnimalFlags seahawk = AnimalFlags::CanFly; // Compiles, as expected
AnimalFlags lion = AnimalFlags::HasClaws; // Compiles, as expected
PlantFlags rose = PlantFlags::HasFlowers; // Compiles, as expected
// rose = 1; // Won't compile, as expected
if (seahawk != lion) {} // Compiles, as expected
// if (seahawk == rose) {} // Won't compile, as expected
// seahawk = PlantFlags::HasThorns; // Won't compile, as expected
seahawk = seahawk | AnimalFlags::EatsFish; // Compiles, as expected
lion = AnimalFlags::HasClaws | // Compiles, as expected
AnimalFlags::Endangered;
// int eagle = AnimalFlags::CanFly | // Won't compile, as expected
// AnimalFlags::HasClaws;
// int has_claws = seahawk & AnimalFlags::CanFly; // Won't compile, as expected
if (seahawk & AnimalFlags::CanFly) {} // Compiles, as expected
seahawk = seahawk & AnimalFlags::CanFly; // Compiles, as expected
return 0;
}
これにより、必要な演算子のオーバーロードが作成されますが、SFINAEを使用してそれらを列挙型に制限します。簡潔にするために、すべての演算子を定義したわけではありませんが、異なるのは。だけ&です。演算子は現在グローバルです（つまり、すべての列挙型に適用されます）が、名前空間にオーバーロードを配置するか（私が行うこと）、または追加のSFINAE条件を追加することによって（おそらく特定の基になる型または特別に作成された型エイリアスを使用して）これを減らすことができます）。これunderlying_type_tはC++14の機能ですが、十分にサポートされているようで、単純なC++11で簡単にエミュレートできます。template<typename T> using underlying_type_t = underlying_type<T>::type;
C ++標準では、これについて明示的に説明しています。「17.5.2.1.3ビットマスクタイプ」のセクションを参照してください。
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3485.pdf
この「テンプレート」が与えられると、次のようになります。
enum AnimalFlags : unsigned int
{
HasClaws = 1,
CanFly = 2,
EatsFish = 4,
Endangered = 8
};
constexpr AnimalFlags operator|(AnimalFlags X, AnimalFlags Y) {
return static_cast<AnimalFlags>(
static_cast<unsigned int>(X) | static_cast<unsigned int>(Y));
}
AnimalFlags& operator|=(AnimalFlags& X, AnimalFlags Y) {
X = X | Y; return X;
}
そして、他のオペレーターについても同様です。また、「constexpr」にも注意してください。コンパイラが演算子のコンパイル時間を実行できるようにする場合に必要です。
C ++ / CLIを使用していて、refクラスの列挙型メンバーに割り当てることができるようにする場合は、代わりに追跡参照を使用する必要があります。
AnimalFlags% operator|=(AnimalFlags% X, AnimalFlags Y) {
X = X | Y; return X;
}
注：このサンプルは完全ではありません。演算子の完全なセットについては、「17.5.2.1.3ビットマスクタイプ」のセクションを参照してください。
シンタックスシュガーのみ。追加のメタデータはありません。
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;
}
積分型のフラグ演算子は正しく機能します。
次のマクロを使用します。
#define ENUM_FLAG_OPERATORS(T) \
inline T operator~ (T a) { return static_cast<T>( ~static_cast<std::underlying_type<T>::type>(a) ); } \
inline T operator| (T a, T b) { return static_cast<T>( static_cast<std::underlying_type<T>::type>(a) | static_cast<std::underlying_type<T>::type>(b) ); } \
inline T operator& (T a, T b) { return static_cast<T>( static_cast<std::underlying_type<T>::type>(a) & static_cast<std::underlying_type<T>::type>(b) ); } \
inline T operator^ (T a, T b) { return static_cast<T>( static_cast<std::underlying_type<T>::type>(a) ^ static_cast<std::underlying_type<T>::type>(b) ); } \
inline T& operator|= (T& a, T b) { return reinterpret_cast<T&>( reinterpret_cast<std::underlying_type<T>::type&>(a) |= static_cast<std::underlying_type<T>::type>(b) ); } \
inline T& operator&= (T& a, T b) { return reinterpret_cast<T&>( reinterpret_cast<std::underlying_type<T>::type&>(a) &= static_cast<std::underlying_type<T>::type>(b) ); } \
inline T& operator^= (T& a, T b) { return reinterpret_cast<T&>( reinterpret_cast<std::underlying_type<T>::type&>(a) ^= static_cast<std::underlying_type<T>::type>(b) ); }
上記のものと似ていますが、いくつかの改善点があります。
int）type_traitsを含める必要があります。
#include <type_traits>
私は同じ質問をしていることに気づき、sourのような一般的なC++11ベースのソリューションを思いつきました。
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|=(TENUM f)
{
return set(f);
}
};
インターフェースを好みに合わせて改善することができます。次に、次のように使用できます。
FlagSet<Flags> flags{Flags::FLAG_A, Flags::FLAG_C};
flags |= Flags::FLAG_D;
コンパイラが強く型付けされた列挙型をまだサポートしていない場合は、c++ソースの次の記事を参照してください。
要約から：
この記事では、ビット操作を制約して
安全で正当なものだけを許可し、すべての無効なビット操作をコンパイル時エラーに変えるという問題の解決策を紹介します。何よりも、ビット演算の構文は変更されておらず、ビットを処理するコードを変更する必要はありません。ただし、まだ検出されていないエラーを修正する場合を除きます。
個々の列挙値を実際に使用しない場合（たとえば、それらをオフにする必要がない場合）、およびバイナリ互換性を維持することを心配していない場合、つまり、ビットマスクのオプションは次のとおりです。あなたのビットがどこに住んでいるかは気にしないでください...おそらくあなたはそうです。また、スコープとアクセス制御についてはあまり気にしない方がよいでしょう。うーん、列挙型にはビットフィールドに適したプロパティがいくつかあります...誰かがそれを試したことがあるかどうか疑問に思います:)
struct AnimalProperties
{
bool HasClaws : 1;
bool CanFly : 1;
bool EatsFish : 1;
bool Endangered : 1;
};
union AnimalDescription
{
AnimalProperties Properties;
int Flags;
};
void TestUnionFlags()
{
AnimalDescription propertiesA;
propertiesA.Properties.CanFly = true;
AnimalDescription propertiesB = propertiesA;
propertiesB.Properties.EatsFish = true;
if( propertiesA.Flags == propertiesB.Flags )
{
cout << "Life is terrible :(";
}
else
{
cout << "Life is great!";
}
AnimalDescription propertiesC = propertiesA;
if( propertiesA.Flags == propertiesC.Flags )
{
cout << "Life is great!";
}
else
{
cout << "Life is terrible :(";
}
}
人生は素晴らしいものであり、離散的な価値観があり、＆と|への素晴らしい整数があることがわかります。私たちの心のコンテンツに、それはまだそのビットが何を意味するのかという文脈を持っています。すべてが一貫していて予測可能です...私にとっては...Win10x64でUpdate3を使用してMicrosoftのVC++コンパイラを使用し続け、コンパイラフラグに触れない限り:)
すべてが素晴らしいですが...フラグの意味については、いくつかのコンテキストがあります。これは、プログラムが複数の個別のタスクを担当する可能性があるひどい現実世界のビットフィールドとの結合であるためです。それでも偶然に（非常に簡単に）異なるユニオンの2つのフラグフィールドを一緒に粉砕し（たとえば、AnimalPropertiesとObjectPropertiesは両方ともintであるため）、すべてのビットを混同します。これは追跡するのに恐ろしいバグです...そして私が知っている方法この投稿の多くの人は、ビットマスクの作成が簡単で、保守が難しいため、ビットマスクをあまり頻繁に使用しません。
class AnimalDefinition {
public:
static AnimalDefinition *GetAnimalDefinition( AnimalFlags flags ); //A little too obvious for my taste... NEXT!
static AnimalDefinition *GetAnimalDefinition( AnimalProperties properties ); //Oh I see how to use this! BORING, NEXT!
static AnimalDefinition *GetAnimalDefinition( int flags ); //hmm, wish I could see how to construct a valid "flags" int without CrossFingers+Ctrl+Shift+F("Animal*"). Maybe just hard-code 16 or something?
AnimalFlags animalFlags; //Well this is *way* too hard to break unintentionally, screw this!
int flags; //PERFECT! Nothing will ever go wrong here...
//wait, what values are used for this particular flags field? Is this AnimalFlags or ObjectFlags? Or is it RuntimePlatformFlags? Does it matter? Where's the documentation?
//Well luckily anyone in the code base and get confused and destroy the whole program! At least I don't need to static_cast anymore, phew!
private:
AnimalDescription m_description; //Oh I know what this is. All of the mystery and excitement of life has been stolen away :(
}
したがって、「フラグ」への直接アクセスを防ぐためにユニオン宣言をプライベートにし、ゲッター/セッターと演算子のオーバーロードを追加してから、それらすべてのマクロを作成する必要があります。列挙型でこれを行います。
残念ながら、コードを移植可能にしたい場合は、A）ビットレイアウトを保証する方法、またはB）コンパイル時にビットレイアウトを決定する方法はないと思います（したがって、コードを追跡し、少なくとも全体の変更を修正できます）バージョン/プラットフォームなど） ビットフィールドを持つ構造体のオフセット
実行時に、フィールドを設定し、フラグをXORして、どのビットが変更されたかを確認するトリックをプレイできます。100％一貫性があり、プラットフォームに依存せず、完全に決定論的なソリューション、つまりENUMを使用している場合でも、私にはかなりくだらないように聞こえます。
TL; DR：嫌いな人の言うことを聞かないでください。C++は英語ではありません。Cから継承された省略キーワードのリテラル定義が使用法に適合しない可能性があるからといって、キーワードのCおよびC++定義にユースケースが完全に含まれている場合にそれを使用すべきではないという意味ではありません。構造体を使用して、構造体以外のものをモデル化したり、学校や社会カースト以外のもののクラスをモデル化したりすることもできます。接地されている値にはfloatを使用できます。未燃でも、小説、演劇、映画の人物でもない変数には、charを使用できます。言語仕様の前にキーワードの意味を決定するために辞書に行くプログラマーは誰でも...まあ、私はそこに私の舌を保持します。
話されている言語に基づいてコードをモデル化する場合は、Objective-Cで記述するのが最適です。Objective-Cは、ビットフィールドにも列挙型を多用します。
C ++11より前のC++バージョンにはテンプレートとキーワードがないため、 Uliwitnessの回答について詳しく説明し、C ++ 98のコードを修正し、 SafeBoolイディオムを使用します。std::underlying_type<>explicit
また、列挙値が明示的な割り当てなしでシーケンシャルになるように変更したので、
enum AnimalFlags_
{
HasClaws,
CanFly,
EatsFish,
Endangered
};
typedef FlagsEnum<AnimalFlags_> AnimalFlags;
seahawk.flags = AnimalFlags() | CanFly | EatsFish | Endangered;
次に、生のフラグ値を次のように取得できます。
seahawk.flags.value();
これがコードです。
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 |=(const FlagsEnum& f) {
m_flags |= f.m_flags;
return *this;
}
FlagsEnum& operator &=(const FlagsEnum& f) {
m_flags &= f.m_flags;
return *this;
}
friend FlagsEnum operator |(const FlagsEnum& f1, const FlagsEnum& f2) {
return FlagsEnum(f1) |= 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;
};
現在、列挙型フラグの言語サポートはありません。メタクラスがc ++標準の一部である場合、この機能を本質的に追加する可能性があります。
私の解決策は、列挙型のみのインスタンス化されたテンプレート関数を作成し、その基になる型を使用して列挙型クラスの型セーフなビット単位の操作のサポートを追加することです。
ファイル：EnumClassBitwise.h
#pragma once
#ifndef _ENUM_CLASS_BITWISE_H_
#define _ENUM_CLASS_BITWISE_H_
#include <type_traits>
//unary ~operator
template <typename Enum, typename std::enable_if_t<std::is_enum<Enum>::value, int> = 0>
constexpr inline Enum& operator~ (Enum& val)
{
val = static_cast<Enum>(~static_cast<std::underlying_type_t<Enum>>(val));
return val;
}
// & operator
template <typename Enum, typename std::enable_if_t<std::is_enum<Enum>::value, int> = 0>
constexpr inline Enum operator& (Enum lhs, Enum rhs)
{
return static_cast<Enum>(static_cast<std::underlying_type_t<Enum>>(lhs) & static_cast<std::underlying_type_t<Enum>>(rhs));
}
// &= operator
template <typename Enum, typename std::enable_if_t<std::is_enum<Enum>::value, int> = 0>
constexpr inline Enum operator&= (Enum& lhs, Enum rhs)
{
lhs = static_cast<Enum>(static_cast<std::underlying_type_t<Enum>>(lhs) & static_cast<std::underlying_type_t<Enum>>(rhs));
return lhs;
}
//| operator
template <typename Enum, typename std::enable_if_t<std::is_enum<Enum>::value, int> = 0>
constexpr inline Enum operator| (Enum lhs, Enum rhs)
{
return static_cast<Enum>(static_cast<std::underlying_type_t<Enum>>(lhs) | static_cast<std::underlying_type_t<Enum>>(rhs));
}
//|= operator
template <typename Enum, typename std::enable_if_t<std::is_enum<Enum>::value, int> = 0>
constexpr inline Enum& operator|= (Enum& lhs, Enum rhs)
{
lhs = static_cast<Enum>(static_cast<std::underlying_type_t<Enum>>(lhs) | static_cast<std::underlying_type_t<Enum>>(rhs));
return lhs;
}
#endif // _ENUM_CLASS_BITWISE_H_
便宜上、ミスを減らすために、列挙型と整数のビットフラグ操作をラップすることもできます。
ファイル：BitFlags.h
#pragma once
#ifndef _BIT_FLAGS_H_
#define _BIT_FLAGS_H_
#include "EnumClassBitwise.h"
template<typename T>
class BitFlags
{
public:
constexpr inline BitFlags() = default;
constexpr inline BitFlags(T value) { mValue = value; }
constexpr inline BitFlags operator| (T rhs) const { return mValue | rhs; }
constexpr inline BitFlags operator& (T rhs) const { return mValue & rhs; }
constexpr inline BitFlags operator~ () const { return ~mValue; }
constexpr inline operator T() const { return mValue; }
constexpr inline BitFlags& operator|=(T rhs) { mValue |= rhs; return *this; }
constexpr inline BitFlags& operator&=(T rhs) { mValue &= rhs; return *this; }
constexpr inline bool test(T rhs) const { return (mValue & rhs) == rhs; }
constexpr inline void set(T rhs) { mValue |= rhs; }
constexpr inline void clear(T rhs) { mValue &= ~rhs; }
private:
T mValue;
};
#endif //#define _BIT_FLAGS_H_
考えられる使用法：
#include <cstdint>
#include <BitFlags.h>
void main()
{
enum class Options : uint32_t
{
NoOption = 0 << 0
, Option1 = 1 << 0
, Option2 = 1 << 1
, Option3 = 1 << 2
, Option4 = 1 << 3
};
const uint32_t Option1 = 1 << 0;
const uint32_t Option2 = 1 << 1;
const uint32_t Option3 = 1 << 2;
const uint32_t Option4 = 1 << 3;
//Enum BitFlags
BitFlags<Options> optionsEnum(Options::NoOption);
optionsEnum.set(Options::Option1 | Options::Option3);
//Standard integer BitFlags
BitFlags<uint32_t> optionsUint32(0);
optionsUint32.set(Option1 | Option3);
return 0;
}
@Xaqqは、クラスによってここで列挙型フラグを使用するための非常に優れたタイプセーフな方法を提供しました。flag_set
コードをGitHubで公開しましたが、使用法は次のとおりです。
#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
| AnimalFlags::EATS_FISH
| AnimalFlags::ENDANGERED);
if (seahawkFlags & AnimalFlags::ENDANGERED)
cout << "Seahawk is endangered";
}
あなたはオブジェクトとオブジェクトのコレクションを混乱させています。具体的には、バイナリフラグとバイナリフラグのセットを混同しています。適切な解決策は次のようになります。
// 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 << flag); }
void Clear( AnimalFlag flag ) { m_Flags &= ~ (1 << flag); }
bool Get( AnimalFlag flag ) const { return (m_Flags >> flag) & 1; }
};
オーバーロードやキャストを一切必要としない私のソリューションは次のとおりです。
namespace EFoobar
{
enum
{
FB_A = 0x1,
FB_B = 0x2,
FB_C = 0x4,
};
typedef long Flags;
}
void Foobar(EFoobar::Flags flags)
{
if (flags & EFoobar::FB_A)
// do sth
;
if (flags & EFoobar::FB_B)
// do sth
;
}
void ExampleUsage()
{
Foobar(EFoobar::FB_A | EFoobar::FB_B);
EFoobar::Flags otherflags = 0;
otherflags|= EFoobar::FB_B;
otherflags&= ~EFoobar::FB_B;
Foobar(otherflags);
}
とにかく（強く型付けされていない）列挙型と整数を識別するので、大丈夫だと思います。
（長い）サイドノートと同じように、
私はこれを思い付くでしょう：
#include <set>
enum class EFoobarFlags
{
FB_A = 1,
FB_B,
FB_C,
};
void Foobar(const std::set<EFoobarFlags>& flags)
{
if (flags.find(EFoobarFlags::FB_A) != flags.end())
// do sth
;
if (flags.find(EFoobarFlags::FB_B) != flags.end())
// do sth
;
}
void ExampleUsage()
{
Foobar({EFoobarFlags::FB_A, EFoobarFlags::FB_B});
std::set<EFoobarFlags> otherflags{};
otherflags.insert(EFoobarFlags::FB_B);
otherflags.erase(EFoobarFlags::FB_B);
Foobar(otherflags);
}
C++11初期化子リストとを使用しますenum class。
別のマクロソリューションですが、既存の回答とは異なり、標準のC ++では禁止されているとreinterpret_castの間のキャストに（またはCキャスト）を使用しません（この投稿を参照）。Enum&Int&
#define MAKE_FLAGS_ENUM(TEnum, TUnder) \
TEnum operator~ ( TEnum a ) { return static_cast<TEnum> (~static_cast<TUnder> (a) ); } \
TEnum operator| ( TEnum a, TEnum b ) { return static_cast<TEnum> ( static_cast<TUnder> (a) | static_cast<TUnder>(b) ); } \
TEnum operator& ( TEnum a, TEnum b ) { return static_cast<TEnum> ( static_cast<TUnder> (a) & static_cast<TUnder>(b) ); } \
TEnum operator^ ( TEnum a, TEnum b ) { return static_cast<TEnum> ( static_cast<TUnder> (a) ^ static_cast<TUnder>(b) ); } \
TEnum& operator|= ( TEnum& a, TEnum b ) { a = static_cast<TEnum>(static_cast<TUnder>(a) | static_cast<TUnder>(b) ); return a; } \
TEnum& operator&= ( TEnum& a, TEnum b ) { a = static_cast<TEnum>(static_cast<TUnder>(a) & static_cast<TUnder>(b) ); return a; } \
TEnum& operator^= ( TEnum& a, TEnum b ) { a = static_cast<TEnum>(static_cast<TUnder>(a) ^ static_cast<TUnder>(b) ); return a; }
意味を失うというreinterpret_castことは、構文に頼ることができなくなったことを意味しx |= yますが、これらをx = x | y形式に拡張することで、構文は不要になります。
注：std::underlying_typeを取得するために使用できますTUnder。簡潔にするために含めていません。
上記（カイ）のように、または以下を行います。本当に列挙型は「列挙型」であり、あなたがしたいのはセットを持っていることです、それであなたは本当にstl::setを使うべきです
enum AnimalFlags
{
HasClaws = 1,
CanFly =2,
EatsFish = 4,
Endangered = 8
};
int main(void)
{
AnimalFlags seahawk;
//seahawk= CanFly | EatsFish | Endangered;
seahawk= static_cast<AnimalFlags>(CanFly | EatsFish | Endangered);
}
たぶんObjective-CのNS_OPTIONSのように。
#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<T1>((static_cast<T2>(a) | 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^ (T1 a, T1 b) { return static_cast<T1>((static_cast<T2>(a) ^ 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&= (T1& a, T1 b) { return reinterpret_cast<T1&>((reinterpret_cast<T2&>(a) &= static_cast<T2>(b))); } \
inline T1& operator^= (T1& a, T1 b) { return reinterpret_cast<T1&>((reinterpret_cast<T2&>(a) ^= 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 | Options::SECOND;
options |= 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.
#include <type_traits>
/*
* Macro to allow enum values to be combined and evaluated as flags.
* * Based on:
* - DEFINE_ENUM_FLAG_OPERATORS from <winnt.h>
* - https://stackoverflow.com/a/63031334/1624459
*/
#define MAKE_ENUM_FLAGS(TEnum) \
inline TEnum operator~(TEnum a) { \
using TUnder = typename std::underlying_type_t<TEnum>; \
return static_cast<TEnum>(~static_cast<TUnder>(a)); \
} \
inline TEnum operator|(TEnum a, TEnum b) { \
using TUnder = typename std::underlying_type_t<TEnum>; \
return static_cast<TEnum>(static_cast<TUnder>(a) | static_cast<TUnder>(b)); \
} \
inline TEnum operator&(TEnum a, TEnum b) { \
using TUnder = typename std::underlying_type_t<TEnum>; \
return static_cast<TEnum>(static_cast<TUnder>(a) & static_cast<TUnder>(b)); \
} \
inline TEnum operator^(TEnum a, TEnum b) { \
using TUnder = typename std::underlying_type_t<TEnum>; \
return static_cast<TEnum>(static_cast<TUnder>(a) ^ static_cast<TUnder>(b)); \
} \
inline TEnum& operator|=(TEnum& a, TEnum b) { \
using TUnder = typename std::underlying_type_t<TEnum>; \
a = static_cast<TEnum>(static_cast<TUnder>(a) | static_cast<TUnder>(b)); \
return a; \
} \
inline TEnum& operator&=(TEnum& a, TEnum b) { \
using TUnder = typename std::underlying_type_t<TEnum>; \
a = static_cast<TEnum>(static_cast<TUnder>(a) & static_cast<TUnder>(b)); \
return a; \
} \
inline TEnum& operator^=(TEnum& a, TEnum b) { \
using TUnder = typename std::underlying_type_t<TEnum>; \
a = static_cast<TEnum>(static_cast<TUnder>(a) ^ static_cast<TUnder>(b)); \
return a; \
}
enum class Passability : std::uint8_t {
Clear = 0,
GroundUnit = 1 << 1,
FlyingUnit = 1 << 2,
Building = 1 << 3,
Tree = 1 << 4,
Mountain = 1 << 5,
Blocked = 1 << 6,
Water = 1 << 7,
Coastline = 1 << 8
};
MAKE_ENUM_FLAGS(Passability)
reinterpret_cast。std::underlying_type_t<TEnum>している場合はに置き換えます。std::underlying_type<TEnum>::typeこれは、列挙型のデフォルトの動作を変更しない怠惰なC++11ソリューションです。とにも機能しenum struct、enum classですconstexpr。
#include <type_traits>
template<class T = void> struct enum_traits {};
template<> struct enum_traits<void> {
struct _allow_bitops {
static constexpr bool allow_bitops = true;
};
using allow_bitops = _allow_bitops;
template<class T, class R = T>
using t = typename std::enable_if<std::is_enum<T>::value and
enum_traits<T>::allow_bitops, R>::type;
template<class T>
using u = typename std::underlying_type<T>::type;
};
template<class T>
constexpr enum_traits<>::t<T> operator~(T a) {
return static_cast<T>(~static_cast<enum_traits<>::u<T>>(a));
}
template<class T>
constexpr enum_traits<>::t<T> operator|(T a, T b) {
return static_cast<T>(
static_cast<enum_traits<>::u<T>>(a) |
static_cast<enum_traits<>::u<T>>(b));
}
template<class T>
constexpr enum_traits<>::t<T> operator&(T a, T b) {
return static_cast<T>(
static_cast<enum_traits<>::u<T>>(a) &
static_cast<enum_traits<>::u<T>>(b));
}
template<class T>
constexpr enum_traits<>::t<T> operator^(T a, T b) {
return static_cast<T>(
static_cast<enum_traits<>::u<T>>(a) ^
static_cast<enum_traits<>::u<T>>(b));
}
template<class T>
constexpr enum_traits<>::t<T, T&> operator|=(T& a, T b) {
a = a | b;
return a;
}
template<class T>
constexpr enum_traits<>::t<T, T&> operator&=(T& a, T b) {
a = a & b;
return a;
}
template<class T>
constexpr enum_traits<>::t<T, T&> operator^=(T& a, T b) {
a = a ^ b;
return a;
}
列挙型のビット演算子を有効にするには：
enum class my_enum {
Flag1 = 1 << 0,
Flag2 = 1 << 1,
Flag3 = 1 << 2,
// ...
};
// The magic happens here
template<> struct enum_traits<my_enum> :
enum_traits<>::allow_bitops {};
constexpr my_enum foo = my_enum::Flag1 | my_enum::Flag2 | my_enum::Flag3;
structは次のように使用できます。
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
};
そしてこれとして使用します：
int flags = UiFlags2::FULLSCREEN | UiFlags2::HIDE_NAVIGATION;
intしたがって、キャストする必要はなく、直接使用できます。
また、スコープは次のように分離されていますenum class