Q:

clase DERIVADA de clase VIRTUAL arroja el siguiente error: because the following virtual functions are pure within 'nombre_de_clase':

Estoy trabajando con clases y herencias y me encontré con este primer error en un programa mucho más grande que el que les presentaré:
undefined reference to vtable for class xxx 
Tratando de recrear el error en un programa pequeño me encontré con este error
[Error] invalid new-expression of abstract class type 'bebe'
[Note] because the following virtual functions are pure within 'bebe':
[Note] virtual double abuelo::expresion()
Y creo que apunta en la misma dirección.  Sé que tiene que ver con el hecho de que la clase abuelo es una clase virtual pura,pero no entiendo exactamente que debo hacer, si dejar de hacerla pura, si implementar la función pura en cada función, si hacer virtual a los hijos, si hacer static cast, o si simplemente no llamar a la clase abuelo.  En el sitio en ingles he encontrado preguntas similares pero los conceptos en ingles se me hacen bastante confusos, por lo cual les presento el código:
#include <cctype>
#include <iostream>
#include <list>
#include <string>

using namespace std;

// clase abuelo es Virtual pura
class abuelo
{
    public:
        virtual double expresion() = 0;
};

// El resto de clases derivadas
class padre: public abuelo
{
    public: 
        padre(abuelo *paterno, abuelo *materno);
        static abuelo *foo();
    private:
        abuelo *paterno;
        abuelo *materno;

};

abuelo *padre::foo()
{
    return 0;
}

class madre: public abuelo
{
    public:
        static abuelo *foo();
};

class bebe: public madre
{
    public:
        bebe(string nombre)
        {
            this->nombre = nombre;
        }
    protected:
        string nombre;
};

class hijo: public madre
{
    public:
        hijo(double value)
        {
            this->value = value;
        }
        double expresion()
        {
            return value;
        }
    private:
        double value;
};

// LA funcion problematica
abuelo *madre::foo()
{
    char paren;
    double value;
    cin >> ws;
    if (isdigit(cin.peek()))
    {
        cin >> value;
        //aquí quise declarar a hijo como new hijo pero me dijo que no 
        //reconocía a hijo
        abuelo *hijo;// = new hijo(value);
        return hijo;
    }
    if (cin.peek() == '(')
    {
        cin >> paren;
        return padre::foo();
    }
    else
        /* y aqui esta el error que les comento */
        return new bebe("Luis");
    return 0; 
}

int main()
{
    return 0;
}

Agradezco cualquier luz que puedan arrojar sobre este problema.  Gracias. 

A:

Las funciones virtuales se usan para poder personalizar el comportamiento de las funciones en clases derivadas cuando estamos trabajando en entornos polimórficos:
struct A
{
  void noVirtual()
  { std::cout << "A": }

  virtual void Virtual()
  { std::cout << "A"; }
};

struct B : A
{
  void noVirtual()
  { std::cout << "B": }

  void Virtual()
  { std::cout << "B"; }
};

int main()
{
  B b;

  b.Virtual();      // Imprime B
  b.NoVirtual();    // Imprime B

  A* ptr = &b;
  ptr->Virtual();   // Imprime B
  ptr->NoVirtual(); // Imprime A!!! 
}

Las funciones virtuales tienen, como característica adicional, que pueden declararse como virtuales puras.  Esto quiere decir que su declaración inicial no posee ninguna implementación.  Esta característica es útil para implementar interfaces o en aquellas situaciones en las que en la clase base la función es necesaria pero no tiene sentido una implementación a ese nivel:
struct ControlGrafico
{
  // No tiene sentido implementar nada en este nivel
  // pero declarar la funcion a este nivel te permite
  // garantizar que todos los objetos que hereden de
  // esta clase van a disponer de un metodo Render
  virtual void Render() = 0;
};

Lo que sucede entonces es que la clase pasa a ser considerada como "abstracta" o "incompleta".  C++ no permite crear instancias de clases abstractas.  Declarar una funcion virtual pura obliga a implementar la función en alguna clase derivada para poder crear instancias:
struct A
{
  virtual void func() = 0;
};

struct B : A
{
  void func2()
  { std::cout << "B": }
};

struct C : A
{
  void func()
  { std::cout << "C": }
};

struct D : C
{
  void func2()
  { std::cout << "D": }
};

int main()
{
  A a; // ERROR, A es una clase abstracta
  B b; // ERROR, B es una clase abstracta
  C c; // Ok, C no es abstracta
  D d; // Ok, aunque D no implementa func directamente
       // hereda la implementacion de C
}

Tu problema es justamente este, que declaras una función virtual pura y dicha función no posee implementación en ninguna de las clases que pretendes crear.  La solución pasa por darle una implementación donde corresponda.