Tengo una jerarquÃ***a muy simple con una clase base abstracta y "n" clases
derivadas. Tanto la clase base como las derivadas tienen una función
"Pinta". Y en principio quiero que cuando se pinte una clase hija
tambien se ejecute el "Pinta" de la clase base.

Se me ocurre dos formas distintas de hacerse. En una primera la clase
derivada llama a la clase base: (en pseudocódigo)

class Base { Pinta(){Lo comun a cada clase; }
clase Hija1: Base {Pinta(){base.Pinta(); mas lo especÃ***fico de Hija1 }
clase Hija2: Base {Pinta(){base.Pinta(); mas lo especÃ***fico de Hija2 }
....

Esta tiene el incoveniente de que hay que acordarse de incorporar la
llamada a la función de la clase base.

El segundo sistema es cargar la clase base:
class Base{ Pinta(){Lo común a cada clase; Pintando()}
Pintando()=0 // pintando es abstracto y se ejecuta por
// polimorfismo}
class Hija1: Base {Pintando(){lo especifico de Hija1}
class Hija2: Base {Pintando(){lo especifico de Hija2}
....

El incoveniente de este es que quizás sea menos claro a la hora de
entender la lógica del programa.

¿qué solución encontrais más práctica o recomendable?

Te recomiendo la segunda opción, mejorándola con el uso de 'private' para
forzar el uso correcto de las clases derivadas
class Base {
public:
void Pinta() {/*lo común*/; PintaEspecializado();}
private:
virtual void PintaEspecializado()=0;
// virtual pura, para que tengan que definirla
// privada para obligarles a llamar siempre a Pinta(), nunca a
PintaEspecializado()
};

class Hija : public Base{
private:
void PintaEspecializado();
// privada para que no se pueda llamar por error.
}

Te recomiendo la segunda opción, mejorándola con el uso de 'private' para
forzar el uso correcto de las clases derivadas
class Base {
public:
void Pinta() {/*lo común*/; PintaEspecializado();}
private:
virtual void PintaEspecializado()=0;
// virtual pura, para que tengan que definirla
// privada para obligarles a llamar siempre a Pinta(), nunca a
PintaEspecializado()
};

class Hija : public Base{
private:
void PintaEspecializado();
// privada para que no se pueda llamar por error.
}

Te recomiendo la segunda opción, mejorándola con el uso de 'private' para
forzar el uso correcto de las clases derivadas
class Base {
public:
void Pinta() {/*lo común*/; PintaEspecializado();}
private:
virtual void PintaEspecializado()=0;
// virtual pura, para que tengan que definirla
// privada para obligarles a llamar siempre a Pinta(), nunca a
PintaEspecializado()
};

class Hija : public Base{
private:
void PintaEspecializado();
// privada para que no se pueda llamar por error.
}

Te recomiendo la segunda opción, mejorándola con el uso de 'private' para
forzar el uso correcto de las clases derivadas
class Base {
public:
void Pinta() {/*lo común*/; PintaEspecializado();}
private:
virtual void PintaEspecializado()=0;
// virtual pura, para que tengan que definirla
// privada para obligarles a llamar siempre a Pinta(), nunca a
PintaEspecializado()
};

class Hija : public Base{
private:
void PintaEspecializado();
// privada para que no se pueda llamar por error.
}

Te recomiendo la segunda opción, mejorándola con el uso de 'private' para
forzar el uso correcto de las clases derivadas
class Base {
public:
void Pinta() {/*lo común*/; PintaEspecializado();}
private:
virtual void PintaEspecializado()=0;
// virtual pura, para que tengan que definirla
// privada para obligarles a llamar siempre a Pinta(), nunca a
PintaEspecializado()
};

class Hija : public Base{
private:
void PintaEspecializado();
// privada para que no se pueda llamar por error.
}

Te recomiendo la segunda opción, mejorándola con el uso de 'private' para
forzar el uso correcto de las clases derivadas
class Base {
public:
void Pinta() {/*lo común*/; PintaEspecializado();}
private:
virtual void PintaEspecializado()=0;
// virtual pura, para que tengan que definirla
// privada para obligarles a llamar siempre a Pinta(), nunca a
PintaEspecializado()
};

class Hija : public Base{
private:
void PintaEspecializado();
// privada para que no se pueda llamar por error.
}

Te recomiendo la segunda opción, mejorándola con el uso de 'private' para
forzar el uso correcto de las clases derivadas
class Base {
public:
void Pinta() {/*lo común*/; PintaEspecializado();}
private:
virtual void PintaEspecializado()=0;
// virtual pura, para que tengan que definirla
// privada para obligarles a llamar siempre a Pinta(), nunca a
PintaEspecializado()
};

class Hija : public Base{
private:
void PintaEspecializado();
// privada para que no se pueda llamar por error.
}