Operações sobre matrizes de complexos

[Sol]

Ola! Estou com um TP da faculdade em que tenho duas classes: Complexo e Matriz.
O programa final deve exibir a soma e a multiplicação de duas matrizes de numeros complexos.
O programa nao da erro porem nao exibe a soma e a multiplicação das matrizes. Alguem poderia ajudar-me?

#pragma once  
class Complexo
{
private:
	float re, im;
public:
	Complexo();   // Construtor cria um número nulo  
	Complexo(float r, float i);

	void atribuir(float r, float i);
	void lerComplexo();  // ler complexo do teclado  
	void imprimir();   // escrever complexo para o monitor  

	float real() { return re; } // devolve coeficiente real  
	float imaginario() { return im; } // devolve coeficiente imaginário  
	float modulo();  // devolve módulo do número  
	float argumento(); // devolve argumento do número  
	Complexo conjugado();  // devolve o conjugado do número  
	Complexo simetrico();  // devolve o simétrico do número 
	Complexo potencia(float exp);  // devolve potência do número 

	// operações entre 2 complexos  
	Complexo operator +(const Complexo& c); // adição   
	Complexo operator -(const Complexo& c); // subtração  
	Complexo operator *(const Complexo& c); // multiplicação  
	Complexo operator /(const Complexo& c); // divisão     

	// operações entre um complexo (operador da esquerda) e um real (operador da  // direita)  
	Complexo operator *(float f);
	Complexo operator /(float f);

};

#define _CRT_SECURE_NO_WARNINGS

#include "Complexo.h"
#include<stdio.h>
#include<math.h>
Complexo::Complexo()
{
	re = 0;
	im = 0;
}

Complexo::Complexo(float r, float i)
{
	re = r;
	im = i;
}

void Complexo::atribuir(float r, float i)
{
	float novo_re = r;
	float novo_im = i;
}

void Complexo::lerComplexo()
{
	printf("Parte real:");
	scanf("%f", &re);
	printf("\n");
	printf("Parte imaginaria:");
	scanf("%f", &im);
	printf("\n");

}

void Complexo::imprimir()   // escrever complexo para o monitor  
{
	printf("%.1f +%.1fi\t", re, im);
}


float Complexo::modulo()  // devolve módulo do número 
{
	float m;
	m = float(sqrt(pow(re, 2) + pow(im, 2)));
	return m;
}
float Complexo::argumento() // devolve argumento do número 
{
	float arg;
	arg = float(atan2(im, re));
	return arg;
}

Complexo Complexo::conjugado()  // devolve o conjugado do número  
{
	Complexo c;
	c.re = re;
	c.im = -im;
	return c;
}
Complexo Complexo::simetrico()  // devolve o simétrico do numero
{
	Complexo s;
	s.re = re * (-1);
	s.im = im * (-1);
	return s;
}
Complexo Complexo::potencia(float exp)  // devolve potência do número
{
	Complexo p;
	float mod;
	mod = pow(modulo(), exp);
	p.re = mod * cos(exp * argumento());
	p.im = mod * sin(exp * argumento());
	return p;
}

// operações entre 2 complexos  
Complexo Complexo::operator +(const Complexo& c) // adição   
{
	Complexo res;
	res.re = re + c.re;
	res.im = im + c.im;
	return res;

}
Complexo Complexo::operator -(const Complexo& c) // subtração  
{
	Complexo res;
	res.re = re - c.re;
	res.im = im - c.im;
	return res;
}
Complexo Complexo::operator *(const Complexo& c) // multiplicação 
{
	Complexo res;
	res.re = re * c.re - im * c.im;
	res.im = re * c.im + im * c.re;
	return res;
}
Complexo Complexo::operator /(const Complexo& c) // divisão    
{
	Complexo num, den, res;
	num = Complexo(re, im);
	den = c;
	num = *this * den.conjugado();
	den = den * den.conjugado();
	return Complexo(num.re / den.re, num.im / den.re);



}

// operações entre um complexo (operador da esquerda) e um real (operador da  // direita)  

Complexo Complexo::operator *(float f)
{
	Complexo res;
	res.re = re * f;
	res.im = im * f;
	return res;

}
Complexo Complexo::operator /(float f)
{
	Complexo res;
	res.re = re / f;
	res.im = im / f;
	return res;

}

#pragma once  
#include "complexo.h"  
class Matriz {
private:
    Complexo** elems;               // elementos da matriz  
    int nlin, ncol;                 // número de linhas e colunas  
public:
    Matriz();                       //um construtor por omissão(a ordem da matriz é definida posteriormente)
    Matriz(int lin, int col);      //um construtor que recebe a ordem da matriz e cria uma matriz com elementos a zero
    Matriz(const Matriz& m2);    //um construtor por cópia
    ~Matriz();                  // Um destrutor para eliminar os dados dinâmicos da classe

    void lerMatriz();
    void escreverMatriz();

