что-то я запуталась немного,а где ошибка,кто знает?

Matrix &operator +( const Matrix &R)

    {
        Matrix **T;
        T=new Matrix*[m_width];
        for(unsigned i=0;i<m_width;i++)
        {
            T[i]=new Matrix[m_height];
            for(unsigned j=0;j<m_height;j++)
            {
                T[i][j]=m_value[i][j]+R.m_value[i][j];
            }
        } return T[m_width][m_height];???
    }

Во-первых интересно было бы узнать какая ошибка
Во-вторых в приведенно коде не видно объявления переменных m_width и m_height

Не могу почему-то сложить матрицы друг с другом, m_width и m_height  равны значениям,которые я ввожу сама в main(),это предусмотрено в конструкторе:
Matrix A(3,4),где 3-это m_width ,а 4-m_height

А компилится без проблем?
Возвращаемое значение заявлено как ссылка, а возвращается указатель. 

Какая конкретно ошибка? Неправильно складывает? 

void main()
{

Matrix A(3,3);
    Matrix B(3,3);
    Matrix C(3,3);
    C=A+B;вот сдесь и ошибка - вообще не работает

return T[m_width-1][m_height-1]

Это сообщение отредактировал(а) TIGERоX - 16.12.2006, 22:54

Не работает или не компилируется?

компилируется,пока не ввожу в

 main()
{
 C=A+B; вот это

Natalka, покажи весь код и скажи, что этот перегружаемый оператор должен делать

#include "stdafx.h"
#include <ctime>
using namespace std;
class Matrix
{
    int ** m_value;
   unsigned m_width,m_height;
public:
   Matrix( unsigned width = 0, unsigned height = 0 ) : m_width(width), m_height(height)
   {
       m_value = new int*[m_width];
       for ( unsigned i = 0; i < m_width; ++i )
       {
          m_value[i] = new int[m_height];
          for ( unsigned j = 0; j< m_height; ++j )
             m_value[i][k]=0;
       }
   }
 void Get()
   {
       for ( unsigned i = 0; i < m_width; ++i )
       {
          for ( unsigned k = 0; k < m_height; ++k )
          {
              m_value[i][k]=rand()%10+1;
              cout<<m_value[i][k]<<" ";
          }cout<<endl;
       }
   }
 Matrix &operator +( const Matrix &R)
    {
        Matrix **T;
        T=new Matrix*[m_width];
        for(unsigned i=0;i<m_width;i++)
        {
            T[i]=new Matrix[m_height];
            for(unsigned j=0;j<m_height;j++)
            {
                T[i][j]=m_value[i][j]+R.m_value[i][j];
            }
        } return T[m_width][m_height];
    }

   ~Matrix()
   {
       for ( unsigned i = 0; i < m_width; i++ )
          delete [] m_value[i];
       delete [] m_value;       
   }
}; 
void main()
{
    //srand(time(0));
    Matrix A(3,3);
                Matrix B(3,3);
                Matrix C(3,3);
    C=A+B;
    A.Get();
    cout<<endl;
    B.Get();
    cout<<endl;
    C.Get();
    
}
Я просто должна сложить две матрицы друг с другом

Natalka, и присвоить результат третьей =) Равно тоже надо перегружать

А зачем столько объектов типа Matrix?

#include "stdafx.h"
#include <ctime>
using namespace std;
class Matrix
{
    int ** m_value;
   unsigned m_width,m_height;
public:
   Matrix( unsigned width = 0, unsigned height = 0 ) : m_width(width), m_height(height)
   {
       m_value = new int*[m_width];
       for ( unsigned i = 0; i < m_width; ++i )
       {
          m_value[i] = new int[m_height];
          for ( unsigned j = 0; j< m_height; ++j )
             m_value[i][k]=0;
       }
   }
 void Get()
   {
       for ( unsigned i = 0; i < m_width; ++i )
       {
          for ( unsigned k = 0; k < m_height; ++k )
          {
              m_value[i][k]=rand()%10+1;
              cout<<m_value[i][k]<<" ";
          }cout<<endl;
       }
   }
 Matrix &operator +( const Matrix &R)
    {
        Matrix **T;
        T=new Matrix*[m_width];
        for(unsigned i=0;i<m_width;i++)
        {
            T[i]=new Matrix[m_height];
            for(unsigned j=0;j<m_height;j++)
            {
                T[i][j]=m_value[i][j]+R.m_value[i][j];
            }
        } return T[m_width][m_height];
    }
 Matrix& operator=( const Matrix &matrix )
   {
       if ( this != &matrix )
       {
          for ( unsigned i = 0; i < m_width; i++ )
             delete [] m_value[i];
          delete [] m_value;
          m_width = matrix.m_width;
          m_height = matrix.m_height;
          m_value = new int*[m_width];
          for ( unsigned i = 0; i < m_width; ++i )
          {
             m_value[i] = new int[m_height];
             for ( unsigned k = 0; k < m_height; ++k )
                m_value[i][k] = matrix.m_value[i][k];
          }          
       }
       return *this;
   }

   ~Matrix()
   {
       for ( unsigned i = 0; i < m_width; i++ )
          delete [] m_value[i];
       delete [] m_value;       
   }
}; 
void main()
{
    //srand(time(0));
    Matrix A(3,3);
                Matrix B(3,3);
                Matrix C(3,3);
    C=A+B;    ------------------------------------//а это разве не третья, равно перегрузила
    A.Get();
    cout<<endl;
    B.Get();
    cout<<endl;
    C.Get();
    
}

Зачем такой большой код

Cпасибо,конечно,но мне нужен код с перегруженным оператором и с динамическим массивом