Temas

Bueno necesito trabjar una llave optica S525
http://search.digikey.com/scripts/DkSearch/dksus.dll?Detail&name=425-2680-5-ND

alguien sabe como se debe conectar ??

[Ahora mi duda es como puedo hacer para que el micro se de cuenta de que la rueda esta andando hacia adelante o hacia atras]

Bueno tengo que hacer un odometro con el Pic 16F84A para mi clase de Microcontroladores el proyecto debe hacer basicamente lo siguiente:
1.si la rueda va hacia adelante contar cuanto avanzo
2.si rueda va hacia atras decrementar lo avanzado.
3.1 pulsador para guardar un dato, otro para visualizar ese dato.
4 la visualizacion se muestra en 3 displays.


"La solucion pensada po mi es hacer una rueda de un perimetro por decir 30cm y hacer huecos cada 2 cm cerca al borde de la rueda, y pues usar un contador optico para que me genere las señales"

Ahora mi duda es como puedo hacer para que el micro se de cuenta de que la rueda esta andando hacia adelante o hacia atras

PD: Todos los pines ocupados (7 pines para display, 3 mas para habilitarlos ya sea anodo o catodo,1para guardar el dato, 1 para mostrar ese dato, y el que sobra que sera el RA4/TOCK0 que sera el que reciba la señal del optocontador)

Bueno mi duda es que cada vez que enciendo o reinicio el PC no me reconoce el mouse y tengo que desconectar y conectar el mouse.
alguien sabe como puedo solucionar este problema???

Este programa crea o atiende clientes (lo hace random) lo maximo a crear o atender son 4 clientes ejem;

Se crearon n clientes (los muestra)
se atendieron n clientes (borra los atendidos de acuerdo TDA Cola)

ahora lo que intento hacer en modo grafico es mostar pero cuando intento mostrar con outtextxy (x,y,"string") siempre se sobreescribe ejem:
se crearon # clientes
# es donde se sobreescriba obviamente al llmar a la funcion
como podria borrar solo esa parte
no se si me hice entender (dejo el codigo asi es mas facil de entender lo que quiero hacer xD)

Código (cpp) [Seleccionar] Expandir

#include <conio.h>
#include <iostream.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

class Nodo
  {Nodo *sig;
   int id;
   public:
   Nodo()
       {sig=NULL;}
   Nodo(int id)
       {sig=NULL;
        setId(id);}
  Nodo* getNodo()
       {return sig;}
  void setNodo(Nodo *siguiente)
       {sig=siguiente;}
   int getId()
    {return id;}
   void setId(int valor)
    {id=valor;}
   };

class Lista
   {Nodo *inicio, *final;
    int  cantidad;
    public:
    Lista()
         {inicio=NULL;
          final=NULL;
          cantidad=0;}
   Nodo * getinicio()
       {return inicio;}
   Nodo * getfinal()
       {return final;}
   int cantidadNodos()
       {return cantidad;}
   bool insertar(Nodo *nodo)
       {if(inicio==NULL)
          {inicio=nodo;
           final=nodo;}
        else
          {final->setNodo(nodo);
           final=nodo;}
        cantidad++;
        return true;}
   void mostrar()
       {if(inicio==NULL)
          {exit;}
        else
          {Nodo *p;
           p=inicio;
           int conta=1;
           int miprioridad=-1;
           cout<<endl;
           while(p!=NULL && conta<=cantidad)
               {cout<<"C"<<p->getId()<<"\t";
       p=p->getNodo();
                conta++;};
          }
       }
   void mostrarNodosDirecciones()
       {if(inicio==NULL)
          {exit;}
        else
          {Nodo *p;
           p=inicio;
           int conta=1;
           int miprioridad=-1;
           cout<<endl;
           while(p!=NULL && conta<=cantidad)
                {cout<<"Nodo C"<<p->getId()<<" Direccion --> "<< p <<" Nodo Sig-->  "<<p->getNodo()<<endl;
        p=p->getNodo();
                 conta++;};
           }
       }
   bool eliminarNodo(int total) //cantidad de nodos a eliminar
      {if(inicio==NULL ||  cantidad==0)
         {cout<<"Lista vacia "<<endl;
          return false;}
       else
         {if(total>cantidad)
            {cout<<endl<<"Solo puede eliminar como maximo "<< cantidad  <<" nodos."<<endl;
             return false;}
             int conta=1;
             Nodo *p;
             p=inicio;
             while(p!=NULL && total>0 && cantidad>0)
               {inicio=inicio->getNodo();
                   total--;
                   cantidad--;
                   delete p;
                   p=inicio;};
             if (cantidad==0)
                inicio=NULL;
             return true;
         }
      }
   bool eliminarNodo()
       {if(inicio==NULL || cantidad==0)
           return false;
        else
          {Nodo *p;
           p=inicio;
     inicio=inicio->getNodo();
           delete p;
           cantidad --;
           return true;}
       }
   };

