Violación de segmento ('core' generado)

[AnaxiMarco]

Hola, estoy programando una calculadora de polinomios y todo funciona bien salvo el MCD. Se compila todo bien pero cuando corro el programa en la opción 9 (MCD) aparece el mensaje de Violación de segmento ('core' generado).

Espero me pue
El código de mi programa es:

Código:

#include <iostream>
#include <cstdlib>
#include <vector>
#include <math.h> //Se usa solo para la opción de evaluar polinomios

using namespace std;

class Poli : public vector<double> {
      public:
       Poli();
       int Gr() const;
       ostream& Print(ostream& os) const;
};

Poli::Poli() : vector<double>()
{ }

ostream& Poli::Print(ostream& os) const
{
    for (int k=0; k<this->size(); k++)
       os << " + " << (*this)[k] << "x**" << k;
    return os;
}

ostream& operator << (ostream& os, const Poli& p)
{
    return p.Print(os);
}


int Poli::Gr() const
{
   int gr= 0;
   for (int k=0; k < (*this).size(); k++)
      if ( (*this)[k] != 0.0 )
          gr= k;
   return gr;
}

Poli Integral(const Poli& p)
{
   Poli r;
   int Gp= p.Gr();
   int k= 0;
   r.push_back(0);
   while (k<=Gp)
      {
       r.push_back( p[k] /(k+1) );
       k++;
      }

    return r;
}


Poli Derivada(const Poli& p)
{
   Poli r;
   int Gp= p.Gr();
   int k= 2;
   r.push_back(p[1]);
   while (k<=Gp)
      {
       r.push_back( p[k] *(k) );
       k++;
      }
    return r;
}

Poli Suma(Poli p, Poli q)
{
   Poli r;
   int Gp= p.Gr();
   int Gq= q.Gr();
   int k= 0;
   while (k<=Gp && k<=Gq)
      {
       r.push_back( p[k] + q[k] );
       k++;
      }
   while (k<=Gp)
      r.push_back( p[k++] );

   while (k<=Gq)
      r.push_back( q[k++] );

    return r;
}

Poli Resta(Poli p, Poli q)
{
   Poli r, t;
   int Gp= p.Gr();
   int Gq= q.Gr();
   int k= 0;
   while (k<=Gp && k<=Gq)
      {
       r.push_back( p[k] - q[k] );
       k++;
      }
   while (k<=Gp)
      r.push_back( p[k++] );

   while (k<=Gq)
      r.push_back( -q[k++] );

    return r;
}

Poli Mult(Poli p, Poli q)
{
  Poli r;
  int res[p.Gr()+q.Gr()+1];
  for(int c=0; c<=p.Gr()+q.Gr(); c++)
   res[c]=0;
  for(int i=0; i<=p.Gr(); i++)
  {
   for(int j=0; j<=q.Gr(); j++)
   {
     res[i+j]+=p[i]*q[j];
   }
  }
  for(int k=0; k<=p.Gr()+q.Gr(); k++)
  {
    r.push_back(res[k]);
  }

  return r;
}

Poli Div(Poli p, Poli q)
{ 
  Poli a, b, c, r, t;
  Poli s;
  s.push_back(0);
    double f[q.Gr()-p.Gr()];
    for(int i=0; i<=q.Gr()-p.Gr(); i++)
      f[i]=0;
    f[q.Gr()-p.Gr()]=q[q.Gr()]/p[p.Gr()];
    for(int j=0; j<=q.Gr()-p.Gr(); j++)
      a.push_back(f[j]);
    b=Mult(p, a);
    s = Suma(s, a);
    c=Resta(q, b);
  return s;
}

Poli Residuo(Poli p, Poli q)
{ 
  Poli a, b, c, r, t;
  Poli s;
  s.push_back(0);
    double f[q.Gr()-p.Gr()];
    for(int i=0; i<=q.Gr()-p.Gr(); i++)
      f[i]=0;
    f[q.Gr()-p.Gr()]=q[q.Gr()]/p[p.Gr()];
    for(int j=0; j<=q.Gr()-p.Gr(); j++)
      a.push_back(f[j]);
    b=Mult(p, a);
    s = Suma(s, a);
    c=Resta(q, b);
  return c;
}

Poli MCD(Poli p, Poli q)
{
  Poli m;
  do
    {
      m= Residuo(p, q);
      q = p;
      p = m;
    }
  while(m.Gr() != 0);
  return m;
}

