Re: Overloading Operator[] through 'this' pointer?

From:

Paul Bibbings <paul.bibbings@gmail.com>

Newsgroups:

comp.lang.c++

Date:

Tue, 08 Jun 2010 23:12:55 +0100

Message-ID:

<878w6pdvh4.fsf@gmail.com>

Immortal Nephi <Immortal_Nephi@hotmail.com> writes:

On Jun 7, 3:01??pm, Paul Bibbings <paul.bibbi...@gmail.com> wrote:

Immortal Nephi <Immortal_Ne...@hotmail.com> writes:

   Can overloading operator[] be connected to any member functions
through ???this??? pointer? I do not want to insert assignment between
array object and integer value. I prefer to place integer value in
the member function???s parameter.

For example:

class Array
{
public:
   Array( int size ) : pData( new unsigned char[ size ] )
   {}

   ~Array()
   {
           delete [] pData;
   }

   int &operator[]( int index )
   {
           return pData[ index ];
   }

   Array &Set_LowNibble( unsigned char val, int index )
   {
           pData[ index ] &= 0xF0;
           pData[ index ] |= (val & 0x0F );
           return *this;
   }

   Array &Set_HighNibble( unsigned char val, int index )
   {
           pData[ index ] &= 0x0F;

           unsigned char temp = val;
           temp &= 0x0F;
           temp <<= 4;

           pData[ index ] |= temp;

           return *this;
   }

private:
   unsigned char *pData;
};

int main()
{
   Array array( 4 );

   array[ 0 ] = 0x1E; // Always valid code

   // Not valid code but you find another way
   array[ 1 ].Set_LowNibble( 0x0D, 1 ).Set_HighNibble( 0x02, 1 );

   return 0;
}

The following is just an idea to think about. I have not given very
much consideration to the details and I am not completely sure why you
are wanting it to work in this way.

   class Byte
   {
   public:
      Byte(unsigned char& c) : c_(c) { }
      Byte& operator=(unsigned char val)
      {
         c_ = val;
         return *this;
      }
      Byte& Set_LowNibble(unsigned char val)
      {
         c_ &= 0xF0;
         c_ |= (val & 0x0F);
         return *this;
      }
      Byte& Set_HighNibble(unsigned char val)
      {
         c_ &= 0x0F;
         unsigned char temp = val;
         temp &= 0x0F;
         temp <<= 4;
         c_ |= temp;
         return *this;
      }
      operator unsigned char&() { return c_; }
   private:
      unsigned char& c_;
   };

   class Array
   {
   public:
      Array(int size)
         : pData(new unsigned char[size])
      { }
      ~Array()
      {
         delete [] pData;
      }
      Byte operator[](int index)
      {
         return pData[index];
      }
   private:
      unsigned char *pData;
   };

   int main()
   {
      Array array(4);

      array[0] = 0x3C;

      array[1].Set_LowNibble(0x0D).Set_HighNibble(0x02);

      std::cout << array[0] << '\n';
      std::cout << array[1] << '\n';

      unsigned char& c_ref = array[1];
      c_ref = array[0];

      std::cout << array[0] << '\n';
      std::cout << array[1] << '\n';

      return 0;
   }

   /**
    * Output:
    * <
    * -
    * <
    * <
    */

That code looks great. One problem???If I want to create a pointer,
Set_LowNibble and Set_HighNibble are not members of that class.

I don't understand the logic in *wanting* Set_LowNibble and
Set_HighNibble to be members of your Array class. Your Array is a
container of elements where the concept of high and low nibbles applies
to the *elements* and not to the container as a whole. I can't
visualize what setting a high or low nibble *of a container* would mean,
conceptually, as opposed to doing the same to any one of its elements.
In the example code above an element is modelled by the proxy Byte,
for which the operation of `setting the high/low nibble' *makes sense*.

Array *pArray = new Array( 4 );

What is another way to fix?

In this example, using a pointer, what would be wrong with:

   (*arr_ptr)[0] = 0x3C;
   (*arr_ptr)[1].Set_LowNibble(0x0D).Set_HighNibble(0x02);
   // etc.

Regards

Paul Bibbings