class Simulacion
  {Lista servidor;
   Lista clientes;
   int  codigo;
   public:
   Simulacion()
      {codigo=0;}
   generarClientes(int cantidad)
      {for(int x=1;x<=cantidad;x++)
    {codigo++;
     Nodo *minodo=new Nodo(codigo);
     clientes.insertar(minodo);}
       }
   int cantidadClientes()
      {return clientes.cantidadNodos();}
   int atenderClientes()
      {int valor;
       if(clientes.cantidadNodos()==0)
          return 0;
       valor=random(4);
       clientes.eliminarNodo(valor);
       return valor;
      }
   mostrarClientes()
     {//clientes.mostrarNodosDirecciones() ;
      clientes.mostrar();}
   mostrarServidor()
      {}
   };

int main()
   {Simulacion lab;
    bool activo=true;
    int canti=0;
    randomize();
    int c=0;
    int turno=-1;
    c=getch();
    cout<<"Presione ENTER para continuar la simulacion y ESC para salir..."<<endl;
    while(c!=27)
         {//determinar si llegan clientes o si atienden
          turno=random(2);
          if(turno==1)
            {//crear clientes
             int cuantos=0;
             cuantos=random(5);
             lab.generarClientes(cuantos);
             cout<<endl<<"Se crearon  "<<cuantos<<"  clientes."<<endl;
             lab.mostrarClientes();}
          else
            {//atender clientes
             canti=lab.atenderClientes();
             cout<<endl<<"Cantidad a atender "<<canti<<endl;
             if (canti>0)
                 lab.mostrarClientes();
            }
          c=getch();
         }
  clrscr();
  cout<<endl<<"El servidor no admite mas clientes..."<<endl;
  if(lab.cantidadClientes()>0)
    {cout<<"Clientes pendientes por atender... "<< lab.cantidadClientes() <<endl;
     lab.mostrarClientes();
     while(lab.cantidadClientes()>0) //si quedan clientes atenderlos
      {canti=lab.atenderClientes();
          cout<<endl<<"Cantidad a atender "<<canti<<endl;
          lab.mostrarClientes();}
     cout<<endl<<"Se atendieron todos clientes..."<<endl;
    }
  getch();
  }


Compile este sencillo ejemplo y solo me ejecuta un pantallazo negro

Código (cpp) [Seleccionar] Expandir

#include <conio.h>
#include <iostream.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <graphics.h>

int main()
  {int driver=DETECT,mode;
   initgraph(&driver,&mode,"C:\BC5\BGI");
   int midx=getmaxx()/2,midy=getmaxy()/2;
   setbkcolor(5);
   outtextxy(midx,midy,"plop");
   getch();
   closegraph();
   return 0;
   }

Tengo cierto programa en modo texto, necesito hacer unas modificaciones para mostrar en modo grafico pero pocon pocon de ese modo si alguien me recomienda un tutorial le agradeceria

Basicamente El Programa Debe Hacer Una Lista Circular Con n nombres, y despues eliminarlo hasta que kede solo 1, el problema es que a veces toma como borrado un nodo sin haberlo eliminado (si me hice entender)

Código (cpp) [Seleccionar] Expandir

