Интересная задачка с битовыми операторами, флагами, переменными, или "до меня не дошло письмо из штаба"

//Переключатель двух атрибутов файла, значения которых сохраняются в одной переменной.
 
#include<iostream>
 
using std::cout;
using std::cin;
using std::endl;
 
 
int attributes = 0;     //Переменная хранения всех флагов
bool txt_bin = 0;       //Флаги атрибутов файла
bool rd_wr = 0;
 
 
bool txt_bin_uncr = 0;       //Флаги атрибутов файла при декодировании
bool rd_wr_uncr= 0;
 
 
int main()
{
    setlocale(LC_ALL, "rus");
    //Блок кодировки атрибутов в одну переменную
    {
        cout << "Введите кодировку файла (0 - если двоичный, 1 - если текстовой): ";   //Ввод флагов
        cin  >> txt_bin;
        cout << "Введите режим чтения\\записи (0 - если чтение, 1 - если запись): ";
        cin  >> rd_wr;
 
        attributes = txt_bin | (rd_wr << 1); //Их слияние в одной переменной
 
        cout << "Запись данных успешно произведена!";
        cout << endl;
    }
 
 
 
    //Блок расшифровки
    {
    if ((attributes >> 1) == 1)
    {
        rd_wr_uncr = attributes ^ 2;  //Отсеиваем передний ненужный флаг при помощи исключающего или, если он == 1
    }
    else
    {
        rd_wr_uncr = attributes; //Или же присваиваем текущее значение, если крайний флаг == 0. (Что тоже верно)
    }
    txt_bin_uncr = attributes >> 1; //Значение крайнего флага получаем при помощи битового смещения и "съедания" первого флага
 
    cout << "Вы установили следующие флаги: "
         << ((txt_bin_uncr == 1)?(" текстовой тип данных (1), "):(" бинарный тип данных (0), "))
         << ((rd_wr_uncr == 1)?(" режим записи (1), "):(" режим чтения (0), "));
    cout << endl;
   system("pause");
    return 0;
}

const int open_txt = 1;
const int open_bin = 2;
 
const int open_read = 4;
const int open_write = 8;

#pragma once
 
namespace tools
{
    template<class ENUMERATION_TYPE, class INTEGRAL_TYPE = int>
    class TFlag
    {
    public:
        typedef ENUMERATION_TYPE ENUMERATION;
        typedef INTEGRAL_TYPE INTEGRAL;
 
        explicit TFlag(const INTEGRAL startFlag = 0 );
        explicit TFlag(const ENUMERATION startFlag);
        explicit TFlag(const bool, const ENUMERATION startFlag);
        explicit TFlag(const bool, const INTEGRAL startFlag);
 
        ~TFlag();
        
        static const TFlag& CastFrom(const INTEGRAL& src);
        static TFlag& CastFrom(INTEGRAL& src);
        static const ENUMERATION& Cast(const INTEGRAL& src);
        static ENUMERATION& Cast(INTEGRAL& src);
        static const INTEGRAL& Cast(const ENUMERATION& src);
        static INTEGRAL& Cast(ENUMERATION& src);
 
        bool Empty()const { return Cast(mFlags)==0; }
        void Clear() { Cast(mFlags)=0; } 
 
        const ENUMERATION& GetByEnumeration()const  { return mFlags;  } 
        ENUMERATION& GetByEnumeration()             { return mFlags;  } 
 
        const INTEGRAL& GetByIntegral()const  { return Cast(mFlags);  } 
        INTEGRAL& GetByIntegral()             { return Cast(mFlags);  } 
 
        //true, если все указанные флаги включены: флаг1|флаг2|флаг3
        bool Has(const ENUMERATION flag)const { return (Cast(flag) & Cast(mFlags)) == Cast(flag); } 
        bool Has(const INTEGRAL flag)const    { return (flag & Cast(mFlags)) == flag; } 
 
        //true, если хотя бы один из указанных флагов включен: флаг1|флаг2|флаг3
        bool HasAny(const ENUMERATION flag)const { return (Cast(flag) & Cast(mFlags)) != 0; } 
        bool HasAny(const INTEGRAL flag)const    { return (flag & Cast(mFlags)) != 0; } 
 
        //true, если this содержит флаги идентичные указанным
        bool HasOnly(const ENUMERATION flag)const { return operator==(TFlag(flag)); }
        bool HasOnly(const INTEGRAL flag)const    { return operator==(TFlag(flag)); }
 
 
        //если success true, тогда добавит флаги: флаг1|флаг2|флаг3
        void Add(const bool success, const ENUMERATION flag);
        void Add(const bool success, const INTEGRAL flag);
 
        //добавит флаги: флаг1|флаг2|флаг3
        void Add(const ENUMERATION flag)  { Cast(mFlags) |= flag; } 
        void Add(const INTEGRAL flag)     { Cast(mFlags) |= flag; } 
 
        //удалит флаги: флаг1|флаг2|флаг3
        void Del(const ENUMERATION flag)  { Cast(mFlags) &= (~flag); } 
        void Del(const INTEGRAL flag)     { Cast(mFlags) &= (~flag); } 
 
        //сделать включенными только флаги: флаг1|флаг2|флаг3
        void Only(const ENUMERATION flag) { Cast(mFlags)=0; Add(flag); }
        void Only(const INTEGRAL flag)    { Cast(mFlags)=0; Add(flag); }
 
        //из включенных флагов оставит только указанные флаги: флаг1|флаг2|флаг3
        void ValidOnly(const ENUMERATION flag ){ Cast(mFlags) &= flag; } 
        void ValidOnly(const INTEGRAL flag )   { Cast(mFlags) &= flag; } 
 
        // true, если хотя бы один выставлен
        operator bool()const { return !Empty(); }
 
        //true, если флаги идентичны
        bool operator==(const TFlag flag)const { return mFlags==flag.mFlags; }
 
        //true, если флаги не идентичны
        bool operator!=(const TFlag flag)const { return mFlags!=flag.mFlags; }
    private:
        ENUMERATION mFlags;
    };
 
    template<class ENUMERATION, class INTEGRAL>
    TFlag<ENUMERATION, INTEGRAL>::TFlag(const INTEGRAL startFlag)
        :mFlags(Cast(startFlag))
    {}
 
    template<class ENUMERATION, class INTEGRAL>
    TFlag<ENUMERATION, INTEGRAL>::TFlag(const ENUMERATION startFlag)
        :mFlags(startFlag)
    {}
 
    template<class ENUMERATION, class INTEGRAL>
    TFlag<ENUMERATION, INTEGRAL>::TFlag(const bool is_true, const ENUMERATION startFlag)
        :mFlags( is_true? startFlag: ENUMERATION(0) )
    {}
 
    template<class ENUMERATION, class INTEGRAL>
    TFlag<ENUMERATION, INTEGRAL>::TFlag(const bool is_true, const INTEGRAL startFlag)
        :mFlags( is_true? Cast(startFlag): ENUMERATION(0) )
    {}
 
    template<class ENUMERATION, class INTEGRAL>
    TFlag<ENUMERATION, INTEGRAL>::~TFlag() 
    {}
 
    template<class ENUMERATION, class INTEGRAL>
    const TFlag<ENUMERATION, INTEGRAL>& TFlag<ENUMERATION, INTEGRAL>::CastFrom(const INTEGRAL& src)
    {
        return *(reinterpret_cast<const TFlag*>(&src)); 
    }
 
    template<class ENUMERATION, class INTEGRAL>
    TFlag<ENUMERATION, INTEGRAL>& TFlag<ENUMERATION, INTEGRAL>::CastFrom(INTEGRAL& src)
    {
        return *(reinterpret_cast<TFlag*>(&src)); 
    }
 
    template<class ENUMERATION, class INTEGRAL>
    const ENUMERATION& TFlag<ENUMERATION, INTEGRAL>::Cast(const INTEGRAL& src)
    {
        return *(reinterpret_cast<const ENUMERATION*>(&src)); 
    }
 
    template<class ENUMERATION, class INTEGRAL>
    ENUMERATION& TFlag<ENUMERATION, INTEGRAL>::Cast(INTEGRAL& src)
    {
        return *(reinterpret_cast<ENUMERATION*>(&src)); 
    }
 
    template<class ENUMERATION, class INTEGRAL>
    const INTEGRAL& TFlag<ENUMERATION, INTEGRAL>::Cast(const ENUMERATION& src)
    {
        return *(reinterpret_cast<const INTEGRAL*>(&src)); 
    }
 
    template<class ENUMERATION, class INTEGRAL>
    INTEGRAL& TFlag<ENUMERATION, INTEGRAL>::Cast(ENUMERATION& src)
    {
        return *(reinterpret_cast<INTEGRAL*>(&src)); 
    }
 
    template<class ENUMERATION, class INTEGRAL>
    void TFlag<ENUMERATION, INTEGRAL>::Add(const bool success, const ENUMERATION flag)  
    {
        if(success)
            Cast(mFlags) |= flag; 
    }
 
    template<class ENUMERATION, class INTEGRAL>
    void TFlag<ENUMERATION, INTEGRAL>::Add(const bool success, const INTEGRAL flag)  
    {
        if(success)
            Cast(mFlags) |= flag; 
    } 
 
}//namespace tools
 
#if 0
//ИСПОЛЬЗОВАНИЕ:
 
enum eFLAGS { eCLEAR = 0, eONE = 1<<1, eTWO = 1<<2, eTHREE = 1<<3 };
typedef tools::TFlag<eFLAGS> Flag;
 
Flag f(eONE|eTWO);
EXPECT_EQ(eONE|eTWO,    f.GetByEnumeration()    );
EXPECT_EQ(false,        f.Empty()               );
EXPECT_EQ(true,        (f)? true: false         );
EXPECT_EQ(true,         f.Has(eONE)             );
EXPECT_EQ(true,         f.Has(eONE|eTWO)        );
EXPECT_EQ(false,        f.Has(eONE|eTWO|eTHREE) );
EXPECT_EQ(true,         f.HasAny(eONE|eTWO)     );
EXPECT_EQ(true,         f.HasAny(eTWO|eTHREE)   );
EXPECT_EQ(false,        f.HasOnly(eONE)         );
EXPECT_EQ(true,         f.HasOnly(eONE|eTWO)    );
 
f.ValidOnly(eONE);
 
EXPECT_EQ(eONE,   f.GetByEnumeration()  );
EXPECT_EQ(false,  f.Empty()             );
EXPECT_EQ(true,  (f)? true: false       );
EXPECT_EQ(true,   f.Has(eONE)           );
EXPECT_EQ(false,  f.Has(eONE|eTWO)      );
EXPECT_EQ(true,   f.HasAny(eONE|eTWO)   );
EXPECT_EQ(false,  f.HasAny(eTWO|eTHREE) );
EXPECT_EQ(true,   f.HasOnly(eONE)       );
EXPECT_EQ(false,  f.HasOnly(eONE|eTWO)  );
#endif