Convertir boost::shared_ptr en shared_ptr

Bonjour à tous,

j'ai le souci suivant:

class SeqVisual
{
private:
int index_;
public:
SeqVisual(int idx) : index_(idx) {}
};

class SeqVisualThumb : public SeqVisual
{
private:
float f_;
public:
SeqVisualThumb(int idx, float f) : SeqVisual(idx),f_(f) {}
void DrawSelectionRect();
};


class ListeSeqBase
{
typedef std::vector<boost::shared_ptr<SeqVisual> > vSeq;
typedef vSeq::const_iterator cIte;
vSeq listSequences_;

boost::shared_ptr<SeqVisual> GetSequence(int idxObject) const
{
cIte ite = std::find_if(listSequences_.begin(),listSequences_.end
(),Functor(idxObject));
if (ite != listSequences_.end())
return *ite;
}
};

class ListSeqThumb : public ListSeqBase
{
boost::shared_ptr<SeqVisualThumb> selected_;

void SelectObject(int idxObject)
{
selected_ = GetSequence(idxObject); // l'erreur est ici
selected_->DrawSelectionRect();
};

J'ai le message d'erreur suivant:
[BCC32 Erreur] shared_ptr.hpp(256): E2034 Impossible de convertir
'SeqVisual * const' en 'SeqVisualThumb *'

J'imagine 3 solutions pour résoudre ce souci:

1) Implémenter pour SeqVisualThumb un opérateur d'affectation depuis un
SeqVisual:

SeqVisualThumb& operator=(const SeqVisual & other)

Mais le souci est que SeqVisualThumb nécessite des paramètres de
construction supplémentaires que ne peut lui fournir SeqVisual.

Une solution serait donc de créer une nouvelle fonction pour
SeqVisualThumb du genre:

void SetFloat(float newFloat) { f_ = newFloat; }

2) Déclarer une fonction DrawSelectionRect dans la classe de base de
SeqVisualThumb pour pouvoir utiliser cette fonction même depuis un
pointeur vers la base.

Le souci ici est que 2 classes dérivent de SeqVisual, et seule
SeqVisualThumb a besoin d'une telle fonction.

3) Effectuer un dynamic_cast de SeqVisual vers SeqVisualThumb.

Souci: j'ai ouï dire que ça trahissait un mauvais design, ce qui me
pousse à m'interroger sur le mien.

En conclusion, j'aimerais savoir quelle solution vous adopteriez, vous?

Merci d'avance

Michael

PS: 2 questions subsidaires.

1) Dans ListSeqThumb, quand je veux dire qu'aucun objet n'est
sélectionné, et donc réinitialiser boost::shared_ptr<SeqVisualThumb>
selectObject_, est-ce que ceci suffit:

selected_.reset();

2) Quelle méthode vous préférez employer

//Méthode 1
class Base
{
public:
virtual void foo()
{
//some work
}
};

class Derived
{
public:
virtual void foo()
{
Base::foo();
// some other work
}
};

//Méthode 2
class Base
{
private:
virtual void fooImpl() = 0;
public:
void foo()
{
//some work
fooImpl();
}
};

class Derived
{
private:
virtual void fooImpl()
{
// some other work
}
};

Merci, ce sera tout pour aujourd'hui ;)