C++ 布尔向量上的数学加法运算

因此，我创建了一个名为

myClass

的类，该类接受

int

并具有一个私有变量，该变量将

int

存储为二进制向量（即12是“1100”）。我想定义一个操作符，它将两个

myClass

变量相加为布尔向量（也称为逐位操作）

以下是我的代码：

class myClass {
public:
    myClass();
    myClass(int a);

    myClass& operator+(const myClass& value);

private:
    std::vector<bool> bit;
};

操作员定义：

myClass myClass::operator+(const myClass& rhs) {
    Integer c = // not sure what to do here
    return c;
}

---

让我困惑的是，它必须接受一个整数，但随后运算符对布尔向量进行运算。

您需要定义一种进出整数表示的方法。这里有一个大致的想法：

#include <vector>
#include <iostream>

class myClass {
private:
    void setInt(int x) {
        bit.clear();
        while (x) {
            if (x & 1)
                bit.push_back(1);
            else
                bit.push_back(0);
            x>>=1;  
        }
        reverse(bit.begin(), bit.end());
    }
public:
    int toInt() const {
        int i = 0;
        for (size_t b = 0; b < bit.size(); b++) {
            if (bit[bit.size() - 1 - b])
                i |= 1<<b;
        }

        return i;
    }

    myClass(int a) {
        setInt(a);
    }

    myClass& operator+(const myClass& value) {
        setInt(toInt() + value.toInt());
        return *this;
    }

private:
    std::vector<bool> bit;
};

int main() {
    myClass c(10);
    myClass d(20);
    std::cout << "c=" << c.toInt() << "\n";
    std::cout << "d=" << d.toInt() << "\n";
    std::cout << "Sum=" << (c + d).toInt() << "\n";
}

#包括
#包括
类myClass{
私人：
void setInt（intx）{
位清除（）；
while（x）{
如果（x&1）
位推回（1）；
其他的
位推回（0）；
x> >=1；
}
反向（bit.begin（），bit.end（））；
}
公众：
int toInt（）常量{
int i=0；
对于（size_t b=0；bi |=1您需要定义一种进出整数表示的方法。这里有一个大致的想法：

#include <vector>
#include <iostream>

class myClass {
private:
    void setInt(int x) {
        bit.clear();
        while (x) {
            if (x & 1)
                bit.push_back(1);
            else
                bit.push_back(0);
            x>>=1;  
        }
        reverse(bit.begin(), bit.end());
    }
public:
    int toInt() const {
        int i = 0;
        for (size_t b = 0; b < bit.size(); b++) {
            if (bit[bit.size() - 1 - b])
                i |= 1<<b;
        }

        return i;
    }

    myClass(int a) {
        setInt(a);
    }

    myClass& operator+(const myClass& value) {
        setInt(toInt() + value.toInt());
        return *this;
    }

private:
    std::vector<bool> bit;
};

int main() {
    myClass c(10);
    myClass d(20);
    std::cout << "c=" << c.toInt() << "\n";
    std::cout << "d=" << d.toInt() << "\n";
    std::cout << "Sum=" << (c + d).toInt() << "\n";
}

#包括
#包括
类myClass{
私人：
void setInt（intx）{
位清除（）；
while（x）{
如果（x&1）
位推回（1）；
其他的
位推回（0）；
x> >=1；
}
反向（bit.begin（），bit.end（））；
}
公众：
int toInt（）常量{
int i=0；
对于（size_t b=0；bi |=1很明显，你需要像在纸上加普通数一样做。从最低有效位开始，把它们加在一起。如果结果溢出（例如二进制1+1=10），那么记住溢出，用于下一次迭代

我强烈建议您首先创建构造函数，为您的类使用bool数组：

myClass(std::vector<bool> bits);

很明显，你需要做和在纸上加普通数字一样的事情。从最低有效位开始，把它们加在一起。如果结果溢出（例如二进制1+1=10），那么记住溢出，用于下一次迭代

我强烈建议您首先创建构造函数，为您的类使用bool数组：

myClass(std::vector<bool> bits);

由于
a
和
b
都声明为
Integer
，因此此行将调用
operator+（const Integer&x，const Integer&y）
或
Integer:：operator+（const Integer&x）
。它将调用
myClass:：operator+（const myClass&rhs）的唯一方法是
是如果您有一个转换构造函数
myClass:：myClass（const Integer&i）

由于
a
和
b
都声明为
Integer
，因此此行将调用
operator+（const Integer&x，const Integer&y）
或
Integer:：operator+（const Integer&x）
。它将调用
myClass:：operator+（const myClass&rhs）的唯一方法是
是一个转换构造函数
myClass:：myClass（const Integer&i）
只有当其中一个操作数属于其类时才会调用
myclass
的
运算符+
。目前，两个操作数的类型都是
Integer
，因此无法调用任何
myclass
运算符。一种解决方案是强制转换（或生成）一个操作数来键入
myclass
什么是
Integer
？为什么必须使用它？
myclass c=a+b；
此行使用
运算符+（）
整数
类的
函数，而不是
MyClass
的函数。
MyClass
的
运算符+
仅在其中一个操作数属于其类时才会被调用。目前，两个操作数的类型都是
整数
，因此无法调用任何
MyClass
运算符。一种解决方案是强制转换（或制作）一个操作数来键入
myclass
什么是
Integer
？为什么必须使用它？
myclass c=a+b；
这一行对
Integer
类使用
运算符+（）
函数，而不是
myclass
函数。
myClass myClass::operator+(const myClass& rhs) {
    myClass result(add_vectors(bit, rhs.bit));
    return result;
}

`myClass c = a+b;`