с++ перегрузка операторов

[proef]

спасибо )
как обращаться в элементу матрицы?
почему то когда пишу
std::cout<<(a+b);
выводит ошибку что :
Необработанное исключение по адресу 0x00D353CC в ConsoleApplication68.exe: 0xC0000005: нарушение прав доступа при чтении по адресу 0xFEEEFEF2.
вот код
на всякий случай

// ConsoleApplication68.cpp: определяет точку входа для консольного приложения.
//


#include "stdafx.h"
#include <iostream>
#include <locale.h>

class Matrix
{protected:
  float **InitMatrix;
   int ISizeOfMatrix;
   int JSizeOfMatrix;
public:
	friend std::istream &operator>>(std::istream &Stream,Matrix &a)
	{
		for (int NumberI = 0;NumberI<a.ISizeOfMatrix;NumberI++){
			for (int NumberJ = 0;NumberJ<a.JSizeOfMatrix;NumberJ++){
				std::cout<<"a["<<NumberI<<"]"<<"["<<NumberJ<<"] = ";
              Stream>>a.InitMatrix[NumberI][NumberJ];
			  }
			
		}
		return Stream;
	
	}
	 friend std::ostream &operator<<(std::ostream &Stream,Matrix &a)
	{
		for (int NumberI = 0;NumberI<a.ISizeOfMatrix;NumberI++)
		{
			for (int NumberJ = 0;NumberJ<a.JSizeOfMatrix;NumberJ++)
			{
				std::cout<<"a["<<NumberI<<"]"<<"["<<NumberJ<<"] = ";
			    Stream<<a.InitMatrix[NumberI][NumberJ];
			}
			Stream<<std::endl;
		
		}
		return Stream;
	}
	 Matrix(int SizeI ,int  SizeJ)
{       ISizeOfMatrix = SizeI;
	    JSizeOfMatrix = SizeJ;
           InitMatrix = new float*[ISizeOfMatrix];
		for (int Number = 0;Number<ISizeOfMatrix;Number++)
		{
			InitMatrix[Number] = new float[JSizeOfMatrix];
		}
		    //std::cin>>*this;
	
		/*for (int NumberI = 0;NumberI<ISizeOfMatrix;NumberI++)
		{
			for (int NumberJ = 0;NumberJ<JSizeOfMatrix;NumberJ++)
			{
			std::cout<<"["<<NumberI<<"]"<<"["<<NumberJ<<"] = ";
			std::cin>>this->InitMatrix[NumberI][NumberJ];
			}
			std::cout<<std::endl;
		
		}*/
		}
	
	  ~Matrix()
	 {
		 delete this->InitMatrix;
	 
	 
	 }
	 
    Matrix  operator+(Matrix &Element)
	{ 
		/*
		
		
		if((this->ISizeOfMatrix != Element.ISizeOfMatrix) ||
            (this->JSizeOfMatrix != Element.JSizeOfMatrix)){
             std::cout << "Different sizes" << std::endl;
             return *this;
         }
         Matrix Result(Element.ISizeOfMatrix, Element.JSizeOfMatrix);

         for (int NumberI = 0;NumberI<this->ISizeOfMatrix; NumberI++){
			
             for (int NumberJ = 0;NumberJ<this->JSizeOfMatrix;NumberJ++){
				 
                 Result.InitMatrix[NumberI][NumberJ] = this->InitMatrix[NumberI][NumberJ] + Element.InitMatrix[NumberI][NumberJ];
             }
         }
         return Result;*/
		 if((this->ISizeOfMatrix != Element.ISizeOfMatrix) ||
            (this->JSizeOfMatrix != Element.JSizeOfMatrix)){
             std::cout << "Different sizes" << std::endl;
             return *this;
         }
         Matrix Result(this->ISizeOfMatrix, this->JSizeOfMatrix);
         for (int NumberI = 0;NumberI<this->ISizeOfMatrix; NumberI++){
             for (int NumberJ = 0;NumberJ<this->JSizeOfMatrix;NumberJ++){
                 Result.InitMatrix[NumberI][NumberJ] =
                     this->InitMatrix[NumberI][NumberJ] + Element.InitMatrix[NumberI][NumberJ];
             }
         }
         return Result;
     
     }
	Matrix& operator=(Matrix &Element)
	{
		for (int NumberI = 0;NumberI<this->ISizeOfMatrix;NumberI++){
		
			for (int NumberJ = 0;NumberJ<this->JSizeOfMatrix;NumberJ++)
			{
			this->InitMatrix[NumberI][NumberJ] = Element.InitMatrix[NumberI][NumberJ];
			
			
			}}
			/*  for (int NumberI = 0;NumberI<this->ISizeOfMatrix; NumberI++){
             for (int NumberJ = 0;NumberJ<this->JSizeOfMatrix;NumberJ++){
                 this->InitMatrix[NumberI][NumberJ] = Element.InitMatrix[NumberI][NumberJ];
             }
         }
      
		*/
		return *this;
	
	
	}
	
