Código (cpp) [Seleccionar]
/ PROG0613.CPP - Suma de polinomios dependientes de dos variables
//
#include <iostream.h>
#include "cpolinom.h" // clases CTermino y CPolinomio
CTermino *IntroducirTermino( void );
void main() // función principal
{
CPolinomio PolinomioA, PolinomioB, PolinomioR;
CTermino *ptx; // puntero a un término
cout << "Términos del polinomio A\n"
<< "(para finalizar introduzca 0 para el\n"
<< "coeficiente y para los exponentes):\n\n";
ptx = IntroducirTermino();
while ( ptx )
{
PolinomioA.AsignarTermino( ptx );
ptx = IntroducirTermino();
}
cout << "Términos del polinomio B\n"
<< "(para finalizar introduzca 0 para el\n"
<< "coeficiente y para los exponentes):\n\n";
ptx = IntroducirTermino();
while ( ptx )
{
PolinomioB.AsignarTermino( ptx );
ptx = IntroducirTermino();
}
PolinomioR = PolinomioA + PolinomioB;
cout << "\nPolinomio A: "; cout << PolinomioA;
cout << "\nPolinomio B: "; cout << PolinomioB;
cout << "\nPolinomio R: "; cout << PolinomioR
<< " = " << PolinomioR(1, 1);
cout << endl;
double v = PolinomioR; // valor del polinomio para x = 1 e y = 1
cout << "Para x = 1 " << " el valor del polinomio es: "
<< v << endl;
}
CTermino *IntroducirTermino()
{
CTermino *ptx = NULL;
float coef;
int expx, expy;
cout << "Introduce coeficiente: "; cin >> coef;
cout << "Introduce exponente en X: "; cin >> expx;
cout << "Introduce exponente en Y: "; cin >> expy;
cout << endl;
if ( !coef && !expx && !expy ) return NULL;
ptx = new CTermino( coef, expx, expy );
return ptx;
}
EI: juntando mensajes.
Código (cpp) [Seleccionar]
// CPOLINOM.H - Declaración de las clases CTermino y CPolinomio
//
#if !defined( _CPolinom_H_ )
#define _CPolinom_H_
#include <stdlib.h>
/////////////////////////////////////////////////////////////////
// Clase para manipular un término de un polinomio cualquiera.
class CTermino
{
protected:
float Coeficiente; // coeficiente
int ExponenteDeX; // exponente de x
int ExponenteDeY; // exponente de y
public:
CTermino( float coef = 0.0, int expx = 1, int expy = 1 ) :
Coeficiente(coef), ExponenteDeX(expx), ExponenteDeY(expy) {}
float ObtenerCoeficiente() { return Coeficiente; }
int ObtenerExponenteDeX() const { return ExponenteDeX; }
int ObtenerExponenteDeY() const { return ExponenteDeY; }
void VisualizarTermino() const;
};
//////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////
// Clase para manipular ecuaciones algebraicas o polinómicas
// dependientes de dos variables.
class CPolinomio
{
friend ostream &operator<<( ostream &, const CPolinomio & );
private:
int NroTerminosMax; // número máximo de términos
int NroTerminosAct; // número de términos que hay actualmente
CTermino **ppTermino; // array de punteros
void copiar( CTermino *&p, CTermino *&q );
public:
CPolinomio(); // constructor
CPolinomio(const CPolinomio &); // constructor copia
~CPolinomio(); // destructor
CPolinomio operator=(const CPolinomio &); // operador =
int ObtenerNroTerminosAct() { return NroTerminosAct; }
void AsignarTermino( CTermino *pterm );
CPolinomio operator+( CPolinomio & ); // operador +
double operator()( double x = 1, double y = 1 ); // operador ()
operator double(); // operador de conversión
void ErrorMem( void )
{
cerr << "Insuficiente memoria\n";
exit( -1 );
}
};
//////////////////////////////////////////////////////////////////
#endif // _CPolinom_H_EI: juntando mensajes.
Código (cpp) [Seleccionar]
// CPOLINOM.CPP - Implementación de las clases CTermino
// y CPolinomio
//
#include <iostream.h>
#include <math.h>
#include <string.h>
#include <stdlib.h>
#include "cpolinom.h" // clases CTermino y CPolinomio
/////////////////////////////////////////////////////////////////
// Visualizar un término
void CTermino::VisualizarTermino() const
{
cout << ((Coeficiente < 0) ? " - " : " + ")
<< fabs(Coeficiente);
if ( ExponenteDeX ) cout << "x^" << ExponenteDeX;
if ( ExponenteDeY ) cout << "y^" << ExponenteDeY;
}
/////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////
// Constructor
CPolinomio::CPolinomio()
{
NroTerminosMax = 10;
NroTerminosAct = 0;
// Reservamos inicialmente espacio para NroTerminosMax términos
ppTermino = new CTermino *[ NroTerminosMax ];
if ( ppTermino == NULL ) ErrorMem();
for ( int i = 0; i < NroTerminosMax; i++ )
ppTermino[i] = NULL;
}
// Destructor
CPolinomio::~CPolinomio()
{
// Liberar la memoria ocupada por el polinomio
for ( int i = 0; i < NroTerminosAct; i++ )
delete ppTermino[i];
delete [] ppTermino;
}
// Copiar un termino del polinomio en otro
void CPolinomio::copiar( CTermino *&p, CTermino *&q )
{
p = (CTermino *) new CTermino( q->ObtenerCoeficiente(),
q->ObtenerExponenteDeX(),
q->ObtenerExponenteDeY());
if ( p == NULL ) ErrorMem();
}
// Constructor copia
CPolinomio::CPolinomio(const CPolinomio &pol)
{
NroTerminosMax = pol.NroTerminosMax;
NroTerminosAct = pol.NroTerminosAct;
ppTermino = new CTermino *[ NroTerminosMax ];
if ( ppTermino == NULL ) ErrorMem();
for ( int i = 0; i < NroTerminosMax; i++ )
ppTermino[i] = NULL;
for ( i = 0; i < NroTerminosAct; i++ )
copiar( ppTermino[i], pol.ppTermino[i] );
}
// Operador de asignación
CPolinomio CPolinomio::operator=(const CPolinomio &pol)
{
// Liberar la memoria del polinomio destino. Este orden es
// fundamental porque el origen puede tener diferente número de
// términos.
for ( int i = 0; i < NroTerminosAct; i++ )
delete ppTermino[i];
delete [] ppTermino;
// Copiar el origen en el nuevo destino
NroTerminosMax = pol.NroTerminosMax;
NroTerminosAct = pol.NroTerminosAct;
ppTermino = new CTermino *[ NroTerminosMax ];
if ( ppTermino == NULL ) ErrorMem();
for ( i = 0; i < NroTerminosMax; i++ )
ppTermino[i] = NULL;
for ( i = 0; i < NroTerminosAct; i++ )
copiar( ppTermino[i], pol.ppTermino[i] );
return *this;
}
// Asigna un término al polinomio colocándolo en orden ascendente
// de los exponentes de x y de y (expx*100+expy). Si no hay espacio
// para el nuevo término se incrementa el tamaño del polinomio en
// dos términos.
void CPolinomio::AsignarTermino( CTermino *pterm )
{
if ( pterm->ObtenerCoeficiente() == 0 )
{
delete pterm; // liberar la memoria del término no insertado
return;
}
if ( abs(pterm->ObtenerExponenteDeX()) > 99 ||
abs(pterm->ObtenerExponenteDeY()) > 99 )
{
cerr << "-99 <= exp <= 99" << endl;
delete pterm; // liberar la memoria del término no insertado
return;
}
if ( NroTerminosAct == NroTerminosMax )
{
// Incrementar el array en 2 elementos
CTermino **ppTemp = new CTermino *[ NroTerminosMax + 2 ];
if ( ppTemp == NULL ) ErrorMem();
for ( int i = 0; i < NroTerminosMax + 2; i++ )
ppTemp[i] = NULL;
for ( i = 0; i < NroTerminosAct; i++ )
ppTemp[i] = ppTermino[i];
delete [] ppTermino;
ppTermino = ppTemp;
NroTerminosMax += 2;
}
// Insertar un nuevo término en orden ascendente de los exps.
int i = NroTerminosAct - 1;
int expXT = pterm->ObtenerExponenteDeX();
int expYT = pterm->ObtenerExponenteDeY();
while ( i >= 0 && (expXT * 100 + expYT <
ppTermino[i]->ObtenerExponenteDeX() * 100 +
ppTermino[i]->ObtenerExponenteDeY()) )
{
ppTermino[i+1] = ppTermino[i];
i--;
}
ppTermino[i+1] = pterm;
NroTerminosAct++;
}
// Sumar dos polinomios. Sobrecarga del operador +.
CPolinomio CPolinomio::operator+( CPolinomio &polB )
{
int ipa = 0, ipb = 0;
int na = NroTerminosAct, nb = polB.NroTerminosAct;
float coefA, coefB;
int expXA, expYA, expXB, expYB;
CPolinomio polR;
// Sumar polA con polB
while ( ipa < na && ipb < nb )
{
coefA = ppTermino[ipa]->ObtenerCoeficiente();
expXA = ppTermino[ipa]->ObtenerExponenteDeX();
expYA = ppTermino[ipa]->ObtenerExponenteDeY();
coefB = polB.ppTermino[ipb]->ObtenerCoeficiente();
expXB = polB.ppTermino[ipb]->ObtenerExponenteDeX();
expYB = polB.ppTermino[ipb]->ObtenerExponenteDeY();
if ( expXA == expXB && expYA == expYB )
{
polR.AsignarTermino(
new CTermino(coefA + coefB, expXA, expYA) );
ipa++, ipb++;
}
else if ( expXA * 100 + expYA < expXB * 100 + expYB )
{
polR.AsignarTermino( new CTermino(coefA, expXA, expYA) );
ipa++;
}
else
{
polR.AsignarTermino( new CTermino(coefB, expXB, expYB) );
ipb++;
}
}
// Términos restantes en el polA
while ( ipa < na )
{
coefA = ppTermino[ipa]->ObtenerCoeficiente();
expXA = ppTermino[ipa]->ObtenerExponenteDeX();
expYA = ppTermino[ipa]->ObtenerExponenteDeY();
polR.AsignarTermino( new CTermino(coefA, expXA, expYA) );
ipa++;
}
// Términos restantes en el polB
while ( ipb < nb )
{
coefB = polB.ppTermino[ipb]->ObtenerCoeficiente();
expXB = polB.ppTermino[ipb]->ObtenerExponenteDeX();
expYB = polB.ppTermino[ipb]->ObtenerExponenteDeY();
polR.AsignarTermino( new CTermino(coefB, expXB, expYB) );
ipb++;
}
return polR;
}
// Visualizar los términos de un polinomio.
// Operador de inserción.
ostream &operator<<( ostream &os, const CPolinomio &polX )
{
int i = polX.NroTerminosAct;
while ( i-- )
if ( polX.ppTermino[i]->ObtenerCoeficiente() )
polX.ppTermino[i]->VisualizarTermino();
return os;
}
// Operador llamada a función
double CPolinomio::operator()( double x, double y )
{
double v = 0;
for ( int i = 0; i < NroTerminosAct; i++ )
v += ppTermino[i]->ObtenerCoeficiente() *
pow(x, ppTermino[i]->ObtenerExponenteDeX()) *
pow(y, ppTermino[i]->ObtenerExponenteDeY());
return v;
}
// Operador de conversión de CPolinomio a double
CPolinomio::operator double()
{
return (*this)();
}Supuestamente Los 3 Programas Generan Uno Solo alguien me podria explicar maso que estan haciendo cada uno