Getting and setting values to an array with Overloading the subscript operator “[ ]” won't work

Question

After really hard search for answers...

I tried fo(u)r hours to get and set values to an array with Overloading the subscript operator “[ ]” but can't figure out why it won't work.

What I'm tring to do here is to set someType value to an array member (On Main "darr1[i] = i*10.0" for example) with overloading the [] and with overloading the = and to get someType value from an array member (On Main "<< darr1[i] << endl" for example) but can't figure out why just the overloading of: "Type & operator [] (int index)" is invoking.

My program doesn't get to the '=' overloading or to the second '[]' overloading at all..

here is my program (sorry for the long one):

#include <iostream>
#include <math.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
using namespace std;

class  AO1Array
{

private:
int _size;

protected:
int top;
int *B;
int *C;

AO1Array(int n);
~AO1Array();
bool isRealValue(int index)
{
    if ((0 <= B[index] && B[index] < top) && (index == C[B[index]]))
        return true;
    return false;
};
};

AO1Array::AO1Array(int n)
{
_size = n;
top = 0;
B = new int[n];
C = new int[n];
}


AO1Array::~AO1Array()
{
delete[] B;
B = NULL;

delete[] C;
C = NULL;
}



template<class Type>
class GenericO1Array : AO1Array
{

public:
GenericO1Array(int size, Type initVal) : AO1Array(size)
{
        _initVal = initVal;
        Len = size;
        A = new Type[size];

}

~GenericO1Array()
{
        delete[] A;
        A = NULL;
}
int Length() { return Len; }
Type & operator [](int index) const
{
    if (AO1Array::isRealValue(index))
        return A[index];
    return _initVal;

}
Type & operator [] (int index) 
{
    if (AO1Array::isRealValue(index))
        realValue = true;
    else
        realValue = false;
    return A[index];
}
Type operator =(Type value)
{
    if (realValue)
        A[lastIndex] = _initVal;
    else
    {
        AO1Array::C[top] = lastIndex;
        AO1Array::B[lastIndex] = AO1Array::top++;
        A[index] = value;
    }

    return *this;

}



private:
int Len;
int lastIndex;
bool realValue;
Type _initVal;
Type *A;
};



int main()
{
int n = 20;
GenericO1Array<double> darr1(n, 1.1);
GenericO1Array<long> iarr1(n, 2);
int i;
cout << "\nLength.darr1 = " << darr1.Length() << endl;
cout << "\nLength.iarr1 = " << iarr1.Length() << endl;

for (i = 0; i < n; i += 2)
{
    darr1[i] = i*10.0;
    iarr1[i] = i * 100;
} // for

cout << "\ndarr1 = " << endl;
for (i = 0; i < n; i++)
    cout << "darr1[" << i << "] = " << darr1[i] << endl;

cout << "\niarr1 = " << endl;
for (i = 0; i < n; i++)
    cout << "iarr1[" << i << "] = " << iarr1[i] << endl;
 } // main

Answer 1

My program doesn't get to the '=' overloading

You are overloading the = assignment operator of Generic01Array itself, but nothing in your code is actually assigning values to your darr1 or iarr1 variables directly (there are no darr1 = ... or iarr = ... statements). That is why your = operator is not being invoked.

If you want something to happen when the user assigns a value to an element of your array, you need to create a proxy class and overload its = assignment operator, then have your [] operator return an instance of that proxy:

template<class Type>
class GenericO1Array : AO1Array
{
public:
    class Proxy;
    friend Proxy;

    class Proxy
    {
    private:
      Generic01Array& _arr;
      int _index;
    public:
        Proxy(Generic01Array &arr, int index) : _arr(arr), _index(index) {}

        operator Type() const
        {
            if (_arr.isRealValue(index))
                _arr.realValue = true;
            else
                _arr.realValue = false;

            return _arr.A[_index];
        }

        Proxy& operator=(const Type &value)
        {
            if (_arr.realValue)
                _arr.A[_arr.lastindex] = _arr._initVal;
            else
            {
                _arr.C[_arr.top] = _arr.lastIndex;
                _arr.B[_arr.lastIndex] = _arr.top++;
                _arr.A[_index] = value;
            }

            return *this;
        }
    };

    ...

    Proxy operator [] (int index) 
    {
        return Proxy(*this, index);
    }

    ...
};

or to the second '[]' overloading at all..

You have two overloads of the [] operator, one that is const and the other is not. The const version of [] is breaking the const -ness of the operator by returning a non- const reference to the array's internal data. It should be returning a non-reference const value instead:

const Type operator [](int index) const

The non- const version of the [] operator can return a reference:

Type& operator [](int index)

You are not calling the [] operator on any const instances of your Generic01Array class, so only the non- const version of your [] operator should be getting invoked.