Operator Cast () Reference?

I

Immortal Nephi

   Should be correct values as reversed bits below.
Click to expand...
    m_RedMask   = 0x3F (0011 1111)
    m_GreenMask = 0xC7 (1100 0111)
    m_BlueMask  = 0xF8 (1111 1000)
Click to expand...
   Byte object has eight member functions when I declare RGB8
Click to expand...

I understand.
Byte& Set_Color( unsigned char val ) { // Assigns 8 bits red, green, &
blue
   dataRef = val;
   return *this;
}
Click to expand...

This can be replaced (but doesn't have to be) by:

   Byte& Byte::eek:perator=(unsigned int new_col);

(see example below).
unsigned char Get_Color() {
   return dataRef;
}
Click to expand...

This can be replaced (but doesn't have to be) by:

   Byte::eek:perator unsigned char&();
   Byte::eek:perator unsigned char() const;

(see example below).
unsigned char Get_Red() {
   return ( dataRef >> m_ShiftRed ) & 0x02;
Click to expand...

                                           ^^^^
                                 Should be 0x03> }
unsigned char Get_Green()
   return ( dataRef >> m_ShiftGreen ) & 0x03;
Click to expand...

                                             ^^^^
                                   Should be 0x07> }
unsigned char Get_Blue()
   return dataRef & 0x03;
Click to expand...

                         ^^^^
               Should be 0x07
}
   You understood very well.  Good suggestions!  Are you going to
agree?  I will not want to avoid bidirectional communications unless
Array object is very flexible to configure inialization.
Click to expand...

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.
Click to expand...

Wow! Your suggestion is excellent. I must consider either enum /
template or bidirectional communication.
If RGB has more than 8 bits such as R4G4B4 or R5G6B5 or R8G8B8 or
higher, they will need to use separate data type unsigned short,
unsigned long, and unsigned long long.
I will study your code shortly.
 
P

Paul Bibbings

Immortal Nephi said:
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,
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.
Click to expand...

Wow! Your suggestion is excellent. I must consider either enum /
template or bidirectional communication.
If RGB has more than 8 bits such as R4G4B4 or R5G6B5 or R8G8B8 or
higher, they will need to use separate data type unsigned short,
unsigned long, and unsigned long long.
Click to expand...

In which case, all you would have to do is add a typedef to your
specializations of the color_traits class, so (for example):

template<>
struct color_traits<rgb8>
{
// ...
typedef unsigned char color_type;
};

template<>
struct color_traits<r5g6b4>
{
// ...
typedef unsigned short color_type; // for 16 bit short
};

and adjust the masks for the same type. Then, for the Color type above,
add a typedef:

typedef typename Tr::color_type color_type;

Then, you can replace *all* cases of `unsigned char' in the Color type
with `color_type', and do the same for your ColorArray, either:

1. replacing all cases of `unsigned char' with

typename color_traits<Bits>::color_type; or

2. adding the typedef:

typedef typename color_traits<Bits>::color_type color_type

and then doing the same that you did for the Color type, replacing
`unsigned char' with `color_type'

In this way you will be able to use whatever underlying type seems most
appropriate for *all* your r#g#b# types by merely specializing
color_traits and adding the appropriate typedef for `color_type'. All
the rest of the code is then completely generic, which feels like quite
a gain over what you were starting with, because you cannot change the
underlying type for your original non-template Array class.

Regards

Paul Bibbings
 
I

Immortal Nephi

Immortal Nephi said:
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.
Click to expand...
Click to expand...
   Wow!  Your suggestion is excellent.  I must consider either enum /
template or bidirectional communication.
   If RGB has more than 8 bits such as R4G4B4 or R5G6B5 or R8G8B8 or
higher, they will need to use separate data type unsigned short,
unsigned long, and unsigned long long.
Click to expand...

In which case, all you would have to do is add a typedef to your
specializations of the color_traits class, so (for example):

   template<>
   struct color_traits<rgb8>
   {
      // ...
      typedef unsigned char color_type;
   };

   template<>
   struct color_traits<r5g6b4>
   {
      // ...
      typedef unsigned short color_type;  // for 16 bit short
   };

and adjust the masks for the same type.  Then, for the Color type above,
add a typedef:

   typedef typename Tr::color_type color_type;

Then, you can replace *all* cases of `unsigned char' in the Color type
with `color_type', and do the same for your ColorArray, either:

   1. replacing all cases of `unsigned char' with

         typename color_traits<Bits>::color_type; or

   2. adding the typedef:

         typedef typename color_traits<Bits>::color_type color_type

      and then doing the same that you did for the Color type, replacing
      `unsigned char' with `color_type'

