struct struct_1
{
};

struct struct_2
{
  struct_1* s_;
  struct_2(struct_1 s)
    : s_(&s)
  {
  }
};

struct_2 foo()
{
  struct_1 s;
  struct_2 s2(s);
  return s2; // Nicht gut
}

Dies ist bei dir im Beispiel übrigens falsch, da du mit &s die Adresse der lokalen struct_1-Kopie s nimmst, nicht die vom s aus foo().

Sollte per Referenz sein. Habe das & vergessen.

SeppJ schrieb:

Normalfall

Würde ich nicht sagen. Ist es nicht eher öfter, dass man den Zeiger nicht speichert?

SeppJ schrieb:

Ich würde jedoch die Übergabe der Zeigers explizit per Zeiger machen, nicht per Referenz.

Das würde bei mir implizieren, dass der Zeiger auch 0 sein kann.
Nicht so ganz zufriedenstellend. Mir will aber auch kein Geistesblitz kommen.

SeppJ schrieb:

Normalfall

Würde ich nicht sagen. Ist es nicht eher öfter, dass man den Zeiger nicht speichert?

Ich meinte, dass eine nicht-besitzende Abhängigkeit der Normalfall ist, im Gegensatz zur Besitzübernahme. Dass überhaupt eine Abhängigkeit da ist, ist natürlich nicht normal.

template <typename T>
class saved_ptr
{
  T* ptr_;
public:
  explicit saved_ptr(T* ptr)
    : ptr_(ptr)
  {}
  // Überladungen
};

template <typename T>
saved_ptr<T> make_saved(T* ptr)
{
  return saved_ptr<T>(ptr);
}

Denn dann wäre man zumindest gezwungen zu schreiben

struct_2 foo()
{
  struct_1 s;
  struct_2 s2(make_saved(&s));
  return s2; // Nicht gut
}

was so einen Fehler schon unwahrscheinlicher macht. Ob das sinnvoll so ist, weiß ich aber nicht.

Ein roher Zeiger drückt doch genau das aus - nicht besitzend...

Ja, aber er drückt nicht aus: Wird gespeichert.

314159265358979__ schrieb:

Ein roher Zeiger drückt doch genau das aus - nicht besitzend...

Ja, aber er drückt nicht aus: Wird gespeichert.

Naja...

Wenn ich wo ne Referenz übergebe gehe ich davon aus dass die Referenz nicht gespeichert wird (sei's nun als Referenz oder als Zeiger).

Wenn ich dagegen nen Zeiger übergebe, dann rechne ich zumindest eher damit dass da was gespeichert werden könnte.