	void print(){
		for (int NumberI = 0;NumberI<ISizeOfMatrix;NumberI++)
		{
			for (int NumberJ = 0; NumberJ<JSizeOfMatrix;NumberJ++)
			
			{
			
			
			}
		
		}
	
	
	}
  /*float &operator()(int CurrentI,int CurrentJ)
	{ return this->InitMatrix[CurrentI][CurrentJ];}
	
	*/
};

int main(int argc, _TCHAR* argv[])
{
	setlocale(2,"rus");
	Matrix a(2,2);
	std::cin>>a;
	std::cout<<a;
	Matrix b(2,2);
	std::cin>>b;

std::cout<<(a+b);

	
	

	
	
	return 0;
}

[proef]

всё разобрался

вот так нужно было

// ConsoleApplication68.cpp: определяет точку входа для консольного приложения.
//


#include "stdafx.h"
#include <iostream>
#include <locale.h>

class Matrix
{protected:
  float **InitMatrix;
   int ISizeOfMatrix;
   int JSizeOfMatrix;
public:
	friend std::istream &operator>>(std::istream &Stream,Matrix &a)
	{
		for (int NumberI = 0;NumberI<a.ISizeOfMatrix;NumberI++){
			for (int NumberJ = 0;NumberJ<a.JSizeOfMatrix;NumberJ++){
				std::cout<<"a["<<NumberI<<"]"<<"["<<NumberJ<<"] = ";
              Stream>>a.InitMatrix[NumberI][NumberJ];
			  }
			
		}
		return Stream;
	
	}
	 friend std::ostream &operator<<(std::ostream &Stream,Matrix &a)
	{
		for (int NumberI = 0;NumberI<a.ISizeOfMatrix;NumberI++)
		{
			for (int NumberJ = 0;NumberJ<a.JSizeOfMatrix;NumberJ++)
			{
				std::cout<<"a["<<NumberI<<"]"<<"["<<NumberJ<<"] = ";
			    Stream<<a.InitMatrix[NumberI][NumberJ];
			}
			Stream<<std::endl;
		
		}
		return Stream;
	}
	 Matrix(int SizeI ,int  SizeJ)
{       ISizeOfMatrix = SizeI;
	    JSizeOfMatrix = SizeJ;
           InitMatrix = new float*[ISizeOfMatrix];
		for (int Number = 0;Number<ISizeOfMatrix;Number++)
		{
			InitMatrix[Number] = new float[JSizeOfMatrix];
		}
		   
	
		
		}
	
	  ~Matrix()
	 {
		 delete this->InitMatrix;
	 
	 
	 }
	 
    Matrix& operator+(Matrix &Element)
	{ 
		
		 if((this->ISizeOfMatrix != Element.ISizeOfMatrix) ||(this->JSizeOfMatrix != Element.JSizeOfMatrix)){
             std::cout << "Different sizes" << std::endl;
             return *this;
         }
       
         for (int NumberI = 0;NumberI<this->ISizeOfMatrix; NumberI++){
             for (int NumberJ = 0;NumberJ<this->JSizeOfMatrix;NumberJ++){
                this->InitMatrix[NumberI][NumberJ] +=Element.InitMatrix[NumberI][NumberJ];
             }
         }
         return *this;
     
     }
	Matrix& operator=(Matrix &Element)
	{
		for (int NumberI = 0;NumberI<this->ISizeOfMatrix;NumberI++){
		
			for (int NumberJ = 0;NumberJ<this->JSizeOfMatrix;NumberJ++)
			{
			this->InitMatrix[NumberI][NumberJ] = Element.InitMatrix[NumberI][NumberJ];
			
			
			}}
			
		return *this;
	
	
	}
	
	void print(){
		for (int NumberI = 0;NumberI<ISizeOfMatrix;NumberI++)
		{
			for (int NumberJ = 0; NumberJ<JSizeOfMatrix;NumberJ++)
			
			{
			std::cout<<this->InitMatrix[NumberI][NumberJ]<<std::endl;
			
			}
		
		}
	
	
	}
 
};

int main(int argc, _TCHAR* argv[])
{
	setlocale(2,"rus");
	Matrix a(2,2);
	std::cin>>a;
	std::cout<<a;
	Matrix b(2,2);
	std::cin>>b;
   std::cout<<a+b;
	
	

	
	system("pause");
	return 0;
}

[waspyd]

только теперь у оператора "+" совсем иное значение, не?

[valeologiya]

Сообщение от proef

спасибо )
как обращаться в элементу матрицы?
почему то когда пишу
std::cout<<(a+b);
выводит ошибку что :
Необработанное исключение по адресу 0x00D353CC в ConsoleApplication68.exe: 0xC0000005: нарушение прав доступа при чтении по адресу 0xFEEEFEF2.
вот код
на всякий случай

Проблемы была в том, что возврат оператора + был сделан по ссылке. Элемент создавался внутри обработчика, передавался и уничтожался деструктором. Таким образом, указатель указывал на пустую память.

Ещё я подправил твой деструктор. Правильно очищать память так.

А вот вопрос с обращением к элементу матрицы (именно через операторы, можно, конечно, функцией) я смог решить только создав дополнительный класс MatrixColumn. Представляю на всеобщий суд получившийся код.

