Перегрузка оператора индексации []

#include<iostream>
 
class ExlandClass
{
/*
Этот великолепный класс имеет в себе указатель на масив и размер масива.
Так же реализоват доступ к элементу масива по индексу, причём проверка
на выход за границы масива не осуществляется потому что это не круто.
    */
    double* m;
    unsigned size;
public:
    ExlandClass(int Size) : size(Size){m = new double [size];}
    ~ExlandClass(){delete[] m;}
 
    /*чтобы к полученному элементу обеспечить доступ на запись
    + не гонять лишние fizeof(double) - sizeof(double&) байта мы высылаем ссылочку*/
    double& operator [] (unsigned i) { return m[i]; }
 
};
 
int main()
{
    ExlandClass m(5);
    m[3] = 5;
    std::cout << m[3] << '\n';
 
    return !true && !false;
}

unsigned TBitFields::operator [](Cmystring ind)
{
    return this->GetField(ind);
}

#include <iostream>
 
class StrangeClass
{
 
    /*задача оказалась для меня сложна но, тем не менее, я её решил. В прочем, решение малопроизводительное.
    Суть в следующем: в с++ мнимальный передаваемый объём - байт. следовательно, мы никак не уйдём от
    передачи целого байта при взаимодействии со встроенными типами. т.е. мы получаем байт и куда-то его пишем.
    Чтобы корректно обработать получаемую информацию как нужно мы вынуждены высылать не просто ссылку на какую-то
    память понимаемую как встроенный тип а сущность работающую в соответствии с нашей формой хранения данных.
    роль такой сущности играет bufer. для обработки информации ему нужна ссылка на байт памети с которым ведётся работа
    и номер сигмента с которым ведётся работа. Уверен, вам не трудно будет приспособить систему для контекста вашей задачи.
    Греет душу то что задача, явно, учебная. если же такое нужно на практике то верный выбор - отказатся от таких 
    красивых оформлений*/
    char fuckedByte;
public:
    struct Bufer
    {
        unsigned i;
        char* byte;
        Bufer(char* Byte): byte(Byte), i (0) {   }
 
        void operator = (char e)
        {
            switch(i)
            {
            case 0:
                *byte -= *byte / ( 2 * 2 * 2 * 2 * 2 ) * 2 * 2 * 2 * 2 * 2;//очистили байты)))
                *byte += e % ( 2 * 2 * 2 ) * 2 * 2 * 2 * 2 * 2;
                break;
            case 1:
                *byte -= *byte / ( 2 * 2 ) % ( 2 * 2 * 2 ) * 2 * 2;
                *byte += e % ( 2 * 2 * 2 ) * 2 * 2;
                break;
            case 2:
                *byte -= *byte % ( 2 * 2 );
                *byte += e % ( 2 * 2 );
            }
        }
        operator char()
        {
            switch(i)
            {
            case 0:
                return *byte / 2 / 2 / 2 / 2 / 2;
            case 1:
                return *byte / 2 / 2 % ( 2 * 2 * 2);
            case 2:
                return *byte % ( 2 * 2);
            }
            return !true && !false;
        }
 
    };
    Bufer bufer;
 
    StrangeClass(char init1, char init2, char init3):
        bufer(&fuckedByte)
    {
        /*скажем, из инициализирующих трёх майтов нас интирересуют последние
        три байта первых двух и два третьего, как в вашем примере.
        И да помилует меня асемпблер за медленность и тупорылось алгоритмов, уверен, у вас там что-то по разумнее.*/
        fuckedByte = init1 % ( 2 * 2 * 2 ) * 2 * 2 * 2 * 2 * 2;//вроде бы так я возьму три последних бита и запишу в три первых.
        fuckedByte += init2 % ( 2 * 2 * 2 ) * 2 * 2;
        fuckedByte += init3 % ( 2 * 2 );//я не перемножаю двойки не для того чтобы это делал кто-то другой а чтобы явно видеть - сколько двоек - столько байтов.
    }
 
    Bufer& operator [] (unsigned i)
    {
        bufer.i = i;
        return bufer;
    }
};
 
int main (void)
{
    StrangeClass a(3, 9, 2);
 
    std::cout << static_cast<int>(a[0]) << ' ' << static_cast<int>(a[1]) << ' ' << static_cast<int>(a[2]) << std::endl; 
 
    a[0] = 10;
 
    std::cout << static_cast<int>(a[0]) << ' ' << static_cast<int>(a[1]) << ' ' << static_cast<int>(a[2]) << std::endl;
 
    return !true && !false;
}