it-swarm.com.de

Nullzeiger mit boost :: shared_ptr?

Was ist das Äquivalent zu Folgendem:

std::vector<Foo*> vec;
vec.Push_back(NULL);

beim Umgang mit boost::shared_ptr? Ist es der folgende Code?

std::vector< boost::shared_ptr<Foo> > vec;
vec.Push_back(boost::shared_ptr<Foo>());

Hinweis: Ich kann viele solcher Objekte zurückschieben. Soll ich irgendwo ein globales statisches nullPtr-Objekt deklarieren? Auf diese Weise müsste nur einer von ihnen konstruiert werden:

boost::shared_ptr<Foo> nullPtr;
55
Frank

Ihr Vorschlag (Aufruf des shared_ptr<T>-Konstruktors ohne Argument) ist korrekt. (Der Aufruf des Konstruktors mit dem Wert 0 ist gleichwertig.) Ich glaube nicht, dass dies langsamer wäre als der Aufruf von vec.Push_back() mit einem bereits vorhandenen shared_ptr<T>, da in beiden Fällen eine Konstruktion erforderlich ist (entweder direkte Konstruktion oder Kopie-Konstruktion).

Wenn Sie eine "schönere" Syntax wünschen, können Sie den folgenden Code versuchen:

class {
public:
    template<typename T>
    operator shared_ptr<T>() { return shared_ptr<T>(); }
} nullPtr;

Dies deklariert ein einzelnes globales Objekt nullPtr, das die folgende natürliche Syntax aktiviert:

shared_ptr<int> pi(new int(42));
shared_ptr<SomeArbitraryType> psat(new SomeArbitraryType("foonly"));

...

pi = nullPtr;
psat = nullPtr;

Wenn Sie dies in mehreren Übersetzungseinheiten (Quelldateien) verwenden, müssen Sie der Klasse einen Namen geben (z. B. _shared_null_ptr_type), die Definition des nullPtr-Objekts in eine separate .cpp-Datei verschieben und extern-Deklarationen in der Header-Datei, in der die Klasse definiert ist.

52
j_random_hacker

Nun, das ist legal:

shared_ptr<Foo> foo;  /* don't assign */

Und in diesem Zustand verweist es auf nichts. Sie können diese Eigenschaft sogar testen:

if (foo) {
    // it points to something
} else {
    // no it doesn't
}

Warum also nicht das tun:

std::vector < shared_ptr<Foo> > vec;
vec.Push_back (shared_ptr<Foo>);   // Push an unassigned one
17
Larry Gritz

In C++ 0x können Sie einfach von nullptr in std::shared_ptr konvertieren:

std::vector< boost::shared_ptr<Foo> > vec;
vec.Push_back(nullptr);
9
bdonlan

Sie könnten eine globale nullPtr für shared_ptr<Foo> angeben. Wenn Sie jedoch den globalen Namespace verschmutzen, wie würden Sie die globale nullPtr für shared_ptr<Bar> nennen?

Normalerweise erkläre ich den Nullpunkt als statisch in der Klasse des Zeigers.

#include <boost\shared_ptr.hpp>

class Foo; // forward decl
typedef boost::shared_ptr<Foo> FooPtr;
class Foo
{
public:
    static FooPtr Null;
}
...
// define static in cpp file
FooPtr Foo::Null;
...
// use Foo Null
vec.Push_back(Foo::Null);

Auf diese Weise hat jede Klasse einen statischen Nullwert.

4
m-sharp

Hier ist etwas, was ich für etwas einfacher halte und gut funktioniert 

(Denken Sie daran, dass typedef Ihr Freund ist):

#include    <cstdlib>
#include    <vector>
#include    <iostream>
#include    <boost/shared_ptr.hpp>

typedef boost::shared_ptr< std::vector<char> > CharVecHandle;

inline CharVecHandle newCharVec(std::vector<char>::size_type size) {
    return CharVecHandle(new std::vector<char>(size));
}

inline CharVecHandle newCharVec(void) {
    return CharVecHandle();
}

int main ( void )
{
    CharVecHandle cvh = newCharVec();

    if (cvh == NULL) 
        std::cout << "It's NULL" << std::endl;
    else 
        std::cout << "It's not NULL" << std::endl;

    std::vector< CharVecHandle > cvh_vec;

    cvh_vec.Push_back(newCharVec(64));
    cvh_vec.Push_back(newCharVec());

    // or call the NULL constructor directly
    cvh_vec.Push_back(CharVecHandle());

    return EXIT_SUCCESS;
}
1

Ja, deklarieren Sie einen globalen statischen Nullzeiger.

0