Question

所以我创建了一个名为myClass的类，它接收int并且有一个私有变量，它将int存储为二进制的向量（即12是'1100'）。我想定义一个运算符，它将两个myClass变量一起作为bool的向量（也称为逐位运算）。

这是我的代码：

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

    myClass& operator+(const myClass& value);

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

我想在主函数中使用它：

int main() {
    std::cin >> value;
    Integer a = value;
    std::cin >> value;
    Integer b = value;
    myClass c = a+b;

    return 0;
}

运营商定义：

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

令我困惑的部分是它必须接受一个整数，然后操作符对bool向量进行操作。

Answer 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";
}

Answer 2

显然你需要像在纸上添加普通数字一样。从最低有效位开始，并将它们一起添加。如果结果溢出（例如二进制1 + 1 = 10），则记住下一次迭代的溢出。

我强烈建议您首先创建一个为您的类创建bool数组的构造函数：

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

我们将在实施中使用它。现在你想要的是添加bools列表。我创建了一个不关心列表有多大的实现。如果你想用大整数计算，这将是很方便的：

#include <vector>

bool add_bools(const bool A, const bool B) {
    return !(A && B) && (A || B);
}
/** Loops over vectors and adds the booleans in them
    the booleans are considered to be in little endian order
    so that the least significant is first in the array. **/
std::vector<bool> add_vectors(const std::vector<bool>& first,
                              const std::vector<bool>& second) {

    std::vector<bool> result;
    // Remembers that previous addition produced false when
    // we add true+true
    bool overflow = false;
    const int bits = first.size()>second.size()?first.size():second.size();
    for (int i = 0; i < bits || overflow; ++i) {
        bool bitA, bitB;
        bitA = i<first.size() ? first[i]:false;
        bitB = i<second.size() ? second[i]:false;
        bool tmp_result = add_bools(bitA, bitB);
        // remember to add overflow from previous iteration
        result.push_back(add_bools(tmp_result, overflow));
        // remember overflow for next iteration
        overflow = (bitA&&bitB) || (overflow && tmp_result);
    }
    return result;
}
#include <iostream>
void test_add_vectors() {
    std::vector<bool> first;
    std::vector<bool> second;
    const int bits = 5;
    for (int i = 0, l = bits; i < l; ++i) {
        first.push_back(false);
        second.push_back(true);
    }
    first[0] = true;

    std::vector<bool> result = add_vectors(first, second);
    for (int i = 0, l = result.size(); i < l; ++i) {
        std::cout<< (result[i]?'1':'0')<<" ";
    }
}

您可以使用这样的实现，使用带有bool数组的构造函数：

myClass myClass::operator+(const myClass& rhs) {
    myClass result(add_vectors(bit, rhs.bit));
    return result;
}

Answer 3

`myClass c = a+b;`

由于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)的唯一方法就是。

数学ADD操作在bools矢量

3 个答案: