0

我正在尝试编写一个返回 1 和 0 而不是真或假的代码。但这似乎不对。

int Short_Vector::operator==(const Short_Vector& obj){
    if(a == obj.a && b == obj.b && c == obj.c && d == obj.d){
        return 1;
    }else{
        return 0;
    }
 }

所以它应该为每个变量返回一个值。

我也试过这个：

int Short_Vector::operator==(const Short_Vector& obj){
    int a_tf, b_tf, c_tf, d_tf;
    if(a == obj.a){
        a_tf = 1;
    }else{
        a_tf = 0;
    }
    if(b == obj.b){
        b_tf = 1;
    }else{
        b_tf = 0;
    }
    if(c == obj.c){
        c_tf = 1;
    }else{
       c_tf = 0;
    }
    if(d == obj.d){
       d_tf = 1;
    }else{
        d_tf = 0;
    }
    return(a_tf, b_tf, c_tf, d_tf)
}

但是我收到一个关于逗号是运算符的错误。

编辑

得到错误：错误：从'int'转换为非标量类型'Short_Vector。

我试图表示一个看起来像这样 [9,1,5,5] 的向量。

那我就说

`Short_Vector a(2, 6, 9, 4);

Short_Vector b(3, 8, 7, 6);

Short_Vector c = a == b;

cout<<c;`

输出是：[0,0,0,0]

4

5 回答 5

3

您可以使用std::bitset为每个成员的平等设置一点

std::bitset<4> Short_Vector::operator==(const Short_Vector& obj){
    std::bitset<4> r;

    r[0] = (a == obj.a);
    r[1] = (b == obj.b);
    r[2] = (c == obj.c);
    r[3] = (d == obj.d);

    return r;
}

你可以像这样使用它

Short_Vector a(1,2,3,4);
Short_Vector b(1,0,3,4);

std::bitset<4> res = (a==b);
std::cout << res;

应该给你

1011

std::bitset很好，因为它提供了方便的方法，例如all any和none（以及更多）。这样您就可以轻松检查汇总值。

于 2013-05-09T19:27:47.293 回答
3

第二种方法不起作用，因为返回类型是 'int' 并且 '(a_tf, b_tf, c_tf, d_tf)' 不是 int 而是用逗号分隔的 4 个 int。

由于您想返回 4 个布尔值，您可以执行以下操作：

int Short_Vector::operator==(const Short_Vector& obj)
{
    //...
    return (a_tf) | (b_tf << 1) | (c_tf << 2) | (d_tf << 3);
}

//the caller would do the follwoing:

int result = (MyObject1 == MyObject2);

if(result & (1 << 1) //b_tf is set to 1;
{
}
if(result & (1 << 3) //d_tf is set to 1;
{
}
于 2013-05-09T19:37:29.067 回答
2

如果您想将结果设为Short_Vector，请尝试以下操作：

Short_Vector Short_Vector::operator==(const Short_Vector& obj) {
    return Short_Vector(
        a == obj.a,
        b == obj.b,
        c == obj.c,
        d == obj.d
    );
}
于 2013-05-09T19:36:40.460 回答
1

逗号运算符不会按照您假设的方式工作。它实际上将评估其每个操作数并返回最后一个。编译器就这个小误解给了你一个警告。

一种替代方法是设置包含布尔表达式的数字true/等效的每个位：false

unsigned int n = 0;

n |= (a == obj.a) << 0;
n |= (b == obj.b) << 1;
n |= (c == obj.c) << 2;
n |= (d == obj.d) << 3;

return n;

您可以使用较小的数据类型，例如char，也可以使用std::bitset.

于 2013-05-09T19:26:25.873 回答
1

如果必须使用 int 作为返回类型，则可以使用左移运算符并执行以下操作：

int result = 0;
result += a_tf << 3; //Shifts the bit 3 places to the left.
result += b_tf << 2; //Shifts the bit 2 places to the left.
result += c_tf << 1; //Shifts the bit 1 place to the left.
result += d_tf; //Puts d_tf as bit 0
return result;

并让每个人退出使用逐位和：

result = obj1 == obj2; //Where obj1 and 2 are your compared objects
int a_tf = (result >> 3) & 1;
int b_tf = (result >> 2) & 1;
int c_tf = (result >> 1) & 1;
int d_tf = result & 1;

虽然我不得不说 Named 的使用 bitset 的解决方案更容易理解，并且这样插入/检索单个值要容易得多。

于 2013-05-09T19:35:35.340 回答