//#include "stdafx.h"
#include <iostream>
#include <locale.h>

class MatrixColumn{
    int ISizeOfMatrix, JSizeOfMatrix;
    float **InitMatrix;
protected:
        int JIndex;
public:
        MatrixColumn(int SizeI ,int  SizeJ, float** Matrix)
            : ISizeOfMatrix(SizeI), JSizeOfMatrix(SizeJ),
              InitMatrix(Matrix){}
        void setJIndex(int Index){
            JIndex = Index;
        }

        float& operator[](int i){
            return InitMatrix[i][JIndex];
        }
};


class Matrix
{
    MatrixColumn* pTempColumn;
protected:
    float **InitMatrix;
    int ISizeOfMatrix;
    int JSizeOfMatrix;
public:
    Matrix(int SizeI ,int  SizeJ)
    {
        ISizeOfMatrix = SizeI;
        JSizeOfMatrix = SizeJ;
        InitMatrix = new float*[ISizeOfMatrix];
        for (int Number = 0;Number<ISizeOfMatrix;Number++)
            InitMatrix[Number] = new float[JSizeOfMatrix];
        pTempColumn = new MatrixColumn(SizeI, SizeJ, InitMatrix);
    }
    ~Matrix()
    {
        for (int Number = 0;Number<ISizeOfMatrix;Number++)
            delete InitMatrix[Number];
        delete this->InitMatrix;
        delete pTempColumn;
    }
    friend std::istream &operator>>(std::istream &Stream,Matrix &a)
    {
        for (int NumberI = 0;NumberI<a.ISizeOfMatrix;NumberI++){
            for (int NumberJ = 0;NumberJ<a.JSizeOfMatrix;NumberJ++){
                std::cout<<"a["<<NumberI<<"]"<<"["<<NumberJ<<"] = ";
                Stream>>a.InitMatrix[NumberI][NumberJ];
             }
        }
        return Stream;
    }
    friend std::ostream &operator<<(std::ostream &Stream, Matrix a)
    {
        for (int NumberI = 0;NumberI<a.ISizeOfMatrix;NumberI++)
        {
            for (int NumberJ = 0;NumberJ<a.JSizeOfMatrix;NumberJ++)
            {
                std::cout << "a[" << NumberI << "]" << "[" << NumberJ << "] = ";
                Stream << a.InitMatrix[NumberI][NumberJ] << " ";
            }
            Stream<<std::endl;
        }
        return Stream;
    }
    Matrix  operator+(Matrix &Element)
    {
         if((this->ISizeOfMatrix != Element.ISizeOfMatrix) ||
            (this->JSizeOfMatrix != Element.JSizeOfMatrix)){
             std::cout << "Different sizes" << std::endl;
             return *this;
         }
         Matrix Result(this->ISizeOfMatrix, this->JSizeOfMatrix);
         for (int NumberI = 0;NumberI<this->ISizeOfMatrix; NumberI++){
             for (int NumberJ = 0;NumberJ<this->JSizeOfMatrix;NumberJ++){
                 Result.InitMatrix[NumberI][NumberJ] =
                     this->InitMatrix[NumberI][NumberJ] + Element.InitMatrix[NumberI][NumberJ];
             }
         }
         return Result;
    }

    Matrix& operator=(Matrix &Element) {
        for (int NumberI = 0;NumberI<this->ISizeOfMatrix;NumberI++) {
            for (int NumberJ = 0;NumberJ<this->JSizeOfMatrix;NumberJ++) {
                this->InitMatrix[NumberI][NumberJ] = Element.InitMatrix[NumberI][NumberJ];
            }
        }
        return *this;
    }
    MatrixColumn& operator[](int j){
        pTempColumn->setJIndex(j);
        return *pTempColumn;
    }
};

//int main(int argc, _TCHAR* argv[])
int main(int argc, char* argv[])
{
    setlocale(2,"rus");
    Matrix a(2,2);
    std::cin>>a;
    std::cout<<a;
    std::cout << "a[1][1] = " << a[1][1] << endl;
    Matrix b(2,2);
    std::cin>>b;
    std::cout << (a+b);




//	system("pause");
    return 0;
}

[valeologiya]

Сообщение от still_alive

Ну ты че-то тут перегнул. В духе С++ обычно:

• не использовать такой убогий хедер conio.h
• вместо stdlib.h подключать cstdlib
• не засорять пространство имен
• не объявлять в неполиморфном классе protected-члены
• не использовать голые указатели
• проверять корректность данных
• не заполнять мусором матрицу в конструкторе
• объявлять константным все, что можно
• избегать возможных накладных расходов при присваивании самому себе
• освобождать выделенную память

С чем-то согласен, с чем-то поспорил бы. В любом случае, это другая тема.

[still_alive]

Сообщение от valeologiya

С чем-то согласен, с чем-то поспорил бы. В любом случае, это другая тема.

Поспорить тут можно разве что по поводу protected-членов. Потому что можно захотеть использовать наследование, не собираясь использовать полиморфное поведение.