C++ 将结构转换为布尔值

我正在尝试将具有布尔值的struct转换为另一个布尔类型的变量。我正在尝试使用

static\u cast

和

reinterpet\u cast

int main()
{
    bool c,d;

    struct b {
        bool b1 = false; 
        bool b2 = false;
    };

    c = reinterpret_cast<uint8_t*>(&b);
    d = (static_cast<uint8_t*>(static_cast<void*>(&b)));
    cout <<c <<endl;
    cout <<d <<endl;

    return 0;
}

intmain（）
{
boolc，d；
结构b{
bool b1=假；
boolb2=假；
};
c=重新解释铸件（&b）；
d=（静态施法（静态施法（&b））；
cout不能将
struct
的实例转换为
bool
，其中值是布尔值或其所有成员的值，只需一个cast即可。您需要告诉编译器如何将对象转换为
bool
，您可以通过重载类的
运算符bool
来实现这一点。在那里，您可以通过逻辑判断t应被视为
true
或
false
，如下所示

struct Foo
{
    bool a = true;
    bool b = true;
    bool c = false;
    operator bool() { return a || b || c; }
};

int main()
{
    Foo f;
    std::cout << static_cast<bool>(f);
}

如果你有很多像你这样的成员，你应该考虑使用数组而不是单独的成员，这样你就可以写一个循环，C++没有反射，所以没有简单的方法告诉所有成员，或者，把所有的成员都告诉一起。< /P> < P>我不做一个演员，但是我会使用一个成员函数，这个名字有一个明确的名字：

int main()
{
  struct b {
    bool b1 = false;
    bool b2 = false;
    bool b3 = false;    
    bool AtLeastOneIsTrue() { return b1 || b2 || b3;  };
  };

  b str;
  str.b2 = true;
  cout << str.AtLeastOneIsTrue() << endl;

  str.b2 = false;
  cout << str.AtLeastOneIsTrue() << endl;
}

但另一方面，如果您的结构有100个不同的bool成员，那么
atlestoneistrue
函数将非常糟糕。一个bool数组或一个bool向量将更合适

使用向量进行采样：

#include <iostream>
#include <vector>

using namespace std;

int main()
{
  struct b {
    vector<bool> values;

    b(int numberofbools) { values.assign(numberofbools, false); };  // constructor

    bool AtLeastOneIsTrue()
    {
      for (bool v : values)
      {
        if (v)
          return true;
      }

      return false;
    };

    void Set(int number, bool value)
    {
      values[number] = value;
    }
  };


  b str(100);   // str has 100 bool values, all false

  cout << str.AtLeastOneIsTrue() << endl;  // print1 0

  str.Set(3, true);                        // set value number 3 to true
  cout << str.AtLeastOneIsTrue() << endl;  // prints 1
}

#包括
#包括
使用名称空间std；
int main（）
{
结构b{
向量值；
b（int numberofbools）{values.assign（numberofbools，false）；}；//构造函数
布尔亚特兰蒂斯特街（）
{
用于（布尔v：值）
{
如果（v）
返回true；
}
返回false；
};
无效集（整数，布尔值）
{
数值[数值]=数值；
}
};
b str（100）；//str有100个bool值，全部为false
cout如果您可以控制结构定义，这可能是使用逐位逻辑的好地方。如果您最多有128个布尔值，您可以在一对64位变量中处理它们。要检查单个布尔值，您可以使用掩码仅检查预期位。对于问题中描述的情况，您可以对64位变量执行布尔或运算。类似于：

struct b {
    uint64_t boolset_a;
    uint64_t boolset_b;
}

因此，如果您将
var_b
定义为类型
struct b
，您可以这样做以查看它们中是否有任何一个是真的：
var_b.boolset_a | var_b.boolset_b

我认为，这应该是一种更有效的方法，因为它不需要100多个布尔运算来判断它们是否为真。
IMHO，您最好为结构创建一个成员函数或运算符，如所示，它在其中的布尔值上操作。事实上，您可以创建至少两个成员函数，一个告诉y你知道这些布尔值中有没有一个是真的，还有一个能告诉你所有的都是真的

我的方法是使用布尔的
向量
，或者更好的是使用
映射，这样每个布尔都可以有一个名称，然后有两个函数（如果它们属于更大的类，比如配置实体，则使用方法）提供这些标志的所有/任何计算

下面显示了此方法的一个快速而肮脏的示例（对于
auto
循环，在激活C++11的情况下进行编译，或者以其他方式进行修改）：

#包括
#包括
#包括
使用名称空间std；
typedef映射标志；
布尔阿洛克（旗帜和飞行层）{
布尔结果=真；
对于（auto&kv:fl）{result&=kv.second；}
返回结果；
}
bool anyOK（旗帜和飞行高度层）{
布尔结果=假；
对于（auto&kv:fl）{result |=kv.second；}
返回结果；
}
int main（int argc，char*arg[]）
{
旗帜；
标志[“a”]=真；
标志[“b”]=真；
标志[“第三个标志”]=假；
难道你忘了问任何问题。但是为什么你认为这些错误是错误的，也就是说，你为什么认为你可以进行这些转换？它们看起来不像是合理的转换。即使语法是固定的，
uint8\u t
也不能保证是任何
char
类型，因此不能保证该转换将满足别名规则。此外，你为什么觉得有必要首先进行这种类型转换还不太清楚。我投票将其标记为不清楚你在问什么，因为你没有解释你为什么要这样做，你目前是如何尝试的，这本身就不清楚。你没有一个
结构b
来转换为bool。但是转换成bool是没有意义的无论如何，将一个结构rt为布尔。我看到你的结构包含两个布尔——你是想提取一个还是另一个，或者对这两个布尔进行布尔运算？这听起来像是个XY问题。你到底想做什么？@MandeepChaudhary我告诉你-通过操作符
或
aka
|但是你可以更好地组织你的数据，然后你可以使用<代码> STD:：AlxOf或 STD:：YANYO< ETCHY，你没有任何结构。你有一个结构类型，那是另外一回事。无论如何，C++的转换也不能很好地表现C++。也许像BIT这样的东西可能满足你的需要。那就是男人。从理论上重新发明了一个已经存在的轮子：
std:：bitset
及其索引或
all
、
any
或
none
方法，因为它是专门为处理固定大小的位集合而设计的。不过，问题是OP对这些神秘结构中的内容的规定是模糊的，但似乎是不明确的严重地意味着成员不能被改变。@ SubSeCudid你可以把问题的原始标记归咎于C程序员解决C++问题。这个类型的XX{BoOL X：1是错误的；BooLy：1；Booz：1；} Zs；UTI88T*P= STATICE-CAST（STATICE-CAST（ANS））@MandeepChaudhary这是一种未定义的行为。阅读这篇关于punni类型的文章
1
0

#include <iostream>
#include <vector>

using namespace std;

int main()
{
  struct b {
    vector<bool> values;

    b(int numberofbools) { values.assign(numberofbools, false); };  // constructor

    bool AtLeastOneIsTrue()
    {
      for (bool v : values)
      {
        if (v)
          return true;
      }

      return false;
    };

    void Set(int number, bool value)
    {
      values[number] = value;
    }
  };


  b str(100);   // str has 100 bool values, all false

  cout << str.AtLeastOneIsTrue() << endl;  // print1 0

  str.Set(3, true);                        // set value number 3 to true
  cout << str.AtLeastOneIsTrue() << endl;  // prints 1
}

struct b {
    uint64_t boolset_a;
    uint64_t boolset_b;
}

#include <iostream>
#include <string>
#include <map>

using namespace std;

typedef map<string, bool> Flags;

bool allOK(Flags & fl) {
    bool result = true;
    for (auto & kv : fl) { result &= kv.second; }
    return result;
}

bool anyOK(Flags & fl) {
    bool result = false;
    for (auto & kv : fl) { result |= kv.second; }
    return result;
}

int main(int argc, char * arg[])
{
    Flags flags;

    flags["a"] = true;
    flags["b"] = true;
    flags["the_third_flag"] = false;

    cout << "1. ALL OK: " << boolalpha << allOK(flags)
         << " - ANY OK: " << anyOK(flags) << '\n';

    flags["the_third_flag"] = true;
    cout << "2. ALL OK: " << boolalpha << allOK(flags)
         << " - ANY OK: " << anyOK(flags) << '\n';

    flags["a"] = false;
    flags["b"] = false;
    flags["the_third_flag"] = false;
    flags["a_last_flag"] = false;
    cout << "3. ALL OK: " << boolalpha << allOK(flags)
         << " - ANY OK: " << anyOK(flags) << '\n';

    return 0;
}