/*****************
Librerias
*****************/
#include <stdio.h>
#include <conio.h>
#include <iostream.h>
#include <stdio.h>
#include <stdlib.h>
/*Clase nodo*/
class nodo
     {public:
      char info[30];
    nodo *sig;
      nodo *generar_nodo(char a[30])
          {nodo *n;
        n=new nodo[30];
           strcpy(n->info,a);
        n->sig=NULL;
        return n;}
      };
/*Clase lista*/
class lista_circular
     {public:
      nodo *cab;
int cant;
      lista_circular()
         {cab=NULL;
          cant=0;}
      insertar(char a[30]);
      extraer(int dato2);
      mostrar();
     };
/*Inserta en la lista*/
lista_circular::insertar(char a[30])
    {char cad[30];
     strcpy(cad,a);
     nodo *nuevo=nuevo->generar_nodo(a);
     if(!cab)
       {cab=nuevo;
        cab->sig=nuevo;
        cant++;}
     else{nodo *p;
          p=cab;
          while(p->sig!=cab)
               {p=p->sig;}
          p->sig=nuevo;
          p=p->sig;
          p->sig=cab;
          cant++;}
     }
/*muestra la lista*/
lista_circular::mostrar()
    {nodo *p=cab;
  while(p->sig!=cab)
          {cout<<p->info<<endl;
         p=p->sig;}
     cout<<p->info<<endl;}//Cierro Mostrar

/*Extrae de la lista*/
lista_circular::extraer(int dato2)
    {if(cab)
       {nodo *p,*q;
      p=cab;
        if(dato2==cant-5)
           {while(p->sig!=cab)
                 {p=p->sig;}
         if(cab->sig==cab)
               {cab=NULL;
                cant--;}
         else{cab=cab->sig;
           p->sig=cab;
                 cant--;}
           }
        else{if(dato2==cant)
               {while(p->sig!=cab)
                    {p=p->sig;}
    p->sig=cab;
                cant--;}
             else{for(int i=0;i<dato2;i++)
                     {q=p;
             p=p->sig;}
              q->sig=p->sig;
                cant--;
                delete p;}}
}else{cout<<"  NO EXISTE LISTA\n";}
    }

main()
   {lista_circular obj;
    char nombre[30];
    int aux=0;
    for(int i=0;i<5;i++)
       {cout<<"Digite El Nombre "<<i<<" De La Lista: ";
          gets(nombre);
          cout<<endl;
          obj.insertar(nombre);}
    clrscr();
    obj.mostrar();
    int aux2=obj.cant-1;
    for(int i=0;i<aux2;i++)
       {clrscr();
        randomize();
      aux=random(obj.cant)+1;
      cout<<"Cantidad De Elementos "<<obj.cant<<endl<<"Se Elimino El Elemento "<<aux<<" De La Lista."<<endl<<"Lista Actual: "<<endl;
        obj.extraer(aux);
        obj.mostrar();
        getch();}
    getch();}

Tengo Un Problema al intentar Extraer un numero de la lista, me revienta memoria, alguien podria decirme por que es :S le he dado vueltas y nada

Código (cpp) [Seleccionar] Expandir

# include <conio>
# include <iostream>
# include <stdlib>
# define cant 4

class nodo
     {public:
      int info;
      nodo *sig;
      nodo(int a)
          {info=a;
           sig=NULL;}
      };
class listac
     {public:
      nodo *cab;
      listac(){cab=NULL;}
      void insertar(int a);
      void mostrar();
      bool buscar(int a);
      void extraer(int a);
      };

int main()
    {int a=0;
     listac obj;
     for(int i=1;i<=cant+1;i++)
         {cout<<"Digite El Elemento "<<i<<" De La Lista: ";
          cin>>a;
          cout<<endl;
          obj.insertar(a);}
     obj.mostrar();
     cout<<"Digite El Numero a Buscar: ";
     cin>>a;
     if(obj.buscar(a)==true)
        cout<<"El Numero Buscado Existe En La Lista";
     else
        cout<<"El Numero Buscado No Existe En La Lista";
     cout<<"Digite El Numero a Extraer De La Lista: ";
     cin>>a;
     obj.extraer(a);
     obj.mostrar();
     getch();
     return 0;
    }

