Перегрузка индексации

int* operator[](int index){
  return  matrix[index];
}

class YourClass
{
    friend class Tmp;
    int a[5][5];
    class Tmp
    {
        YourClass &your_class;
        int i;
        Tmp(YourClass &your_class_, int i_):
                your_class(your_class_), i(i_) {}
        Tmp(const Tmp &);
        friend class YourClass;
    public:
        int &operator[](int j) { return your_class.a[i][j]; }
    };
public:
    Tmp operator[](int i) { return Tmp(*this, i); }
};
 
int main()
{
    YourClass y;
    y[3][4]=5;
    int m=y[3][4];
    return 0;
}

class my_class {
    private:
        int **Massiv; // Указатель на двумерный массив
    public:
        мега_код_перегрузки (int i, int j) { return Massiv[i][j]; }
};

int operator[] (int n){
        ...
    return *str[n];
    }

char * operator[] (int index)
    {
        return ptr[index];
    }

template <class QType> class int_array
{
    template <class PType> class row
    {
        friend class int_array<PType>;
        PType *first_cell_in_row;
        row<PType>( int *p ) : first_cell_in_row(p) {}
    public:
        PType &operator[] ( int index );
    };
    int nrows;
    int ncols;
    int *the_array;
public:
    virtual
    ~int_array( void );
    int_array( int rows, int cols );
    row<QType> operator[] (int index);
};
 
template <class QType> int_array<QType>::int_array( int rows, int cols ) 
: nrows ( rows ), ncols ( cols ), the_array ( new int[rows * cols])
{}
 
template <class QType> int_array<QType>::~int_array( void )
{
    delete [] the_array;
}
 
template <class QType> inline int_array<QType>::row<QType> int_array<QType>::operator[]( int index )
{
    return row<QType>( the_array + (ncols * index) );
}
 
template <class QType> inline QType &int_array<QType>::row<QType>::operator[]( int index ) // Тут ошибка!
{
    return first_cell_in_row[ index ];
}

#include <iostream>
#include "array.h"
 
int main(){
    int_array<int> p(10,10);
    return 0;
}