C++ 有条件地测试向量的相等性'；s元素

虽然看起来很简单，但我不确定哪种方法最有效

我有两个向量：

std::vector<bool> a;
std::vector<int> b;

如果

a

中的值相等，此函数返回

true

。但是，它只考虑与

b

中的

true

值相对应的

a

中的值

我可以这样做：

bool test(std::vector<int> a, std::vector<bool> b){
    int x;
    unsigned int i;
    for(i = 0; i < a.size(); ++i){
        if(b.at(i) == true){
            x = a.at(i);
            break;
        }
    }
    for(i = 0; i < a.size(); ++i){
        if(b.at(i) == true){
            if(a.at(i) != x){
                return false;
            }
        }
    }
    return true;
}

布尔测试（标准：：向量a，标准：：向量b）{ int x； 无符号整数i； 对于（i=0；i

---

但是我必须创建两个循环。尽管第一个循环将在第一个真值处停止，但有更好的方法吗？

如果您知道a.size（）==b.size（）只需创建一个循环，在每次迭代的同时将“a”元素与“b”元素进行比较。一旦你看到a[i]！=b[i]那么你知道容器不匹配，你可以打破它。

如果你知道a.size（）==b.size（）只需创建一个循环，在每次迭代的同时将“a”元素与“b”元素进行比较。一旦你看到a[i]！=b[i]那么你知道容器不匹配，你可以突破。

如果你记得是否在

b

中看到了第一个

true

元素，你可以在一个循环中完成。此外，还应参考

a

和

b

参数，以避免不必要的复制。最后，如果您知道向量中的索引始终在有效范围内（即0和vector.size（）-1之间，包括0和vector.size（）-1），则可以使用

运算符[]

而不是

at

，并获得更好的性能（

at

进行范围检查，而

运算符[]

不进行范围检查）。以下是您的

测试

函数的修改版本，考虑了上述所有要点：

bool test(std::vector<int> const& a, std::vector<bool> const& b){
    int x;
    bool first = true;
    for(unsigned i = 0, n = a.size(); i != n; ++i){
        if( b[i] ){
            if( first ) {
                x = a[i];
                first = false;
            }
            else if( x != a[i] ) {
                return false;
            }
        }
    }
   return true;
}

bool测试（std:：vector const&a，std:：vector const&b）{
int x；
bool first=true；
for（无符号i=0，n=a.size（）；i！=n；++i）{
if（b[i]）{
如果（第一）{
x=a[i]；
第一个=假；
}
如果（x！=a[i]）{
返回false；
}
}
}
返回true；
}

如果您记得是否在

b

中看到了第一个

true

元素，则可以在一个循环中完成。此外，还应参考

a

和

b

参数，以避免不必要的复制。最后，如果您知道向量中的索引始终在有效范围内（即0和vector.size（）-1之间，包括0和vector.size（）-1），则可以使用

运算符[]

而不是

at

，并获得更好的性能（

at

进行范围检查，而

运算符[]

不进行范围检查）。以下是您的

测试

函数的修改版本，考虑了上述所有要点：

bool test(std::vector<int> const& a, std::vector<bool> const& b){
    int x;
    bool first = true;
    for(unsigned i = 0, n = a.size(); i != n; ++i){
        if( b[i] ){
            if( first ) {
                x = a[i];
                first = false;
            }
            else if( x != a[i] ) {
                return false;
            }
        }
    }
   return true;
}

bool测试（std:：vector const&a，std:：vector const&b）{
int x；
bool first=true；
for（无符号i=0，n=a.size（）；i！=n；++i）{
if（b[i]）{
如果（第一）{
x=a[i]；
第一个=假；
}
如果（x！=a[i]）{
返回false；
}
}
}
返回true；
}

我不是100%确定我知道你想要做什么，而是在你知道你的尺寸相等后进行直接比较

std::equal(a.begin(), a.end(), b.begin(), std::equal_to<bool>())

std:：equal（a.begin（）、a.end（）、b.begin（）、std:：equal_to（））

我不是100%确定我知道你想要做什么，而是在你知道你的尺寸相等后进行直接比较

std::equal(a.begin(), a.end(), b.begin(), std::equal_to<bool>())

std:：equal（a.begin（）、a.end（）、b.begin（）、std:：equal_to（））

我觉得您的解决方案足够好：

• 无论如何，每个循环都会做不同的事情（因此您不必担心重复）
• 不要使用使代码复杂化的额外变量或标志

我看到的唯一问题是：

• 第二个循环从0开始，而不是从停止的位置开始
• 如果（条件==true）执行

  是非常难看的。只要做
  if（条件）

---

布尔测试（标准：：向量a，标准：：向量b）{ int x； 未签名的i； 对于（i=0；i

---

}

您的解决方案在我看来已经足够好了：

• 无论如何，每个循环都会做不同的事情（因此您不必担心重复）
• 不要使用使代码复杂化的额外变量或标志

我看到的唯一问题是：

• 第二个循环从0开始，而不是从停止的位置开始
• 做

  if（条件==true）

  非常难看。只要做

  if（条件）

  就行了

---

布尔测试（标准：：向量a，标准：：向量b）{ int x； 未签名的i； 对于（i=0；i

---

}

我相信这不是他想做的我相信这不是他想做的我不是控制流布尔变量的忠实粉丝。看起来你这样做“在一个循环中”只是为了它。我不是控制流布尔变量的忠实粉丝。看起来你这样做“在一个循环中”只是为了它。