void listac::insertar(int a)
    {nodo *nuevo=new nodo(a);
     if(!cab)
        {nuevo->sig=nuevo;
         cab=nuevo;}
        else
        {nuevo->sig=cab->sig;
         cab->sig=nuevo;}
    }//cierro Insertar
void listac::mostrar()
    {nodo *p=cab;
     do{p=p->sig;
        cout<<p->info<<" ";}
     while(p!=cab);
    }
bool listac::buscar(int a)
   {nodo *p=cab;
    do{p=p->sig;
       if(p->info==a)
          {return true;}}
       while (p!=cab);
       return false;}
void listac::extraer(int a)
     {nodo*p=cab;
      do{p=p->sig;
         if(p->info=a)
            {while(cab->sig!=p)
                  {cab=cab->sig;
                   cab->sig=p->sig;
                   delete p;
                   break;}//cierro while
            }//cierro if
        }//cierro do
        while (p!=cab);
     }



lo tenia en estatica se me dio por hacerlo a memoria dinamica y grabe encima ahora no encuentro el error, si alguien lo ve por fa ayudaaa es urgenteeeeeee

Código (cpp) [Seleccionar] Expandir

#include <iostream>
#include <conio>
#include <stdlib>
#define tama1 10
#define tama2 8
#define tama3 6
class Pila
     {public:
      int tope,y;
      int pila1[tama1];
      Pila(){tope=-1;
             y=0;}
      mostrar()
         {for(int i=0;i<tama1;i++)
                  {cout<<"\tPila1["<<i<<"]="<<pila1[i]<<endl;}}
      insertar(int a)
        {tope++;
         if(tope==tama1)
            {cout<<"\t\t\nPila llena "<<endl;
             tope--;}
         else {pila1[tope]=a;}
         }
      int sacar()
          {if(tope==-1)
           cout<<"\t\t\nPila Vacia ";
           else{
                y=pila1[tope];
                pila1[tope]=0;
                tope--;
                return y;
                cout<<"\n\tElemento Eliminado "; }
          }};
class Pil
     {public:
      int tope2,z;
      int pila2[tama2];
      Pil(){tope2=-1;}
       mostrar()
         {for(int i=0; i<tama2;i++)
                  {cout<<"\tPila2["<<i<<"]="<<pila2[i]<<endl;}}
       insertar(int a)
        {tope2++;
         if(tope2==tama2)
            {cout<<"\t\t\nPila llena "<<endl;
             tope2--;}
         else {pila2[tope2]=a;}
         }
       int sacar()
          {if(tope2==-1)
           cout<<"\t\t\nPila Vacia ";
           else{z=pila2[tope2];
                pila2[tope2]=0;
                tope2--;
                return z;
                cout<<"\n\tElemento Eliminado "; }
          }};
class Pi
     {public:
      int tope3;
      int pila3[tama3];
      Pi(int z)
          {tope3=-1;}
       mostrar()
         {for(int i=0; i<tama3;i++)
                  {cout<<"\tPila3["<<i<<"]="<<pila3[i]<<endl;}}
       insertar(int a)
        {tope3++;
         if(tope3==tama3)
            {cout<<"\t\t\nPila llena "<<endl;
             tope3--;}
         else {pila3[tope3]=a;}
         }
       int sacar()
          {if(tope3==-1)
           cout<<"\t\t\nPila Vacia ";
           else{pila3[tope3]=0;
                tope3--;
                cout<<"\n\tElemento Eliminado "; }
          }};
int main()
     {int x=0;
     Pila ob();
     Pil o();
     Pi obj();
     cout<<"\n\nInsercion de Elementos a la Pila1\n";
     randomize();
     while(x<tama1)
       {ob.insertar(random(10));
        x++;}
     ob.mostrar();
     getch();
     for(int i=0;i<tama2;i++)
         {o.insertar(ob.sacar());}
     o.mostrar();
     for(int i=0;i<tama3;i++)
         {obj.insertar(o.sacar());}
     obj.mostrar();
     getch();
     return 0;
     }

EI: juntando mensajes.

ya lo encontre jejeje el rpoblema eran los parentesis en los objetos del amin y el objeto de pi recibia parametro pero ya

Código (cpp) [Seleccionar] Expandir

