shared_ptr null-Zeiger und-Zuordnung

Will ich mit shared_ptr, wie ich das verwenden würde, eine tatsächliche Zeiger. Ich wollte in der Lage sein, Dinge zu tun, wie

shared_ptr<int> a;
a = new int(5);
a = 0;
shared_ptr<int> foo()
    return 0;

aber es ist nicht standardmäßig implementiert.

Ich änderte den Quellcode der shared_ptr der boost-Bibliothek durch hinzufügen

template<class Y> void operator=( int i )
{
    reset(i);
}
template<class Y> void reset(int i)
{
    this_type(i).swap(*this);
}
template<class Y> void operator=( Y * p )
{
    reset(p);
}
shared_ptr(int i): px(0), pn()
{
}

Die einzige Sache ist, dass wenn ich a = -1; es wird kompiliert und geben Sie mir ein null-Zeiger ist, das sollte nicht das problem sein, denn normalerweise kann man nicht zuweisen einer integer-Wert in einen Zeiger.

Also meine Frage ist, ist dies eine richtige Weg, um dies zu implementieren, oder habe ich vergessen den Fällen, die Abstürzen der Anwendung? Weil überall wo ich geschaut, die einzige Möglichkeit, die ich sah, um ein nullpointer für einen shared_ptr wurde, um die Standard-Konstruktor, der nicht besonders elegant im code im Vergleich: ptr = 0;.

Eine wörtliche 0 ist ein null-Zeiger-Konstanten, so ist implizit, umwandelbar zu einem null-Zeiger-Wert von jedem Zeiger-Typ schon.
+1 "ich änderte den Quellcode der shared_ptr der boost-Bibliothek" 😉
warum nicht die C++11 nullptr statt?

InformationsquelleAutor Michael Ferris | 2012-04-22

  1. 25

    Nicht. Nicht die Quelle wechseln. So ist es für einen Grund, und sehr intelligente Menschen haben entschieden, dass die Art, wie es definiert ist, ist besser als was du gehst, um es zu Bearbeiten.

    Was Sie haben nicht einmal Sinn zu machen. Sie können nicht zuweisen eines integer zu einem pointer, es sind zwei verschiedene Arten, aber Sie haben es da solche Semantik. Sie sagen: "...was kein problem sein sollte, denn normalerweise kann man nicht zuweisen einer integer-Wert in einen Zeiger", aber Sie sagte auch, an der Spitze Ihrer Frage: "will ich mit shared_ptr, wie ich das verwenden würde, eine tatsächliche" Zeiger". Gut, was ist es? Da die Zuweisung von Ganzzahlen in Zeiger, Sie auf null zu setzen ist ungefähr so weit von einem tatsächlichen Zeiger, wie Sie bekommen können.

    Müssen Sie einen Schritt zurück und erkennen, was Sie wollen ist nicht immer das beste, was zu tun ist. Sie sollten wieder diese änderungen und verwenden Sie die Klasse richtig. Ich will nicht gemein sein aber das ist ernsthaft nicht die route, die Sie wollen, zu gehen; es ist gefährlich, hat unsinnig Semantik, und ist in der ganzen wartbaren.

    Ja, du hast Recht. Ich glaube, ich war einfach nur faul, weil ich nicht wollen, um alles zu ändern, weil ich hatte eine normale Zeiger vor und war dabei, sich auf smart ptr. Ich ahnte, was ich Tat, falsch war, und dies ist der Grund, warum ich gefragt habe 🙂
    Das ist in Ordnung, aber manchmal muss man einfach anfangen zu arbeiten, vor allem, wenn code-refactoring. 🙂 Wie Ihr Programmierstil verbessert Sie finden, dass es besser ist, explizit über die Dinge. Während implizite Funktionalität bedeutet weniger Arbeit für Sie, es bedeutet in der Regel weniger Klarheit und Sicherheit für Sie. Schauen Sie einfach nur auf return 0; zum Beispiel, du denkst, du bist der Rückkehr der Zahl - null, keine null-Zeiger. Aber es gibt keine Verwirrung, wenn Sie sagen return boost::shared_ptr<int>();. In der Tat, dies ist so viel, so dass der neue C++ - standard eingeführt, ein neues Schlüsselwort nur für die null: nullptr.
    Ich wusste selbst nicht, dass die Existenz von nullptr. Danke! 🙂 Auch, ich entschied mich für die Verwendung der shared_ptr in der standard-lib, damit ich nicht haben, tragen eine riesige Bibliothek wie boost. Noch so viele Dinge zu lernen 😉
    Wenn Sie es verwenden können, auf jeden Fall bekommen Sie in der Gewohnheit. Alle gängigen Compiler jetzt unterstützt, und es ist sehr nützlich. Auch, willkommen auf StackOverflow.

    InformationsquelleAutor GManNickG

  2. 8

    shared_ptr implementiert ein Zeiger-wie Schnittstelle, so können Sie die * und -> Betreiber.

    Einen default-konstruiert (leer) shared_ptr wird gleich nullptr intern, so dass Sie nicht brauchen, um über die Zuordnung explizit. also

    std::shared_ptr<int> sh;
std::cout << ( sh.get() == nullptr ) << std::endl;

//Or alternatively:
std::cout << ( sh == nullptr ) << std::endl;

    Auch, (meiner Meinung nach) die eleganteste Art der Verwendung von shared_ptr-Objekte zu erstellen ist die std::make_shared Funktion. Dies hat auch den Vorteil, dass Sie etwas effizienter in einigen Compilern (zumindest im MSVC++) aufgrund von einigen internen Optimierungen, bekannt als die "wir wissen, wo Sie Leben idiom"

    #include <memory>
#include <string>

class foo
{
public:
    foo(std::string s, int n) {}
};

int main()
{
    auto p = std::make_shared<int>();
    auto q = std::make_shared<foo>("hello", 2);
}

    InformationsquelleAutor Ben Cottrell

Schreibe einen Kommentar