In this way you will be able to use whatever underlying type seems most
appropriate for *all* your r#g#b# types by merely specializing
color_traits and adding the appropriate typedef for `color_type'.  All
the rest of the code is then completely generic, which feels like quite
a gain over what you were starting with, because you cannot change the
underlying type for your original non-template Array class.
Click to expand...

You bet. What if I add two colors, four colors, and sixteen colors?
Two colors are monochrome and eight pixels per byte. Four colors are
four pixels per byte. Also, sixteen colors are two pixels per byte.
All three modes don’t use RGB format to hold raw data in memory. They
will be translated to RGB format when raw data is read from file and
store into memory.
I will study template specification as you suggested.
 
P

Paul Bibbings

Immortal Nephi said:
Immortal Nephi said:
On Jun 11, 5:45 am, Paul Bibbings <[email protected]> wrote:
Click to expand...
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.
Click to expand...
#include <iostream>
#include <new>
Click to expand...
enum bits { rgb3 = 3, rgb6 = 6, rgb8 = 8 };
Click to expand...
template<bits>
struct color_traits;
Click to expand...
template<>
struct color_traits<rgb3> { /* ... */ };
Click to expand...
template<>
struct color_traits<rgb6> { /* ... */ };
Click to expand...
template<>
struct color_traits<rgb8>
{
// ...
Click to expand...
static const int RedBits = 0x03;
static const int GreenBits = 0x07;
static const int BlueBits = 0x07;
Click to expand...
static const int ShiftRed = 6;
static const int ShiftGreen = 3;
Click to expand...
static const unsigned char ClearRedMask = 0x3F;
static const unsigned char ClearGreenMask = 0xC7;
static const unsigned char ClearBlueMask = 0xF8;
};
Click to expand...
template<
bits Bits,
typename Tr = color_traits<Bits>
Click to expand...
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;
};
Click to expand...
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;
};
Click to expand...
typedef ColorArray<rgb3> RGB3;
typedef ColorArray<rgb6> RGB6;
typedef ColorArray<rgb8> RGB8;
Click to expand...
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';
}
Click to expand...
/**
* Output:
* red : 2
* green: 4
* blue : 3
*/
Click to expand...
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.
Click to expand...
Wow! Your suggestion is excellent. I must consider either enum /
template or bidirectional communication.
If RGB has more than 8 bits such as R4G4B4 or R5G6B5 or R8G8B8 or
higher, they will need to use separate data type unsigned short,
unsigned long, and unsigned long long.
Click to expand...

In which case, all you would have to do is add a typedef to your
specializations of the color_traits class, so (for example):

template<>
struct color_traits<rgb8>
{
// ...
typedef unsigned char color_type;
};

template<>
struct color_traits<r5g6b4>
{
// ...
typedef unsigned short color_type; // for 16 bit short
};

and adjust the masks for the same type. Then, for the Color type above,
add a typedef:

typedef typename Tr::color_type color_type;

Then, you can replace *all* cases of `unsigned char' in the Color type
with `color_type', and do the same for your ColorArray, either:

1. replacing all cases of `unsigned char' with

typename color_traits<Bits>::color_type; or

2. adding the typedef:

typedef typename color_traits<Bits>::color_type color_type

and then doing the same that you did for the Color type, replacing
`unsigned char' with `color_type'

In this way you will be able to use whatever underlying type seems most
appropriate for *all* your r#g#b# types by merely specializing
color_traits and adding the appropriate typedef for `color_type'. All
the rest of the code is then completely generic, which feels like quite
a gain over what you were starting with, because you cannot change the
underlying type for your original non-template Array class.
Click to expand...

You bet. What if I add two colors, four colors, and sixteen colors?
Two colors are monochrome and eight pixels per byte. Four colors are
four pixels per byte. Also, sixteen colors are two pixels per byte.
All three modes don’t use RGB format to hold raw data in memory. They
will be translated to RGB format when raw data is read from file and
store into memory.
I will study template specification as you suggested.
Click to expand...

Just one further point (a correction). If you do use the proxy class
(Color above, Byte previously), do *not* implement the copy-assignment
operator:

Color& Color::eek:perator=(const Color&)

as I have given it above. I have since questioned it and it clearly
produces undefined behaviour. The other copy assignment which takes an
argument of the underlying type:

Color& Color::eek:perator=(unsigned char)

is still okay, however.

Regards

Paul Bibbings
 

Ask a Question

Want to reply to this thread or ask your own question?

You'll need to choose a username for the site, which only take a couple of moments. After that, you can post your question and our members will help you out.

Ask a Question

Similar Threads

How to use reference to do cast operator? 6
Operatr+ Updated 7
Overloading Operator[] through 'this' pointer? 6
Overloaded operator question 2
How to use parameter in operator delete? 2
Use Assignment Operator On Both Types 4
Two proxy classes in main class 3
Error operator+ function 11

Members online

No members online now.
Total: 2,623 (members: 1, guests: 2,622)
Robots: 174

Forum statistics

Threads
474,146
Messages
2,570,832
Members
47,374
Latest member
anuragag27

Latest Threads

Top