Jump to content
Sol

Operações sobre matrizes de complexos

Recommended Posts

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");
		}
}

 

Share this post


Link to post
Share on other sites
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.

Share this post


Link to post
Share on other sites
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 "="?

Share this post


Link to post
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now

×
×
  • Create New...

Important Information

By using this site you accept our Terms of Use and Privacy Policy. We have placed cookies on your device to help make this website better. You can adjust your cookie settings, otherwise we'll assume you're okay to continue.