    bool podeSomar(const Matriz& m2);
    bool podeMultiplicar(const Matriz& m2);

   Matriz& operator=(const Matriz& m2);
   Matriz operator+(const Matriz& m2);
   Matriz operator*(const Matriz& m2);
};

#define _CRT_SECURE_NO_WARNINGS

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h>

#include "Matriz.h"

Matriz::Matriz() //um construtor por omissão(a ordem da matriz é definida posteriormente)
{
	nlin = 0;
	ncol = 0;
	elems = NULL;
}
Matriz::Matriz(int lin, int col)    //um construtor que recebe a ordem da matriz e cria uma matriz com elementos a zero
{
	nlin = lin;
	ncol = col;
	elems = new Complexo* [nlin];
	for (int i = 0; i < nlin; i++)
	{
		elems[i] = new Complexo[ncol];
		for (int j = 0; j < ncol; j++)
		{
			elems[i][j]=Complexo();
		}
	}
}
Matriz::Matriz(const Matriz& m2)    //um construtor por cópia
{
	Matriz(m2.nlin, m2.ncol);
	for (int i = 0; i < nlin; i++)
		for (int j = 0; j < ncol; j++)
			elems[i][j] = m2.elems[i][j];
}
Matriz::~Matriz()                  // Um destrutor para eliminar os dados dinâmicos da classe
{
	for (int i = 0; i < nlin; i++)
		delete elems[i];
	delete[]elems;
}
void Matriz:: lerMatriz()
{
	printf("Digite a ordem da matriz. Numero de linha e numero de colunas respectivamente\n");
	scanf("%d %d", &nlin, &ncol);
	elems = new Complexo* [nlin];

	for (int i = 0; i < nlin; i++)
	{
		elems[i] = new Complexo[ncol];
		for (int j = 0; j < ncol; j++)
		{
			printf("\nDigite a posição %dx%d da Matriz\n",i+1,j+1);
			elems[i][j].lerComplexo();
		}
	}
}

void Matriz::escreverMatriz()
{
	for (int i = 0; i < nlin; i++)
	{
		
		for (int j = 0; j < ncol; j++)
		{
			elems[i][j].imprimir();
		}
		printf("\n");
	}
}


bool Matriz::podeSomar(const Matriz& m2)
{
	if (nlin == m2.nlin && ncol == m2.ncol)
		return true;
	else
		return false;
}

bool Matriz::podeMultiplicar(const Matriz& m2)
{
	if (ncol == m2.nlin)
		return true;
	else
		return false;
}




Matriz& Matriz::operator = (const Matriz& m2)// Operador Igual
{
	
	Matriz(m2.nlin, m2.ncol);
	for (int i = 0; i < nlin; i++)
		for (int j = 0; j < ncol; j++)
			elems[i][j] = m2.elems[i][j];
	return *this;
}


Matriz Matriz::operator + (const Matriz& m2)
{
	Matriz res(m2.nlin,m2.ncol);
	for (int i = 0; i < nlin; i++)
		for (int j = 0; j < ncol; j++)
		{
			res.elems[i][j] = elems[i][j] + m2.elems[i][j];
		}
	return res;
}

Matriz Matriz::operator*(const Matriz& m2)
{
	Matriz res(m2.nlin,m2.ncol); // matriz resultado

	for (int i = 0; i < m2.nlin; i++)
		for (int j = 0; j < m2.ncol; j++)
		{
				res.elems[i][j] = m2.elems[i][j] + (elems[i][j] * m2.elems[i][j]);
		}
	return res;
}

#define _CRT_SECURE_NO_WARNINGS

#include<stdio.h>
#include"Complexo.h"
#include"Matriz.h"
#include"Complexo.h"
int main()
{
	Matriz A, B, C;

	A.lerMatriz();
	A.escreverMatriz();

	B.lerMatriz();
	B.escreverMatriz();

	if ((A.podeSomar(B)) != 0)
	{
		C = A + B;
		C.escreverMatriz();	
	}
	else
	{
		printf("\nSOMA NAO PODE SER EFETUADA");
	}


	if ((A.podeMultiplicar(B)) != 0)
	{
		C = A * B;
		C.escreverMatriz(); 
		
	}
		else
		{
		printf("\nMULTIPLICACAO NAO PODE SER EFETUADA");
		}
}

[Rui Carlos]

Experimenta correr o código com um debugger, coloca um breakpoint no operador de soma, e verifica se o mesmo está a ser executado como esperavas.

[antseq]

Matriz& Matriz::operator = (const Matriz& m2)// Operador Igual
{
	Matriz(m2.nlin, m2.ncol); 
	for (int i = 0; i < nlin; i++)
		for (int j = 0; j < ncol; j++)
			elems[i][j] = m2.elems[i][j];
	return *this;
}

já estou meio "enferrujado" nisto de operadores c++, mas o erro não estará aqui no operador "="?