Где почитать про перегрузку поразрядных логических операций (|, &, ^)

 stream << static_cast<int>( obj.data[i] ) << " ";

friend Vector operator|(Vector& lhs, Vector& rhs)
    {
 
        int size1 = lhs.size_;//размеры массивов
        int size2 = rhs.size_;
 
        Vector result;
        if (size1 < size2)
        {
            lhs.Dopolnim(size2);
            result.size_ = size2;
        }
        else if (size2 < size1)
        {
            rhs.Dopolnim(size1);
            result.size_ = size1;
        }
        else result.size_ = size2;
        for (size_t i = 0; i<lhs.size_; ++i)
        {
            result.data[i] = ((lhs.data[i] - '0') | (rhs.data[i] - '0')) + '0';
        }
 
        return result;
    }

#include <iostream>
#include <cstring>
using namespace std;
class Vector
{
private:
    int size_;
    char *data;
public:
    Vector();
    Vector(const int, const int);
    Vector(const char*);
    Vector(const Vector &);
    ~Vector();
    int GetSize();
    void SetSize(int);
    void SetVector(int);
    void One();
    char& operator[](int i)
    {
        return data[i];
    }
 
    friend ostream& operator << (ostream &stream, Vector &obj)
    {
        for (int i = 0; i < obj.size_; i++)
            stream << static_cast<int>(obj.data[i]) << " ";
        stream << endl;
        return stream;
    }
 
    friend istream& operator >> (istream &stream, Vector &obj)
    {
        for (int i = 0; i < obj.size_; i++)
            stream >> obj.data[i];
        return stream;
    }
    void Dopolnim(int size)//дополнение нулями слева
    {
        int i;
        Vector tmp;
        for (i = 0; i < size - size_; i++)
        {
            tmp.data[i] = data[i];
            data[i] = '0';
        }
        for (i = size - size_; i < size; i++)
            data[i] = tmp.data[i - (size - size_)];
        size_ = i;                           
 
    }
    friend Vector operator|(Vector& lhs, Vector& rhs) 
    {
 
        int size1 = lhs.size_;
        int size2 = rhs.size_;
 
        Vector result;
        if (size1 < size2)
        {
            lhs.Dopolnim(size2);
            result.size_ = size2;
        }
        else if (size2 < size1)
        {
            rhs.Dopolnim(size1);
            result.size_ = size1;
        }
        else result.size_ = size2;
        for (int i = 0; i<lhs.size_; ++i)
        {
            result.data[i] = ((lhs.data[i] - '0') | (rhs.data[i] - '0')) + '0';
        }
 
        return result;
    }
 
    friend Vector operator&(Vector& lhs, Vector& rhs)
    {
 
        int size1 = lhs.size_;
        int size2 = rhs.size_;
 
        Vector result;
        if (size1 < size2)
        {
            lhs.Dopolnim(size2);
            result.size_ = size2;
        }
        else if (size2 < size1)
        {
            rhs.Dopolnim(size1);
            result.size_ = size1;
        }
        for (int i = 0; i<lhs.size_; ++i)
        {
            result.data[i] = lhs.data[i] & rhs.data[i];
        }
        return result;
    }
 
    friend Vector operator~(Vector& lhs)
    {
 
        int size1 = lhs.size_;
 
        Vector result;
        result.size_ = lhs.size_;
        for (int i = 0; i<lhs.size_; ++i)
        {
            
            if (lhs.data[i] == '1') result.data[i] = '0';
            else result.data[i] = '1';
        }
        return result;
    }
 
    friend Vector operator^(Vector& lhs, Vector& rhs)
    {
 
 
        int size1 = lhs.size_;
        int size2 = rhs.size_;
 
        Vector result;
        if (size1 < size2)
        {
            lhs.Dopolnim(size2);
            result.size_ = size2;
        }
        else if (size2 < size1)
        {
            rhs.Dopolnim(size1);
            result.size_ = size1;
        }
        for (int i = 0; i<lhs.size_; ++i)
            result.data[i] = lhs.data[i] ^ rhs.data[i];
        return result;
    }
 
};
Vector::Vector()
{
    data = new char[10];
    size_ = 10;
    for (int i = 0; i < size_; i++)
    {
        data[i] = 0;
    }
}
Vector::Vector(const Vector &arrayToCopy) //КК
    :size_(arrayToCopy.size_)            
{
    data = new char[size_]; 
 
    for (int i = 0; i < size_; i++)
        data[i] = arrayToCopy.data[i];
}
 
