Comment convertir en toute sécurité un pointeur de base unique en un pointeur unique de dérivé ?

Downcasting du pointeur unique de base vers le pointeur unique de dérivé

Lorsque vous travaillez avec des hiérarchies de classes et l'héritage, il peut être nécessaire de downcaster un pointeur unique d'une classe de base vers une classe dérivée pour accéder à des fonctionnalités spécifiques. Ceci est couramment rencontré lorsqu'une méthode d'usine renvoie un pointeur unique vers la classe de base mais que l'objet réel est d'un type dérivé.

Pour effectuer un downcasting, il est souvent recommandé de suivre une approche en deux étapes. Tout d’abord, libérez l’objet du pointeur unique à l’aide de sa méthode release(). Cela libère la ressource sous-jacente et renvoie un pointeur brut vers l'objet de classe dérivé. Deuxièmement, utilisez une fonction pour convertir le pointeur brut vers la classe dérivée souhaitée et le réaffecter à un nouveau pointeur unique.

Voici un exemple de fonction CastToDerived() qui effectue un downcast sécurisé :

template<typename Derived, typename Base>
std::unique_ptr<Derived> CastToDerived(Base* obj) {
    return std::unique_ptr<Derived>(static_cast<Derived*>(obj));
}

Cette fonction peut être utilisée pour convertir un pointeur unique de classe de base en une classe dérivée unique. pointeur :

unique_ptr<Derived> ptr = CastToDerived(DerivedAFactory());

Alternativement, si le casting statique n'est pas fiable, vous pouvez utiliser les modèles de fonctions suivants, qui effectuent des castings statiques ou dynamiques en fonction de la sécurité du type du downcast :

template<typename Derived, typename Base, typename Del>
std::unique_ptr<Derived, Del> 
static_unique_ptr_cast( std::unique_ptr<Base, Del>& p )
{
    auto d = static_cast<Derived *>(p.release());
    return std::unique_ptr<Derived, Del>(d, std::move(p.get_deleter()));
}

template<typename Derived, typename Base, typename Del>
std::unique_ptr<Derived, Del> 
dynamic_unique_ptr_cast( std::unique_ptr<Base, Del>& p )
{
    if(Derived *result = dynamic_cast<Derived *>(p.get())) {
        p.release();
        return std::unique_ptr<Derived, Del>(result, std::move(p.get_deleter()));
    }
    return std::unique_ptr<Derived, Del>(nullptr, p.get_deleter());
}

Ces fonctions garantissent que la ressource est éliminée correctement et que le pointeur unique est construit avec la fonction de suppression appropriée.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!