Tengo una serie de fábricas que vuelven.unique_ptr<Base>. Bajo el capó, sin embargo, están proporcionando punteros a varios tipos derivados, es decir,unique_ptr<Derived>, unique_ptr<DerivedA>, unique_ptr<DerivedB>etc.

DadoDerivedA : Derived yDerived : Base tendríamos

unique_ptr<Base> DerivedAFactory() {
    return unique_ptr<Base>(new DerivedA);
}

Lo que necesito hacer es "lanzar" el puntero desde el valor devueltounique_ptr<Base> a algún nivel derivado (no necesariamente el original interno). Para ilustrar en pseudo código:

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

Estoy pensando en hacer esto liberando el objeto de launique_ptr, luego, utilizando una función que proyecta el puntero en bruto y lo reasigna a otrounique_ptr del sabor deseado (elrelease sería hecho explícitamente por la persona que llama antes de la llamada):

unique_ptr<Derived> CastToDerived(Base* obj) {
    return unique_ptr<Derived>(static_cast<Derived*>(obj));
}

¿Es esto válido, o es / habrá algo funky pasando?

PD. Existe una complicación adicional en el hecho de que algunas de las fábricas residen en archivos DLL que se cargan dinámicamente en tiempo de ejecución, lo que significa que necesito asegurarme de que los objetos producidos se destruyan en el mismo contexto (espacio de pila) que se crearon. La transferencia de propiedad (que normalmente ocurre en otro contexto) debe proporcionar un borrado del contexto original. Pero aparte de tener que suministrar / lanzar un borrado junto con el puntero, el problema de lanzamiento debería ser el mismo.