Vector::Vector(const int value, const int size)
{
    data = new char[size];
    size_ = size;
    for (int i = 0; i < size; i++)
        data[i] = (char)value;
}
Vector::Vector(const char* value)//Є®*бвагЄв®а
{
    size_ = strlen(value);
    data = new char[size_];
    for (int i = 0; i < size_; i++)
        data[i] = value[i];
}
 
Vector::~Vector() //
{
    delete[] data;
}
void Vector::SetSize(int size)
{
    size_ = size;
    data = new char[size];
}
void Vector::SetVector(int size)
{
    delete[] data;
    data = new char[size];
    size_ = size;
}
int Vector::GetSize()
{
    return size_;
}
 
void Vector::One()
{
    int i, k, j;
    for (i = 0; i<size_; i++)
    {
        if (data[i] == '0')
            continue;
        else
            break;
    }
    for (j = size_ - 1; j > i - 1; j--)
    {
        if (data[j] == '0')
            continue;
        else break;
    }
    for (k = i; k <= j; k++)
        cout << data[k] << " ";
    cout << endl;
}
int main()
{
    int n = 100;
    Vector a, b, c, d, e;
    while (n != 0)
    {
        cout << "----------MainMenu-----------" << endl;
        cout << "1. Ввести массивы*. " << endl;
        cout << "2. Вывести массивы*." << endl;
        cout << "3. Операция |" << endl;
        cout << "4. Операция &" << endl;
        cout << "5. Операция ^" << endl;
        cout << "6.Операция ~" << endl;
        cout << "7. Выделение массива начинающегося и зак. еденицами." << endl;
        cout << "0. Выход" << endl;
        cin >> n;
        system("cls");
        switch (n)
        {
        case 1:
        {
            int N;
            cout << "Введите размер массива * A: ";
            cin >> N;
            a.SetSize(N);
            cout << "Введите массив A" << endl;
            for (int i = 0; i < N; i++)
            {
                cout << "Введите А" << i << endl;
                cin >> a[i];
            }
            cout << "‚ўҐ¤ЁвҐ а*§¬Ґа ўҐЄв®а* B: ";
            cin >> N;
            b.SetSize(N);
            cout << "Введите размер массива B" << endl;
            for (int i = 0; i < N; i++)
            {
                cout << "Введите B" << i << endl;
                cin >> b[i];
            }
            system("pause");
            break;
        }
        case 2:
        {
            cout << "Массив A: " << endl;
            for (int i = 0; i < a.GetSize(); i++)
            {
                cout << a[i] << " ";
            }
            cout << endl;
            cout << "Массив B: " << endl;
            for (int i = 0; i < b.GetSize(); i++)
            {
                cout << b[i] << " ";
            }
            cout << endl;
            system("pause");
            break;
        }
        case 3:
        {
            c = a | b;
            cout << "Вектор A|B: " << endl;
            for (int i = 0; i <c.GetSize(); i++)
            {
                cout <<c[i] << " ";
            }
            cout << endl;
            system("pause"); 
 
            break;
        }
        case 4:
        {
            c = a ^ b;
            cout << "Вектор A^B: " << endl;
            for (int i = 0; i <c.GetSize(); i++)
            {
                cout << (int)c[i] << " ";
            }
            cout << endl;
            system("pause");
            break;
        }
        case 5:
        {
            c = a & b;
            cout << "Вектор A&B: " << endl;
            for (int i = 0; i <c.GetSize(); i++)
            {
                cout << c[i] << " ";
            }
            cout << endl;
            system("pause");
            break;
        }
        case 6:
        {
            c = ~a;
            d = ~b;
            cout << "Вектор ~A: " << endl;
            for (int i = 0; i <c.GetSize(); i++)
            {
                cout << c[i] << " ";
            }
            cout << endl;
            cout << "Вектор ~B: " << endl;
            for (int i = 0; i <d.GetSize(); i++)
            {
                cout << d[i] << " ";
            }
            cout << endl;
            system("pause");
            break;
        }
        case 7:
        {
            a.One();
            cout << endl;
            system("pause");
            break;
        }
        case 0: break;
        default:{cout << "Неверный пункт!" << endl; break; }
        }
    }
}

    Vector & operator = (const Vector & rhs) 
    {
        delete[] data;
        size_ = rhs.size_;
        data = new char[size_];
        for (int i = 0; i < size_; i++) data[i] = rhs.data[i];
        return *this;
    }