Classes Combinadas

[Sol]

Ola! Preciso de ajuda com meu programa. Por favor!

Tenho 3 Classes: Complexo: que faz operações entre números complexos, Matriz: cria matriz de complexos e faz operações entre matrizes Por ultimo, criei a Classe sistema que possui métodos para calcular a resolução de um sistema linear pelo método iterativo de Gauss, sendo os elementos da Matriz (Sistema) todos complexos. Até ai ok.

O meu bug esta a ser em manipular as coisas no Main.cpp
Preciso: primeiro verificar convergencia(), depois se convergir faço o calculo pelo metodo Gauss(). Por ultimo exibir a solução dada pelo metodo resultados(). Com duas classes fui até bem. Com tres já estou a misturar as coisas.

#define _CRT_SECURE_NO_WARNINGS

    #include<stdio.h>
    #include"Complexo.h"
    #include"Matriz.h"
    #include"Sistema.h"

   `insira o código aqui`int main()
    {

Matriz AB,X;
Sistema Y;


AB.lerMatriz();
AB.escreverMatriz();

Y = AB;

// verificar convergencia da matriz A

if (Y.convergencia())
{
    printf("\nSistema pode ser calculado pelo metodo iterativo de Gauss-Siedel\n");
}

// se convergencia ok calcular gauss

  }

#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 = float(pow(modulo(), exp));
	p.re = float(mod * cos(exp * argumento()));
	p.im =float( 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 
 {
  friend class Sistema;
  private:
  Complexo** elems;               // elementos da matriz  
  int nlin, ncol;               // número de linhas e colunas
  public:

void inicia();                    // função para iniciar matriz
void delete_matriz();             // função para apagar matriz

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"
#include"Sistema.h"

void Matriz::inicia()
{
	elems = new Complexo * [nlin];

	for (int i = 0; i < nlin; i++) {
		elems[i] = new Complexo[ncol];
	}
}
void Matriz::delete_matriz()
{
	for (int i = 0; i < nlin; i++) {
		delete[] elems[i];
	}
	delete[] elems;

}

Matriz::Matriz() //um construtor por omissão(a ordem da matriz é definida posteriormente)
{
	nlin = 1;
	ncol = 1;
	inicia();
}
Matriz::Matriz(int lin, int col)    //um construtor que recebe a ordem da matriz e cria uma matriz com elementos a zero
{
	delete_matriz();
	nlin = lin;
	ncol = col;
	inicia();
}
Matriz::Matriz(const Matriz& m2)    //um construtor por cópia
{
	nlin = m2.nlin;
	ncol = m2.ncol;
	inicia();
	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
{
	delete_matriz();
}
void Matriz::lerMatriz()
{
	delete_matriz();
	printf("Digite a ordem da Matriz Aumentada. Numero de linha e numero de colunas respectivamente\n\n");
	printf("OBS: O numero de linhas da matriz aumentada corresponde ao numero de esquacoes do sistema\n");
	printf("O numero de colunas = numero de linhas +1\n");
	scanf("%d %d", &nlin, &ncol);
	inicia();


	for (int i = 0; i < nlin; i++)
	{

		for (int j = 0; j < ncol; j++)
		{
			printf("\nDigite a posicao %dx%d da Matriz AB\n", i + 1, j + 1);
			elems[i][j].lerComplexo();
		}
	}
}

void Matriz::escreverMatriz()
{
	printf("\n");
	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)
{
	return (nlin == m2.nlin && ncol == m2.ncol);

}

bool Matriz::podeMultiplicar(const Matriz& m2)
{
	return (ncol == m2.nlin);

}




Matriz& Matriz::operator = (const Matriz& m2)// Operador Igual
{
	delete_matriz();
	nlin = m2.nlin;
	ncol = m2.ncol;

	inicia();
	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 mat(nlin, ncol);

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

Matriz Matriz::operator*(const Matriz& m2)
{
	Matriz mat(nlin, m2.ncol);

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

#pragma once
#include "Complexo.h"
#include "Matriz.h"


class Sistema
{
friend class Matriz;
private:

int ordem;
public: 
Sistema() { Matriz(); }
Matriz Matriz_AB;// matriz aumentada
Matriz X; // vetor de icognitas
void gauss();
bool convergencia();
void resultados();
};

#define _CRT_SECURE_NO_WARNINGS
#define max_iter 100 //número máximo de iterações admissível
#define tol 0.0001 //erro máximo admitido

#include<stdio.h>
#include "Sistema.h"
#include "Matriz.h"
#include "Complexo.h"
#include <math.h>


void Sistema::gauss()
{
	Matriz X(ordem, 1);//vector das incógnitas na iteração actual 
	Complexo x_antigo; //valor da incógnita na iteração anterior
	Complexo soma;
	float erro_x = 0; // erro_x - o erro da incógnita 
	float erro_iter = 0; //erro_iter - erro da iteração
	int niter = 0; //numero de iteracoes

	do {
		niter++;
		float erro_iter = 0;

		for (int i = 0; i < ordem; i++)
		{
			x_antigo = X.elems[i][0];
			//soma =0
			for (int j = 0; j < ordem; j++)
			{
				if (j != i)
					soma = soma + (Matriz_AB.elems[i][j] * X.elems[j][1]);
			}
			X.elems[i][1] = (Matriz_AB.elems[i][ordem]) - (soma) / Matriz_AB.elems[i][i];
			erro_x = (X.elems[i][0] - x_antigo).modulo();
			if (erro_x > erro_iter)
				erro_iter = erro_x;
		}

	} while (erro_x > tol && niter < max_iter);//ver erro x
	return X;
}



bool Sistema::convergencia()
{
	Complexo soma;
	for (int i = 0; i < ordem; i++)
	{
		for (int j = 0; j < ordem; j++)
		{
			if (j != i)
				soma = soma + Matriz_AB.elems[i][j];

		}
		if (Matriz_AB.elems[i][i].modulo() > soma.modulo())
			return true;
		else
			return false;

	}
}

void Sistema::resultados()
{
	for(int i=0;i<ordem;i++)
	X.elems[i][1].imprimir();
}

[M6]

Qual é o teu bug? O que é que dá e o que devia dar?

Tens de ser claro e concreto nas dúvidas que colocas.

[Sol]

11 horas atrás, M6 disse:

Qual é o teu bug? O que é que dá e o que devia dar?

Tens de ser claro e concreto nas dúvidas que colocas.

Ola! Não estou a ter um bug no programa. Realmente nao fui clara. Eu criei a classe Sistema. Preciso de no main.cpp, chamar o metodo Gauss() que pertence a classe Sistema de forma a fazer os calculos com a matriz AB que é inserida pelo usuario. A matriz AB, é um objeto do tipo Matriz. Eu nao posso fazer coisas do tipo: AB.gauss(). Preciso chamar o metodo Gauss passando AB como parametro. Não sei como fazer isso. Tambem tentei criar um objeto do tipo Sistema, ex: Sistema Y. E tentei coisas do tipo: Y=AB e daí fazer Y.gauss(). Porem ao igualar os dois objetos da erro. Nao verdade o programa nao bugou ainda, fui eu. 

[Procrastinator]

Fazer Y = AB; ñ faz sentido já que sãi tipos diferentes.

Eu ñ percebo o uso de funções de C num programa C++.

Talvez brincar um pouco no compiler explorer com algo mais simples para tentar perceber o que podes fazer.