why does return statement assigns value?

[Ruthra]

why is the return statement in line 13 assigning integer values to array.
All it should do is to return the element right? how is this possible?

// overload_array.cpp
// overloading the c++ array subscript operator []
#include <iostream>

using namespace std;

class myArray {
    private:
      int size;
      int a[10];
    public:
      int& operator[] (int x) {
          return a[x];
      }
      void print_array();   // I included this just to show the operator[] works!   
};

void myArray::print_array()
{
    for (int j=0; j < 10; j++)
        cout << "array[" << j << "] = " << a[j] << "\n";
}

int main(int argc, char *argv[])
{
    // create an instance of the myArray class    
    myArray instance;

    // load instance.a[] with integers
        // NOTE: here we use instance[i] NOT instance.a[i]   
        // instance.a[] wouldn't work as "int a[]" in the myArray class
        // is defined as PRIVATE!!!!!  
    for (int i=0; i < 10; i++)
        instance[i] = i; 

    // show that our operator worked by printing out the array values
    // using the myArray member function myArray::print_array()
    instance.print_array();

    cout << "\n\n";
    system("PAUSE");
    return EXIT_SUCCESS;
}

[coder777]

It does not return the value. It returns a reference (&) to the value, so that on line 34 it is possible to assign a value. Remove the & on line 12 and see what happens.

[Ruthra]

removing (&) operator causes a 'lvalue required' error.
i modified the code to use pointer instead of reference and it works

int *operator[] (int x) {
     return &a[x];
}

*instance[i] = i+10;

however when i try multidimensional array using reference "declaration of operator[] as non-function" is thrown.

private:
      int a[10][10];
    public:
      int& operator[] [] (int x,int y) {
          return a[x][y];
      }

Is it even possible to overload a [] operator for a multi dimesional array?

[JLBorges]

struct my_array
{
    int a[10][10] {};

    auto& operator[] ( std::size_t pos ) { return a[pos] ; } // invariant: pos < 10
    const auto& operator[] ( std::size_t pos ) const { return a[pos] ; } // invariant: pos < 10
};

int main()
{
    my_array a ;
    a[3][5] = 99 ;
    std::cout << a[3][5] << '\n' ;
}

http://coliru.stacked-crooked.com/a/cbd6308f3043e946

[Ruthra]

above code causes an

internal compiler error: in gen_type_die_with_usage, at dwarf2out.c:19483 

in my codeblocks with support for C++11 turned on.

I assume that by my understanding in a two dimensional array the first index stores pointer to starting address of the arrays, the second index access the pos element in the array.

so the first overloaded operator[]

auto& operator[] (std::size_t pos){ return a[pos];}

returns a pointer to starting address of 3rd array, and the second operator[]

const auto& operator[] { std::size_t pos) const { return a[pos]; }

return the pos element or 5th element of that array.
Is my understanding right? the code is not running on my local machine with g++ 4.8.4 version

[JLBorges]

> above code causes an internal compiler error: in gen_type_die_with_usage, at dwarf2out.c:19483
> in my codeblocks with support for C++11 turned on.

Try this version (without C++14 return type deduction):

#include <iostream>

struct my_array
{
    int a[10][10] {};
    
    typedef int array_type[10] ;

    array_type& operator[] ( std::size_t pos ) { return a[pos] ; } // invariant: pos < 10
};

int main()
{
    my_array a ;
    a[3][5] = 99 ;
    std::cout << a[3][5] << '\n' ;
}

http://coliru.stacked-crooked.com/a/29197029f3af3cdd

The overloaded operator returns a reference to 'array of 10 int'. ie. a[3] yields a reference to 'array of 10 int'.
The [5] in a[3][5] is the normal subscript operator applied to that array,.