int x = 1;
int y = 2;
int array[3] = { 0, 0, 0 };

array[0] = x; // okay, per your explanation, we don't mean to write 0 = 1, rather, we mean [element at index 0] = 1
// but then what about:
x = array[0]; // why does x end up holding the r-value of "0", instead of the address of the integer array element at index 0?


Perhaps I need more coffee, but the reasoning here is escaping me… is it simply a matter of compiler convention that a reference used as an r-value will always be evaluated for its r-value rather than the l-value?

int& IntList::operator[](const int index)
{
    if (index < 10)
        return m_anList_A[index];
    else if (index < 20)
        return m_anList_B[index-10];
    else
        throw std::out_of_range("Index out of range");
}

This will return an element from the first list if the index is 0-9, return an element from the second list if the index is 10-19, or throw an exception otherwise.

In a case where we have 2 lists, can we still overload the [] operator?
How does the overload function know which list to use when returning the reference?

—rob

class IntList
{
private:
    int m_anList_A[10];
    int m_anList_B[10];

public:
    int& operator[] (const int nIndex);
};

int& IntList::operator[] (const int nIndex)
{
    return ???
}

I have another question. I want to do sub-indexing too, something like: MyNewType[a][b].

anybody? :)