Alternativen static_pointer_cast für unique_ptr

Raw-Pointer

Die Lösung für Ihr problem ist die roh - (nicht-Besitz) Zeiger und warf es - dann lass einfach die raw-Zeiger außerhalb des Bereichs und lassen Sie die restlichen unique_ptr<Base> constrol die Lebensdauer der im Eigentum Objekt.

Wie diese:

unique_ptr<Base> foo = fooFactory();

{
    Base* tempBase = foo.get();
    Derived* tempDerived = static_cast<Derived*>(tempBase);
} //tempBase and tempDerived go out of scope here, but foo remains -> no need to delete

Unique_pointer_cast

Die andere Möglichkeit ist die Verwendung der release() Funktion unique_ptr wickeln Sie es in einem anderen unique_ptr.

Wie diese

template<typename TO, typename FROM>
unique_ptr<TO> static_unique_pointer_cast (unique_ptr<FROM>&& old){
    return unique_ptr<TO>{static_cast<TO*>(old.release())};
    //conversion: unique_ptr<FROM>->FROM*->TO*->unique_ptr<TO>
}

unique_ptr<Base> foo = fooFactory();

unique_ptr<Derived> foo2 = static_unique_pointer_cast<Derived>(std::move(foo));

Denken Sie daran, dass diese ungültig macht, die alten Zeiger foo

Referenz von raw-Pointern

Nur der Vollständigkeit halber die Antwort, diese Lösung war tatsächlich vorgeschlagen, als eine Modifikation des raw-Zeiger von der OP in die Kommentare.

Ähnlich wie mit raw-Pointern kann man cast dem raw-Pointer und dann erstellen Sie einen Verweis durch derefering. In diesem Fall ist es wichtig, zu garantieren, dass die Lebensdauer der erstellten Referenz nicht übersteigt die Lebensdauer der unique_ptr.

Beispiel:

unique_ptr<Base> foo = fooFactory();
Derived& bar = *(static_cast<Derived*>(foo.get()));
//do not use bar after foo goes out of scope

InformationsquelleAutor Anedar

Ich möchte etwas ergänzen zu der vorherigen Antwort von Anedar die Anrufe, die release() member-Methode der angegebenen std::unique_ptr< U >. Will man zur Umsetzung einer dynamic_pointer_cast als auch (zusätzlich zu einem static_pointer_cast) für die Konvertierung std::unique_ptr< U > zu std::unique_ptr< T >, müssen sicherstellen, dass die Ressource bewacht von der unique pointer ist korrekt freigegeben, im Fall der dynamic_cast ausfällt (d.h. es gibt eine nullptr). Andernfalls tritt ein Speicherverlust auf.

Code:

#include <iostream>
#include <memory>

template< typename T, typename U >
inline std::unique_ptr< T > dynamic_pointer_cast(std::unique_ptr< U > &&ptr) {
    U * const stored_ptr = ptr.release();
    T * const converted_stored_ptr = dynamic_cast< T * >(stored_ptr);
    if (converted_stored_ptr) {
        std::cout << "Cast did succeeded\n";
        return std::unique_ptr< T >(converted_stored_ptr);
    }
    else {
        std::cout << "Cast did not succeeded\n";
        ptr.reset(stored_ptr);
        return std::unique_ptr< T >();
    }
}

struct A { 
    virtual ~A() = default;
};
struct B : A {
    virtual ~B() { 
        std::cout << "B::~B\n"; 
    }
};
struct C : A {
    virtual ~C() { 
        std::cout << "C::~C\n"; 
    }
};
struct D { 
    virtual ~D() { 
        std::cout << "D::~D\n"; 
    }
};

int main() {

  std::unique_ptr< A > b(new B);
  std::unique_ptr< A > c(new C);
  std::unique_ptr< D > d(new D);

  std::unique_ptr< B > b1 = dynamic_pointer_cast< B, A >(std::move(b));
  std::unique_ptr< B > b2 = dynamic_pointer_cast< B, A >(std::move(c));
  std::unique_ptr< B > b3 = dynamic_pointer_cast< B, D >(std::move(d));
}

Ausgang (mögliche Reihenfolge):

Cast did succeeded
Cast did not succeeded
Cast did not succeeded
B::~B
D::~D
C::~C

Die Destruktoren von C und D wird nicht aufgerufen werden, wenn man setzt:

template< typename T, typename U >
inline std::unique_ptr< T > dynamic_pointer_cast(std::unique_ptr< U > &&ptr) {
    return std::unique_ptr< T >(dynamic_cast< T * >(ptr.release()));
}

InformationsquelleAutor Matthias