Question

我正在尝试创建一个表示布尔数组的BoolArray类，而不是每个bool变量保存1个布尔值。它使用1个char变量来表示使用位的8个布尔值，并节省内存。我想使用operator []来使它像普通数组一样方便。

我可以使用arr [5]并返回第五位的bool值。我的问题是分配一点。我不能引用一位，所以我需要创建一个执行该任务的函数。我的问题是，是否可以使用运算符重载来控制数组样式赋值。我的解决方案是使用另一个类（MyBoolean）并将其作为BoolArray运算符[]的引用返回。 MyBoolean重载operator =并更改BoolArray的位。是否有一种更简单的方法可以重载运算符[] =或类似的东西？

#include <iostream>
#include <tgmath.h>
using namespace std;



string int_to_binary_string(int number)
{
    if ( number == 0 ) return "0";
    if ( number == 1 ) return "1";

    if ( number % 2 == 0 )
        return int_to_binary_string(number / 2) + "0";
    else
        return int_to_binary_string(number / 2) + "1";
}




class MyBoolean;
class BoolArray {

    private:
        unsigned char* arr;
        int size;


        void setBit(int bit_number,bool value);

    public:
        explicit BoolArray(int size);       
        ~BoolArray();
        MyBoolean operator[](unsigned int index);
        int getSize() const;

        friend class MyBoolean;
};



// ***************************** MyBoolean *********************************
class MyBoolean {

    private:
        bool value;
        int bit_number;
        BoolArray* bool_array;

    public:
        // --- Constructor ---
        MyBoolean(bool value,int bit_number,BoolArray* bool_array) :
            value(value),bit_number(bit_number),bool_array(bool_array)
        {}


        // --- cast ---
        operator bool() const{
            return value;
        }

        MyBoolean& operator=(bool new_value) {
            value = new_value;
            bool_array->setBit(bit_number,new_value);
        }
};



// ***************************** BoolArray *****************************
    void BoolArray::setBit(int bit_number,bool value) {
            int index = floor((double)bit_number/8);
            bit_number -= index*8;

            cout << "trying to set " << bit_number << " to " << value << endl;

            if(value==true) {
                int binary_num = pow(2,bit_number);
                cout << "arr[index]: " << int_to_binary_string(arr[index]) << " - binary_num: " << int_to_binary_string(binary_num);
                arr[index] = arr[index] | binary_num; 
                cout << " - after: " << int_to_binary_string(arr[index]) << endl;
            }
            else {
                int binary_num = 0 | 255;
                int binary_num_2 = pow(2,bit_number);
                binary_num = binary_num^binary_num_2;
                arr[index] = arr[index] & binary_num;
            }
    }


    // --- Constructor ---
    BoolArray::BoolArray(int size) :
        size(size)
    {
        size = ceil((double)size/8);
        arr = new unsigned char[size];
    }


    // --- Destructor ---
    BoolArray::~BoolArray() {
        delete[] arr;
    }


    // --- operator[] ---
    MyBoolean BoolArray::operator[](unsigned int index) {
        if(index>size-1)
            throw "error";

        int arr_index = floor((double)index/8);
        int bit_number = index - arr_index*8;
        unsigned int binary_num = pow(2,bit_number);
        int value= false;
        if((arr[arr_index] & binary_num)>0)
            value = true;

        MyBoolean my_bool(value,index,this);

        return my_bool;
    }


    // --- size ---
    int BoolArray::getSize() const {
        return size;
    }



ostream& operator<<(ostream& os, MyBoolean b) {
    os << (bool) b;
    return os;
}

ostream& operator<<(ostream& os,BoolArray& arr) {
    for(int i=0;i<arr.getSize();i++)
        os << arr[i] << "->";
    return os;
}


int main() {
    BoolArray arr(12);
    arr[0] = true;
    arr[1] = false;
    arr[2] = true;
    arr[3] = false;
    arr[4] = true;
    arr[5] = false;
    arr[6] = true;
    arr[7] = false; 
    arr[8] = true;
    arr[9] = false;
    arr[10] = true;
    arr[11] = false;    
    cout << arr;
    return 0;
}

Answer 1

你已经拥有了基本上最好的解决方案：创建一个可以从bool分配的代理类，但内部只分配1位，并且可以隐式转换为bool。 BoolArray将从operator[]返回此代理类。

事实上，这是vector<bool>对vector<bool>::reference所做的事情。正如评论者所说，std::vector专门用于bool来完成您正在编写的内容。因此，除非这只是为了学习，否则你所写的内容是无用的/多余的。

Answer 2

正如评论者建议的那样，请使用std::bitset。 不重新发明轮子。

但是如果你想做一个练习，并实现一个bitset，答案是 NO 。

事实上，implementation of std::bitset正是你所做的：使用存储该值的值和位置的代理类。

请结帐行 00760 （代理类声明）和 01138 （非const运算符[]的声明和实现）。

Answer 3

像你一样使用代理对象，基本上是正确的做法。但是：你永远不应该使用浮点运算来进行整数运算（它们不精确，有时精度不高）：

// Don't do this:
int index = floor((double)bit_number/8);
// But this:
int index = bitnumber/8;

整数除法将一直向零舍入，不需要使用floor(x)。

// Don't do this:
int binary_num = pow(2,bit_number);
// But this:
int binary_num = 1 << bit_number;

除了在舍入到整数后可能给出错误的结果之外，pow(a,b)比使用位移运算符要慢得多。

是否可以控制[]运算符和运算符=？

3 个答案: