如何使用选项真、假、默认值和切换C++实现标志

不是很漂亮，但非常简单(从你的方法 1 构建)：

#include <iostream>
using Flag = int;
static const Flag Flag1 = 1<<0;
static const Flag Flag2 = 1<<2;
// add more flags to turn things off, etc.
class Foo
{
bool flag1 = true;      // default true
bool flag2 = false;     // default false
void applyDefault(Flag& f)
{
if (f & Flag1)
flag1 = true;
if (f & Flag2)
flag2 = true;
// apply off flags
}
public:
void operator()(/*args ,*/ Flag f)
{
applyDefault(f);
if (flag1)
std::cout << "Flag 1 ONn";
if (flag2)
std::cout << "Flag 2 ONn";
}
};
void foo(/*args ,*/ Flag flags)
{
Foo f;
f(flags);
}
int main()
{
foo(Flag1); // Flag1 ON
foo(Flag2); // Flag1 ONnFlag2 ON
foo(Flag1 | Flag2); // Flag1 ONnFlag2 ON
return 0;
}

您的评论和回答为我指明了我喜欢并希望与您分享的解决方案：

struct Default_t{} Default;
struct Toggle_t{} Toggle;
struct FlagSet{
uint m_set;
uint m_reset;
constexpr FlagSet operator|(const FlagSet other) const{
return {
~m_reset & other.m_set & ~other.m_reset |
~m_set & other.m_set & other.m_reset |
m_set & ~other.m_set,
m_reset & ~other.m_reset |
~m_set & ~other.m_set & other.m_reset|
~m_reset & other.m_set & other.m_reset};
}
constexpr FlagSet& operator|=(const FlagSet other){
*this = *this|other;
return *this;
}
};
struct Flag{
const uint m_bit;
constexpr FlagSet operator= (bool val) const{
return {(uint)val<<m_bit,(!(uint)val)<<m_bit};
}
constexpr FlagSet operator= (Default_t) const{
return {0u,0u};
}
constexpr FlagSet operator= (Toggle_t) const {
return {1u<<m_bit,1u<<m_bit};
}
constexpr uint operator& (FlagSet i) const{
return i.m_set & (1u<<m_bit);
}
constexpr operator FlagSet() const{
return {1u<<m_bit,0u}; //= set
}
constexpr FlagSet operator|(const Flag other) const{
return (FlagSet)*this|(FlagSet)other;
}
constexpr FlagSet operator|(const FlagSet other) const{
return (FlagSet)*this|other;
}
};
constexpr uint operator& (FlagSet i, Flag f){
return f & i;
}

所以基本上FlagSet包含两个整数。一个用于设置，一个用于重置。不同的组合表示该特定位的不同操作：

{false,false} = Default (D)
{true ,false} = Set (S)
{false,true } = Reset (R)
{true ,true } = Toggle (T)

operator|使用相当复杂的按位运算，旨在完成填充

D|D = D
D|R = R|D = R
D|S = S|D = S
D|T = T|D = T
T|T = D
T|R = R|T = S
T|S = S|T = R
S|S = S
R|R = R
S|R = S  (*)
R|S = R  (*) 

(*)中的非交换行为是由于这样一个事实，即我们以某种方式需要能够决定哪一个是"默认"的，哪一个是"用户定义的"。因此，在值冲突的情况下，左边的值优先。

Flag类表示单个标志，基本上是其中一个位。使用不同的operator=()重载可以使某种"键值表示法"直接转换为 FlagSet，其中位置的位对m_bit设置为先前定义的对之一。默认情况下(operator FlagSet())，这将转换为给定位上的Set(S)操作。
该类还为按位 OR 提供了一些重载，这些重载会自动转换为FlagSet并operator&()以实际将Flag与FlagSet进行比较。在此比较中，Set(S) 和 Toggle(T) 都被认为是true，而 Reset(R) 和 Default(D) 都被认为是false。

使用它非常简单，非常接近"通常"的标志实现：

constexpr Flag Flag1{0};
constexpr Flag Flag2{1};
constexpr Flag Flag3{2};
constexpr auto NoFlag1 = (Flag1=false); //Just for convenience, not really needed;

void foo(FlagSet f={0,0}){
f |= Flag1|Flag2; //This sets the default. Remember: default right, user left
cout << ((f & Flag1)?"1":"0");
cout << ((f & Flag2)?"2":"0");
cout << ((f & Flag3)?"3":"0");
cout << endl;
}
int main() {
foo();
foo(Flag3);
foo(Flag3|(Flag2=false));
foo(Flag3|NoFlag1);
foo((Flag1=Toggle)|(Flag2=Toggle)|(Flag3=Toggle));
return 0;
}

输出：

120
123
103
023
003

在 ideone 上进行测试

关于效率的最后一句话：虽然我没有在没有所有constexpr关键字的情况下对其进行测试，但使用它们的代码：

bool test1(){
return Flag1&((Flag1=Toggle)|(Flag2=Toggle)|(Flag3=Toggle));
}
bool test2(){
FlagSet f = Flag1|Flag2 ;
return f & Flag1;
}
bool test3(FlagSet f){
f |= Flag1|Flag2 ;
return f & Flag1;
}

编译为 (usign gcc 5.3 on gcc.godbolt.org)

test1():
movl    $1, %eax
ret
test2():
movl    $1, %eax
ret
test3(FlagSet):
movq    %rdi, %rax
shrq    $32, %rax
notl    %eax
andl    $1, %eax
ret

虽然我不完全熟悉汇编代码，但这看起来像是非常基本的按位运算，可能是您在不内联测试函数的情况下可以获得的最快操作。

如果我理解这个问题，您可以通过从bool和默认构造函数创建一个带有隐式构造函数的简单类来解决问题：

class T
{
T(bool value):def(false), value(value){} // implicit constructor from bool
T():def(true){}
bool def; // is flag default
bool value; // flag value if flag isn't default
}

并在这样的函数中使用它：

void f(..., T flag = T());

void f(..., true); // call with flag = true
void f(...); // call with flag = default

如果我理解正确，您想要一种简单的方法将一个或多个标志作为单个参数传递给函数，和/或一种简单的方法让对象跟踪单个变量中的一个或多个标志，对吗？ 一种简单的方法是将标志指定为类型化枚举，其无符号基础类型足够大，可以容纳所需的所有标志。 例如：

/* Assuming C++11 compatibility.  If you need to work with an older compiler, you'll have
* to manually insert the body of flag() into each BitFlag's definition, and replace
* FLAG_INVALID's definition with something like:
*   FLAG_INVALID = static_cast<flag_t>(-1) -
*                   (FFalse + FTrue + FDefault + FToggle),
*/
#include <climits>
// For CHAR_BIT.
#include <cstdint>
// For uint8_t.
// Underlying flag type.  Change as needed.  Should remain unsigned.
typedef uint8_t flag_t;
// Helper functions, to provide cleaner syntax to the enum.
// Not actually necessary, they'll be evaluated at compile time either way.
constexpr flag_t flag(int f) { return 1 << f; }
constexpr flag_t fl_validate(int f) {
return (f ? (1 << f) + fl_validate(f - 1) : 1);
}
constexpr flag_t register_invalids(int f) {
// The static_cast is a type-independent maximum value for unsigned ints.  The compiler
//  may or may not complain.
// (f - 1) compensates for bits being zero-indexed.
return static_cast<flag_t>(-1) - fl_validate(f - 1);
}
// List of available flags.
enum BitFlag : flag_t {
FFalse   = flag(0),  // 0001
FTrue    = flag(1),  // 0010
FDefault = flag(2),  // 0100
FToggle  = flag(3),  // 1000
// ...
// Number of defined flags.
FLAG_COUNT = 4,
// Indicator for invalid flags.  Can be used to make sure parameters are valid, or
// simply to mask out any invalid ones.
FLAG_INVALID = register_invalids(FLAG_COUNT),
// Maximum number of available flags.
FLAG_MAX = sizeof(flag_t) * CHAR_BIT
};
// ...
void func(flag_t f);
// ...
class CL {
flag_t flags;
// ...
};

请注意，这假定FFalse和FTrue应该是不同的标志，可以同时指定这两个标志。 如果您希望它们互斥，则需要进行一些小的更改：

