Re: Operator Cast () Reference?
Immortal Nephi <Immortal_Nephi@hotmail.com> writes:
On Jun 10, 5:12?pm, Paul Bibbings <paul.bibbi...@gmail.com> wrote:
One other point. ?Though I can only guess at the purpose of the
m_... members of Array above, I would have thought that the masks should
be:
? ?m_RedMask ? = 0xC0 (1100 0000)
? ?m_GreenMask = 0x38 (0011 1000)
? ?m_BlueMask ?= 0x07 (0000 0111)
given how you describe them above. ?Here I am supposing that you want
the mask to do things like:
Should be correct values as reversed bits below.
m_RedMask = 0x3F (0011 1111)
m_GreenMask = 0xC7 (1100 0111)
m_BlueMask = 0xF8 (1111 1000)
Byte object has eight member functions when I declare RGB8
I understand.
Byte& Set_Color( unsigned char val ) { // Assigns 8 bits red, green, &
blue
dataRef = val;
return *this;
}
This can be replaced (but doesn't have to be) by:
Byte& Byte::operator=(unsigned int new_col);
(see example below).
unsigned char Get_Color() {
return dataRef;
}
This can be replaced (but doesn't have to be) by:
Byte::operator unsigned char&();
Byte::operator unsigned char() const;
(see example below).
unsigned char Get_Red() {
return ( dataRef >> m_ShiftRed ) & 0x02;
^^^^
Should be 0x03
}
unsigned char Get_Green()
return ( dataRef >> m_ShiftGreen ) & 0x03;
^^^^
Should be 0x07
}
unsigned char Get_Blue()
return dataRef & 0x03;
^^^^
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.
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.
Regards
Paul Bibbings