#include <conio>
#include <iostream>
#include <stdlib>
#include <math>

class C
{public:
  int *c;
  int r;
  C(){c=new int [10];}
  Union(int q[10],int p[10],int a,int b);
  int suma(int q[10],int a);
  double promedio(int a,int b);
  double varianza(int a,int b);
  double desviacion(int a);
};
main ()
   {int a,z;
    int *conjuntoA;
    int *conjuntoB;
    conjuntoA=new int [10];
    conjuntoB=new int [10];
    cout<<"Digite El Numero De Elementos Del Conjunto A: ";
    cin>>a;
    cout<<"Digite El Numero De Elementos Del Conjunto B: ";
    cin>>z;
    randomize();
    cout<<"\nEl Conjunto A es : ";
    for(int i=0;i<a;i++)
       {conjuntoA[i]=random(100);
        cout<<conjuntoA[i]<<" ";}
    cout<<"\nEl Conjunto B es : ";
    for(int j=0;j<z;j++)
       {conjuntoB[j]=random(100);
        cout<<conjuntoB[j]<<" ";}
    C obj;
    obj.Union(conjuntoA,conjuntoB,a,z);
    cout<<"\nLa Suma De A es :"<<obj.suma(conjuntoA,a);
    cout<<"\nLa Suma De B es :"<<obj.suma(conjuntoB,z);
    cout<<"\nEl Promedio De A Es :"<<obj.promedio(obj.suma(conjuntoA,a),a);
    cout<<"\nEl Promedio De B Es :"<<obj.promedio(obj.suma(conjuntoB,z),z);
    cout<<"\nLa Varianza De A Es :"<<obj.varianza(obj.promedio(obj.suma(conjuntoA,a),a),a);
    cout<<"\nLa Varianza De B Es :"<<obj.varianza(obj.promedio(obj.suma(conjuntoB,z),z),z);
    cout<<"\nLa Varianza De A Es :"<<obj.desviacion(obj.varianza(obj.promedio(obj.suma(conjuntoA,a),a),a));
    cout<<"\nLa Varianza De B Es :"<<obj.desviacion(obj.varianza(obj.promedio(obj.suma(conjuntoB,z),z),z));
    getch();
    }
C::Union(int q[10],int p[10],int a,int b)
   {for(int i=0;i<a;i++)
       c[i]=q[i];
    for(int i=0;i<b;i++)
       {c[a+i]=p[i];}
    cout<<"\nEl Conjunto Union De A y B Es : ";
    for(int i=0;i<(a+b);i++)
        {cout<<c[i]<<" ";}
   return 0;}//Cierro Union
int C::suma(int q[10],int a)
    {r=0;
     for(int i=0;i<a;i++)
         {r+=q[i];}
     return r;}//Cierro Suma
double C::promedio(int a,int b)
     {return a/b;}//Cierro Promedio
double C::varianza(int a,int b)
       {return a/(b-1);}
double C::desviacion(int a)
       {return sqrt(a);}


lo que quiero es ver si hay otra forma de eliminar la info de r cada vez que llamo la funcion suma, ademas si hay sugerencias en otra parte del codigo se aceptan 

Código (cpp) [Seleccionar] Expandir

class Cadena
{public:
char cad1[50],cad2[50];
Cadena(char cade1,char cade2)
       {strcpy(cad1,cade1);
        strcpy(cad2,cade2);}
int Cantidad_Caracteres();
Mayusculas();
Minusculas();
int Caracteres_Numericos();
int Caracteres_Alfabeto();
Union();
Iguales();
Generar();
};

main()
{char cadena1[50],cadena2[50];
  cout<<"Digite La Cadena 1: ";
  gets(cadena1);
  cout<<"Digite La Cadena 2: ";
  gets(cadena2);
  Cadena obj(cadena1,cadena2);
}

Errores de que no puede convertir de int a char :S ayuda

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

digamos: xD

Class padre{public:
                  capturar();}
class hija:Public padre{capturar();}

main()
  {hija ob;
   ob.capturar();}

mi duda es como llamar la funcion capturar del padre desde el main con la clase hija

Agradezco su pronta Respuesta