int main()
{

   Poli p;
   p.push_back(8);
   p.push_back(2);
   p.push_back(0);
   p.push_back(1);

   Poli q;
   q.push_back(2);
   q.push_back(0);
   q.push_back(4);
   q.push_back(1);
   q.push_back(4);
   q.push_back(9);
   
 
   Poli r, s;
   int b, a;
   cout<<"CALCULADORA DE POLINOMIOS\n";
   cout<<"Por favor elija la operación que quiera hacer con los polinomios ingresados\n";
   cout<<"1 Sumar los polinomios p y q\n";
   cout<<"2 Restar los polinomios p y q\n";
   cout<<"3 La integral de p y la integral de q\n";
   cout<<"4 La derivada de p y la derivada de q\n";
   cout<<"5 Evaluar p y q en un punto elegido por el usuario\n";
   cout<<"6 Multiplicar p y q\n";
   cout<<"7 Dividir q (el polinomio de mayor grado) entre p\n";
   cout<<"8 El residuo de dividir q entre p\n";
   cout<<"9 El MCD de los polinomios q (de mayor grado) y p\n"<<endl;
   cin>>a;

   switch(a)
   {
     case 1:
     {
       r= Suma(p, q);
       cout<<"La suma de los polinomios p y q es:\n";
       cout<< r << endl;
       cout<<"\n El grado de la suma es:"<< r.Gr() << endl;
     }
     break;
    case 2:
     {
       r= Resta(p, q);
       cout<<"La resta de los polinomios p y q es:\n";
       cout<< r << endl;
       cout<<"\n El grado de la resta es:"<< r.Gr() << endl;
     }
     break;
    case 3:
     {
       r= Integral(p);
       s= Integral(q);
       cout<<"La integral del polinomio p es:\n";
       cout<< r <<" + c"<< endl;
       cout<<"\n El grado de la integral de p es: "<< r.Gr() << endl;
       cout<<"\n La integral del polinomio q es:\n";
       cout<<s<< " + c"<< endl;
       cout<<"\n El grado de la integral de q es:"<< s.Gr() << endl;
     }
     break;
    case 4:
     {
      r= Derivada(p);
      s= Derivada(q);
      cout<<"La derivada del polinomio p es:\n";
      cout << r << endl;
      cout<<"El grado de la derivada de p es: "<< r.Gr() << endl;
      cout<<"La derivada del polinomio q es:\n";
      cout << s << endl;
      cout<<"El grado de la derivada de q es: "<< s.Gr() << endl;
     }
     break;
    case 5:
     {
      cout<<"Ingrese el número donde quiere evaluar a los polinomios p y q: "<<endl;
      cin>>b;
      int sum1=0, par1;
      for(int j=0; j<=p.Gr(); j++)
      {
       par1=p[j]*pow(b,j);
       sum1+=par1;
      }
      int sum2=0, par2;
      for(int j=0; j<=q.Gr(); j++)
      {
       par2=q[j]*pow(b,j);
       sum2+=par2;
      }
      cout<<"\n El valor del polinomio p en "<<b<<" es: "<<sum1<<endl;
      cout<<"\n El valor del polinomio q en "<<b<<" es: "<<sum2<<endl;
     }
     break;
    case 6:
     {
      Poli r;
      r= Mult(p, q);
      cout<<"La multiplicación de p y q es:\n";
      cout<<r<< endl;
      cout<<"El grado de la multiplicación es: "<<r.Gr()<<endl;
     }
     break;
    case 7:
     {
       Poli r;
       r= Div(p, q);
       cout<<"La división q entre p es:\n";
       cout<< r << endl;
       cout<<"El grado de la división es: "<<r.Gr()<<endl;
     }
     break;
   case 8:
     {
       Poli r;
       r= Residuo(p, q);
       cout<<"La división q entre p es:\n";
       cout<< r << endl;
       cout<<"El grado del residuo es: "<<r.Gr()<<endl;
     }
     break;
   case 9:
     {
       Poli r;
       r=MCD(p, q);
       cout<<"El MCD de los polinomios p y q es:\n";
       cout<<r <<endl;
     }
     break;
   }
  

   return EXIT_SUCCESS;
}

[eferion]

Que el programa te arroje los resultados esperados en todos los apartados menos en ese no implica necesariamente que el programa esté bien:

Código C++:

class Poli : public vector<double>
 

Has de saber que el destructor de std::vector<T> no es virtual. Esto quiere decir que si usas polimorfismo te puedes encontrar con la desagradable sorpresa de que no se invoca al destructor de Poli, con lo que toda la memoria reservada por este objeto o por sus variables internas se quedará en el limbo.

Código C++:

class NoVirtualA
{
  public:
    NoVirtualA(){}
 
    ~NoVirtualA()
    { std::cout << "NoVirtualA::~NoVirtualA()" << std::endl; }
};
 
class NoVirtualB : public NoVirtualA
{
  public:
    NoVirtualB(){}
 
    ~NoVirtualB()
    { std::cout << "NoVirtualB::~NoVirtualB()" << std::endl; }
};
 
class VirtualA
{
  public:
    VirtualA(){}
 
    virtual ~VirtualA()
    { std::cout << "VirtualA::~VirtualA()" << std::endl; }
};
 
class VirtualB : public VirtualA
{
  public:
    VirtualB(){}
 
    ~VirtualB()
    { std::cout << "VirtualB::~VirtualB()" << std::endl; }
};
 
