Re: Operator Cast () Reference?

Before you decide on using `bidirectional communication', consider
something like the following, which uses a `traits' type. Note that I
have changed some of the names to match what it is that I think you are
trying to do.

   #include <iostream>
   #include <new>

   enum bits { rgb3 = 3, rgb6 = 6, rgb8 = 8 };

   template<bits>
   struct color_traits;

   template<>
   struct color_traits<rgb3> { /* ... */ };

   template<>
   struct color_traits<rgb6> { /* ... */ };

   template<>
   struct color_traits<rgb8>
   {
      // ...

      static const int RedBits = 0x03;
      static const int GreenBits = 0x07;
      static const int BlueBits = 0x07;

      static const int ShiftRed = 6;
      static const int ShiftGreen = 3;

      static const unsigned char ClearRedMask = 0x3F;
      static const unsigned char ClearGreenMask = 0xC7;
      static const unsigned char ClearBlueMask = 0xF8;
   };

   template<
      bits Bits,
      typename Tr = color_traits<Bits>
   >
   class Color {
   public:
      Color(unsigned char& col)
         : m_col(col)
      { }
      ~Color() { }
      Color(const Color& other)
         : m_col(other.m_col)
      { }
      Color& operator=(const Color& other)
      {
         if (this != &other)
         {
            this->~Color();
            new (this) Color(other);
         }
         return *this;
      }
      Color& operator=(unsigned char new_col) // Set_Color
      {
         m_col = new_col;
         return *this;
      }
      Color& Set_Red(unsigned char red)
      {
         m_col &= Tr::ClearRedMask;
         unsigned char temp = red << Tr::ShiftRed;
         m_col |= temp;
         return *this;
      }
      Color& Set_Green(unsigned char green)
      {
         m_col &= Tr::ClearGreenMask;
         unsigned char temp = green << Tr::ShiftGreen;
         m_col |= temp;
         return *this;
      }
      Color& Set_Blue(unsigned char blue)
      {
         m_col &= Tr::ClearBlueMask;
         m_col |= blue;
         return *this;
      }
      operator unsigned char&() { return m_col; } // Get_Color
      operator unsigned char() const { return m_col; } // Get_Color
      unsigned char Get_Red() const
      {
         return (m_col >> Tr::ShiftRed) & Tr::RedBits;
      }
      unsigned char Get_Green() const
      {
         return (m_col >> Tr::ShiftGreen) & Tr::GreenBits;
      }
      unsigned char Get_Blue() const
      {
         return m_col & Tr::BlueBits;
      }
   private:
      unsigned char& m_col;
   };

   template<bits Bits>
   class ColorArray {
   public:
      ColorArray(int size)
         : pData(new unsigned char[size])
      { }
      ~ColorArray() { delete [] pData; }
      Color<Bits> operator[](int index)
      {
         return pData[index];
      }
      const Color<Bits> operator[](int index) const
      {
         return pData[index];
      }
   private:
      unsigned char *pData;
   };

   typedef ColorArray<rgb3> RGB3;
   typedef ColorArray<rgb6> RGB6;
   typedef ColorArray<rgb8> RGB8;

   int main()
   {
      RGB8 col_array8(4);
      col_array8[0].Set_Red(0x01).Set_Green(0x07).Set_Blue(0x05);
      col_array8[1].Set_Red(col_array8[0].Get_Red() + 1)
                   .Set_Green(col_array8[0].Get_Green() - 3)
                   .Set_Blue(col_array8[0].Get_Blue() - 2);
      std::cout << "red : " << int(col_array8[1].Get_Red()) << '\n';
      std::cout << "green: " << int(col_array8[1].Get_Green()) << '\n';
      std::cout << "blue : " << int(col_array8[1].Get_Blue()) << '\n';
   }

   /**
    * Output:
    * red : 2
    * green: 4
    * blue : 3
    */

I do not say that this is the right way to do it, and it may not work
for you for other reasons. However, it is an idea, at least.