C ++ Smart Pointer const Korrektheit

Ich habe ein paar Container in einer Klasse, zum Beispiel vector oder eine map, die enthalten
shared_ptr - Objekte Leben auf dem heap.

Beispielsweise

template <typename T>
class MyExample
{
public:

private:
 vector<tr1::shared_ptr<T> > vec;
 map<tr1::shared_ptr<T> , int> h;
};

Ich will eine öffentliche Schnittstelle dieser Klasse, manchmal gibt shared_ptrs
const-Objekte (über shared_ptr<const T>) und manchmal shared_ptr<T> wo
Ich lasse die Anrufer zu mutieren die Objekte. Ich will logische const-correctness ist, also, wenn ich mark
eine Methode als const, kann es nicht ändern, die Objekte auf dem heap.

Fragen:

1) ich bin verwirrt durch die Austauschbarkeit von tr1::shared_ptr<const T> und tr1::shared_ptr<T>.
Wenn sich jemand übergibt eine shared_ptr<const T> shared_ptr in die Klasse, Speichere ich es als shared_ptr<T> oder shared_ptr<const T> im inneren der vector und map oder muss ich die Karte wechseln, Vektor-Typen (z.B. insert_elemeent(shared_ptr<const T> obj) ?

2) Ist es besser zu instanziieren-Klassen wie folgt: MyExample<const int> ? Das scheint
zu restriktiv sind, da kann ich nie wieder ein shared_ptr<int> ?

InformationsquelleAutor der Frage user231536 | 2010-01-17

c++const shared-ptr

35

shared_ptr<T> und shared_ptr<const T> sind nicht austauschbar sind. Es geht ein Weg - shared_ptr<T> ist konvertierbar zu shared_ptr<const T> aber nicht Umgekehrt.

Beobachten:
```
//f.cpp

#include <memory>

int main()
{
    using namespace std;

    shared_ptr<int> pint(new int(4)); //normal shared_ptr
    shared_ptr<const int> pcint = pint; //shared_ptr<const T> from shared_ptr<T>
    shared_ptr<int> pint2 = pcint; //error! comment out to compile
}
```
kompilieren über

cl /EHsc f.cpp

Können Sie auch überladen einer Funktion basierend auf einem constness. Sie kombinieren können, um diese beiden Tatsachen zu tun, was Sie wollen.

Als für Ihre zweite Frage, MyExample<int> wahrscheinlich mehr Sinn macht, als MyExample<const int>.

InformationsquelleAutor der Antwort Terry Mahaffey

Ich würde vorschlagen, die folgenden methotology:

template <typename T>
class MyExample
{
  private:
    vector<shared_ptr<T> > data;

  public:
    shared_ptr<const T> get(int idx) const
    {
      return data[idx];
    }
    shared_ptr<T> get(int idx)
    {
      return data[idx];
    }
    void add(shared_ptr<T> value)
    {
      data.push_back(value);
    }
};

Dieser sorgt für const-Korrektheit. Wie Sie sehen, das add () - Methode nicht verwenden, <const T> aber <T> denn Sie wollen die Klasse zum speichern von Ts nicht const Ts. Aber, wenn der Zugriff const, kehren Sie <const T> ist das kein problem, da shared_ptr<T> kann leicht umgewandelt werden, um shared_ptr<const T>. Und sice sowohl get () - Methoden liefern Kopien der shared_ptr in Ihrem internen Speicher der Anrufer kann nicht versehentlich ändern Sie das Objekt Ihrer internen Zeiger zeigen. Dies ist vergleichbar zu den nicht-smart-pointer-Variante:

template <typename T>
class MyExamplePtr
{
  private:
    vector<T *> data;

  public:
    const T *get(int idx) const
    {
      return data[idx];
    }
    T *get(int idx)
    {
      return data[idx];
    }
    void add(T *value)
    {
      data.push_back(value);
    }
};

InformationsquelleAutor der Antwort mmmmmmmm

5

Wenn sich jemand übergibt Sie eine shared_ptr<const T> sollten Sie nie in der Lage sein zu ändern T. Es ist natürlich technisch möglich, die Besetzung der const T nur ein Taber das bricht der Absicht, dass die T const. Also, wenn Sie wollen, dass die Leute in der Lage sein, um das hinzufügen von Objekten zu Ihrer Klasse, dass Sie sollten geben Sie shared_ptr<T> und keine shared_ptr<const T>. Wenn Sie wieder Dinge aus Ihrer Klasse wollen Sie nicht geändert, das ist, wenn Sie verwenden shared_ptr<const T>.

shared_ptr<T> können automatisch umgesetzt werden (ohne expliziten cast) zu einem shared_ptr<const T> aber nicht die andere Weise herum. Es kann Ihnen helfen (und Sie sollten es trotzdem tun), um liberale Verwendung von const Methoden. Wenn Sie eine Klasse definieren, Methode constder compiler wird nicht zulassen, Sie ändern Ihre Daten-member oder Rückgabe etwas, außer einem const T. Daher ist die Verwendung dieser Methoden wird Ihnen helfen, sicherzustellen, dass Sie nicht etwas vergessen, und wird Benutzern helfen, Eure Klasse zu verstehen, was die Absicht der Methode ist. (Beispiel: virtual shared_ptr<const T> myGetSharedPtr(int index) const;)

Sind Sie richtig auf Ihre zweite Aussage, die Sie wahrscheinlich nicht wollen, instanziieren Sie die Klasse als <const T>da Sie nie in der Lage, ändern Sie Ihre Ts.

InformationsquelleAutor der Antwort SoapBox
3

einer Sache zu erkennen ist, dass:

tr1::shared_ptr<const T> ist, imitiert die Funktionalität der T const * nämlich das, was es zeigt, ist const, aber der Zeiger selbst nicht.

So können Sie einen neuen Wert zuweisen, um Ihre freigegebenen Zeiger, aber ich würde erwarten, dass Sie wäre nicht in der Lage zu verwenden, die aufgelöst shared_ptr als l-Wert.

InformationsquelleAutor der Antwort Evan Teran

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.