int main()
{
  std::cout << "Caso 1: Se llama a los dos destructores:" << std::endl;
  NoVirtualB* noVirtualB = new NoVirtualB;
  delete noVirtualB;
 
  std::cout << "Caso 2: Dónde quedó el segundo destructor?" << std::endl;
  NoVirtualA* noVirtualA = new NoVirtualB;
  delete noVirtualA;
 
  std::cout << "Caso 3: Ahora si aparecen los dos destructores:" << std::endl;
  VirtualA* virtualA = new VirtualB;
  delete virtualA;
}
 

Lo suyo, más que herencia, sería tirar de composición, es decir, hacer que el vector fuese un miembro de Poli. Claro está te obligaría a implementar métodos para añadir, eliminar, acceder y modificar los diferentes monomios pero el diseño no sería problemático.

Otro error que tienes es la comparación de datos de tipo double:

Código C++:

int Poli::Gr() const
{
   int gr= 0;
   for (int k=0; k < (*this).size(); k++)
      if ( (*this)[k] != 0.0 )
          gr= k;
   return gr;
}
 

Si te han explicado las cosas por orden, habrás tenido que ver cómo se almacenan los números decimales en la memoria del ordenador (eso de la mantisa, el exponente, ...). Así mismo habrás visto que un número decimal no tiene por qué tener una representación exacta en binario. Hay números muy tontos como, por ejemplo, 0,3 que en binario tendrá infinitos dígitos: 0.01010101... queda claro entonces que por mucho que te esfuerces no vas a poder almacenar exactamente 0,3 en 32 bits (o 64 o los que te de la gana).

La forma correcta de comparar decimales es asumir que dos números son iguales si se parecen lo suficiente... esto es |A - B| < ALGO. Normalmente ALGO puedes sustituirlo por 1e-4 o 1e-6... si usas double puedes aumentar la precisión pero normalmente no te va a aportar gran cosa. Por cierto, nota que me estoy quedando con el valor absoluto de la resta.

Más cosillas:

Código C++:

int Poli::Gr() const
{
   int gr= 0;
   for (int k=0; k < (*this).size(); k++)
      if ( (*this)[k] != 0.0 )
          gr= k;
   return gr;
}
 

Si en el vector almacenas en la posición 0 el monomio menos representativo y de ahí en orden hacia arriba... por qué fuerzas al código a recorrer todo el polinomio desde el principio si lo único que te interesa es el último valor?? Funcionar funciona, pero la forma de hacerlo no es desde luego la más adecuada. Lo suyo sería empezar desde el final y quedarse con el primer valor distinto de 0... después de eso salir del bucle porque no tiene sentido seguir comprobando valores.


Seguimos:

Código C++:

Poli Residuo(Poli p, Poli q)
{ 
  Poli a, b, c, r, t;
  Poli s;
  s.push_back(0);
    double f[q.Gr()-p.Gr()];
    for(int i=0; i<=q.Gr()-p.Gr(); i++)
      f[i]=0;
    f[q.Gr()-p.Gr()]=q[q.Gr()]/p[p.Gr()];
    for(int j=0; j<=q.Gr()-p.Gr(); j++)
      a.push_back(f[j]);
    b=Mult(p, a);
    s = Suma(s, a);
    c=Resta(q, b);
  return c;
}
 

En la función anterior centrémonos en la línea:

Código C++:

double f[q.Gr()-p.Gr()];
 

¿Qué sucede si p.Gr() es mayor que q.Gr()? Se puede crear un array con tamaño negativo? la respuesta rápida es que no. ¿Es muy importante esto? pse... si miramos otra función:

Código C++:

Poli MCD(Poli p, Poli q)
{
  Poli m;
  do
    {
      m= Residuo(p, q); // <<<--- AQUI!!!
      q = p;
      p = m;
    }
  while(m.Gr() != 0);
  return m;
}
 

Pues lo mismo empieza a tener sentido el error que comentas :)

Y ya como bonus un pequeño detalle. Pasar a una función objetos por valor implica hacer una copia de los mismos. Para lo que estás haciendo ahora mismo no es significativo, pero es una mala práctica porque reduce muchísimo el rendimiento. Lo más común es pasar los objetos como referencias constantes, lo que evita crear una copia en cada llamada:

Código C++:

Poli MCD(const Poli& p, const Poli& q)
 

Lo bueno de aplicar esta solución es que no tienes que modificar para nada el código de la función!!!

Un saludo.

[dehm]

No sabía que se podía heredar de una plantilla, o de un contenedor, mejor dicho

[eferion]

Iniciado por dehm

No sabía que se podía heredar de una plantilla, o de un contenedor, mejor dicho

Es más correcto decir que no es seguro heredar de una clase que no tiene su destructor como virtual.

Si la plantilla tiene el destructor virtual no hay ningún problema. Lo que sucede es que los contenedores de la STL no tienen el destructor marcado como virtual.

Un saludo.