template<typename T>
Matrix<T>& Matrix<T>::operator *( Matrix & input )
{
    assert( this->width == input.height );
    Matrix<T> * newmatrix = new Matrix<T>(this->width, input.height); // ну, вот например создаю новый объект
    for( unsigned i = 0; i < this->height; i++ )
        for( unsigned j = 0; j < input.width; j++ )
        {
            newmatrix->data[i][j] = 0;
            for( int k = 0; k < this->width; k++ )
                newmatrix->data[i][j] += this->data[k][i] * input.data[j][k];
        }

    return * newmatrix;
}

template<typename T>
Matrix<T>& Matrix<T>::operator =( Matrix & input )
{
    assert( this->height == input.height );
    assert( this->width == input.width );
    for( unsigned i = 0; i < this->height; i++ )
        for( unsigned j = 0; j < this->width; j++ )
            this->data[i][j] = input.data[i][j];
    return * this;
}

__I>template<typename T>
__I>Matrix<T>& Matrix<T>::operator *( Matrix & input )
__I>{
__I>    assert( this->width == input.height );
__I>    Matrix<T> * newmatrix = new Matrix<T>(this->width, input.height); // ну, вот например создаю новый объект
__I>    for( unsigned i = 0; i < this->height; i++ )
__I>        for( unsigned j = 0; j < input.width; j++ )
__I>        {
__I>            newmatrix->data[i][j] = 0;
__I>            for( int k = 0; k < this->width; k++ )
__I>                newmatrix->data[i][j] += this->data[k][i] * input.data[j][k];
__I>        }

__I>    return * newmatrix;
__I>}

template<typename T>
Matrix<T>& operator *(const Matrix & l, const Matrix & r)
{
  Matrix<T> result( l );
  return result._do_multiply(l);
}

__I>template<typename T>
__I>Matrix<T>& Matrix<T>::operator =( const Matrix & input ) // лишнее копирование ни к чему
__I>{
      if ( this != &input ) // и здесь то же
      {
__I>    assert( this->height == input.height );
__I>    assert( this->width == input.width );
__I>    for( unsigned i = 0; i < this->height; i++ )
__I>        for( unsigned j = 0; j < this->width; j++ )
__I>            this->data[i][j] = input.data[i][j];
      }
__I>    return * this;
__I>}

GN>template<typename T>
GN>Matrix<T>& operator *(const Matrix & l, const Matrix & r)
GN>{
GN>  Matrix<T> result( l );
GN>  return result._do_multiply(l);
GN>}
GN>

class X
{
    X& operator *=(Whatever const& w)
    {
        . . .
        return *this;
    }

    X operator *(Whatever const& w) const
    {
         X tmp(*this);
         return tmp *= w;
    }
};

class X
{
    friend X& operator *=(X& x, Whatever const& w)
    {
        . . .
        return x;
    }
};

X operator *(X x, Whatever const& w)
{
    return x *= w;
}

__I>template<typename T>
__I>Matrix<T> // возвращать надо новый временный объект, а не ссылку на созданный на куче и в дальнейшем потерянный
__I>Matrix<T>::operator *( Matrix const& input ) const // ты же не собираешься модифицировать аргументы, правильно?
__I>{
__I>    assert( this->width == input.height );
__I>    Matrix<T> newmatrix(this->width, input.height); // создаёшь локальный объект на стеке...
__I>    for( unsigned i = 0; i < this->height; i++ )
__I>        for( unsigned j = 0; j < input.width; j++ )
__I>        {
__I>            newmatrix.data[i][j] = 0;
__I>            for( int k = 0; k < this->width; k++ )
__I>                newmatrix.data[i][j] += this->data[k][i] * input.data[j][k];
__I>        }

__I>    return newmatrix; // и возвращаешь его копию (вообще-то, компилятор выполнит NRVO и сэкономит на копировании)
__I>}

__I>template<typename T>
__I>Matrix<T>& Matrix<T>::operator =( Matrix const& input ) // источник не меняется - объяви его константным
__I>{
__I>    assert( this->height == input.height );
__I>    assert( this->width == input.width );
__I>    for( unsigned i = 0; i < this->height; i++ )
__I>        for( unsigned j = 0; j < this->width; j++ )
__I>            this->data[i][j] = input.data[i][j];
__I>    return * this;
__I>}
__I>

T** data;
........
data = new T* [height];
for( unsigned i = 0; i < height; ++i ) data[i] = new T [width];

template<class T> class Matrix
{
    T* data;
    unsigned width,height;
    unsigned reserved; // текущий размер массива: width*height <= reserved
    
    Matrix() : data(NULL), width(0), height(0), reserved(0) {}
.....
    void resize(unsigned w, unsigned h)
    {
        unsigned s = w*h; // потребный размер
        if(s > reserved)
        {
            delete[]data;
            data = new T[s];
            reserved = s;
        }
        width=w; height=h;
    }
.....
    unsigned indexof(unsigned i, unsigned j) const { assert(i<width && j<height); return i*width + j; }
.....    
    T      & at(unsigned i, unsigned j)       { return data[indexof(i,j)]; }
    T const& at(unsigned i, unsigned j) const { return data[indexof(i,j)]; }
.....
};

newmatrix.at(i,j) += this->at(i,k) * input.at(k,j);

if(this != &input)
{
    resize(input.width,input.height);
    std::copy(input.data, input.data+input.width*input.height, data);
}