Ayuda con estos 3 Programas

[Gerik]

Código (cpp) [Seleccionar] Expandir

/ 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] Expandir

// 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] Expandir

// 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

[h0oke]

Sólo son 2 programas, y un archivo de cabecera...

¿Qué hacen? Lee los comentarios... está bien documentado... Otra opción es que los compiles y lo veas step by step...

[Eternal Idol]

Es un solo programa, intenta compilarlo.