// ...
constexpr flag_t register_invalids(int f) {
// Compensate for 0th and 1st flags using the same bit.
return static_cast<flag_t>(-1) - fl_validate(f - 2);
}
// ...
enum BitFlag : flag_t {
FFalse   = 0,        // 0000
FTrue    = flag(0),  // 0001
FDefault = flag(1),  // 0010
FToggle  = flag(2),  // 0100
// ...

或者，您可以修改flag()，而不是修改enum本身：

// ...
constexpr flag_t flag(int f) {
// Give bit 0 special treatment as "false", shift all other flags down to compensate.
return (f ? 1 << (f - 1) : 0);
}
// ...
constexpr flag_t register_invalids(int f) {
return static_cast<flag_t>(-1) - fl_validate(f - 2);
}
// ...
enum BitFlag : flag_t {
FFalse   = flag(0),  // 0000
FTrue    = flag(1),  // 0001
FDefault = flag(2),  // 0010
FToggle  = flag(3),  // 0100
// ...

虽然我相信这是最简单的方法，如果你为flag_t选择尽可能小的基础类型，它可能是最节省内存的方法，但它也可能是最无用的。 [另外，如果您最终使用这个或类似的东西，我建议将帮助程序函数隐藏在命名空间中，以防止全局命名空间中不必要的混乱。

一个简单的例子。

有什么理由我们不能为此使用枚举吗？这是我最近使用的解决方案：

// Example program
#include <iostream>
#include <string>
enum class Flag : int8_t
{
F_TRUE      = 0x0, // Explicitly defined for readability
F_FALSE     = 0x1,
F_DEFAULT   = 0x2,
F_TOGGLE    = 0x3
};
struct flags
{
Flag flag_1;
Flag flag_2;
Flag flag_3;
Flag flag_4;
};
int main()
{
flags my_flags;
my_flags.flag_1 = Flag::F_TRUE;
my_flags.flag_2 = Flag::F_FALSE;
my_flags.flag_3 = Flag::F_DEFAULT;
my_flags.flag_4 = Flag::F_TOGGLE;
std::cout << "size of flags: " << sizeof(flags) << "n";
std::cout << (int)(my_flags.flag_1) << "n";
std::cout << (int)(my_flags.flag_2) << "n";
std::cout << (int)(my_flags.flag_3) << "n";
std::cout << (int)(my_flags.flag_4) << "n";
}

在这里，我们得到以下输出：

size of flags: 4
0
1
2
3

这种方式的内存效率不高。每个标志是 8 位，而每个布尔值一个位，内存增加 4 倍。但是，我们获得了enum class的好处，这可以防止一些愚蠢的程序员错误。

现在，我有另一个解决方案来解决内存至关重要的情况。在这里，我们将 4 个标志打包到一个 8 位结构中。这是我为数据编辑器想出的这个，它非常适合我的用途。但是，我现在意识到可能存在缺点。

// Example program
#include <iostream>
#include <string>
enum Flag
{
F_TRUE      = 0x0, // Explicitly defined for readability
F_FALSE     = 0x1,
F_DEFAULT   = 0x2,
F_TOGGLE    = 0x3
};
struct PackedFlags
{
public:
bool flag_1_0:1;
bool flag_1_1:1;
bool flag_2_0:1;
bool flag_2_1:1;
bool flag_3_0:1;
bool flag_3_1:1;
bool flag_4_0:1;
bool flag_4_1:1;
public:
Flag GetFlag1()
{
return (Flag)(((int)flag_1_1 << 1) + (int)flag_1_0);
}
Flag GetFlag2()
{
return (Flag)(((int)flag_2_1 << 1) + (int)flag_2_0);
}
Flag GetFlag3()
{
return (Flag)(((int)flag_3_1 << 1) + (int)flag_3_0);
}
Flag GetFlag4()
{
return (Flag)(((int)flag_4_1 << 1) + (int)flag_4_0);
}
void SetFlag1(Flag flag)
{
flag_1_0 = (flag & (1 << 0));
flag_1_1 = (flag & (1 << 1));
}
void SetFlag2(Flag flag)
{
flag_2_0 = (flag & (1 << 0));
flag_2_1 = (flag & (1 << 1));
}
void SetFlag3(Flag flag)
{
flag_3_0 = (flag & (1 << 0));
flag_3_1 = (flag & (1 << 1));
}
void SetFlag4(Flag flag)
{
flag_4_0 = (flag & (1 << 0));
flag_4_1 = (flag & (1 << 1));
}
};
int main()
{
PackedFlags my_flags;
my_flags.SetFlag1(F_TRUE);
my_flags.SetFlag2(F_FALSE);
my_flags.SetFlag3(F_DEFAULT);
my_flags.SetFlag4(F_TOGGLE);
std::cout << "size of flags: " << sizeof(my_flags) << "n";
std::cout << (int)(my_flags.GetFlag1()) << "n";
std::cout << (int)(my_flags.GetFlag2()) << "n";
std::cout << (int)(my_flags.GetFlag3()) << "n";
std::cout << (int)(my_flags.GetFlag4()) << "n";
}

输出：

size of flags: 1
0
1
2
3