假设一个"布尔"数组，'a[n] == (-1)'真的吗？

Assuming an array of 'bool', can 'a[n] == (-1)' ever be true?

本文关键字：真的吗 数组 布尔 假设 一个      更新时间：2023-10-16

我有一些代码，其中我有两个布尔数组a[]和b[]，大小相同N。

it是一个指向a索引的迭代器，可能在0到N-1之间 

if( (a[*it] == 1 && index>*it) ||
    (a[index]==b[index] && a[index]==-1 && index!=0))
{
      final = !final;
}
对我来说

，如果条件|| (a[index]==b[index] && a[index]==-1 && index!=0)的第二部分永远不会为真，因为对于任何index a[index]都不等于-1，它要么是1，要么是0......所以我想我可以删除该部分，但是结果会发生变化，对于某些特定条件(我不知道条件， 这是一个在线法官类型的网站，我不知道他们的测试用例是什么(。

我在我的程序中的这个if部分之前添加了另一个测试条件，

if(a[index]==-1){
cout<<"its True";
}

但"它的真实"从未印刷过。

为什么会这样？

编辑：添加实际代码，程序的目的是处理类型的查询

set_a INDEX VALUE

set_b INDEX VALUE

将相应的索引 (0..n-1( 设置为值 (0 或 1(和

get_c index打印出 C=A+B c[index]

请注意，INDEX是从 LSB 端，我将 A 和 B 的 LSB 存储在数组 a 的 MSB 中

，并b

法典：

int main(int argc, char * argv[])
{
  int n, q;
  char c;
  bool a[100005] = {0}, b[100005] = {0};
  VanEmdeBoasTree equals;
  cin>>n;
  cin>>q;
  for(int i=0;i<n;i++){
    cin>>c;
    if(c=='1')
      a[n-i-1] = true;
  }
  for(int i=0;i<n;i++){
    cin>>c;
    if(c=='1')
      b[n-i-1] = true;
    if(a[n-i-1] == b[n-i-1]){
      equals.insert(n-i-1);
    }
  }
  string query;
  int index, val, lastval;
  for(int i=0;i<q;i++){
    cin>>query;
    cin>>index;
    if(query[4] == 'a'){
      cin>>val;
      if(a[index] != val){
        a[index] = val;
        if(val == b[index]){
          equals.insert(index);
        }else{
          equals.erase(index);
        }
      }
    }else if(query[4] == 'b'){
      cin>>val;
      if(b[index] != val){
        b[index] = val;
        if(a[index] == val){
          equals.insert(index);
        }else{
          equals.erase(index);
        }
      }
    }else if(query[4] == 'c'){
      int final = 0;
      if(index >n-1){
        if(equals.size() > 0){
          int last = (*(equals.predecessor(n+1)));
          if(a[last] == 1){
            final = 1;
          }
        }
      }else{
        if(equals.size() > 0 && index>0){
          VanEmdeBoasTree::const_iterator it = equals.predecessor(index);
          final = (a[index] + b[index])%2;
          if( (a[*it] == 1 && index>*it) || (a[index]==b[index] && a[index]==-1 && index!=0)){
            final = !final;
          }
        }else{
          final = (a[index] + b[index])%2;
        }
      }
      cout<<final;
    }
  }
  return 0;
}

如果a确实是一个bool数组，那么除非你越界a[i]==-1总是会产生false。这是毫无疑问的。另一方面，如果您确实越界，那么行为是不确定的，这意味着一切都可能发生，包括评估为 -1 的布尔值。

此外，a有可能是一个BOOL数组而不是bool。 BOOL可以typedef或#define d作为int。

更新： 由于OP认为数组是bool类型并且绝对没有溢出的可能性(让我假装一段时间我相信他(，那么我应该注意，如果一个程序包含一个导致未定义行为的构造，那么整个程序的行为是未定义的， 甚至在到达表现出未定义行为的构造之前。因此，即使a数组始终正确索引，但其他一些不相关的数组没有，那么您仍然有可能在a中得到垃圾。永远不要期望在具有未定义行为的程序中具有任何类型的一致性。

我猜有时index或"*it"中的一个实际上并不在范围内。布尔值的存储方式取决于实现，但是如果你从数组的末尾运行，那么很有可能返回 0 或 1 以外的值。

顺便说一下，如果 a 是布尔数组，将 a[*it] 与 1 进行比较并不是一件好事。 它应该这样测试：

   if (a[*it] && something)

您正在强制将强制转换从布尔值转换为整数，这在这种情况下是不必要的。我会简单地使用逻辑运算符来实现相同的代码。

无论如何，回答你的问题，这可能是真的。

int main(){
    bool a = -1;
    printf("a = %dn", a);
    return 0;
}

这将打印出"a = 1"。

相关文章：