Nicht besitzende Abhängigkeit

Wie macht ihr nicht besitzende Abhängigkeiten klar? Also z.B.

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
}

TyRoXx

- ein Kommentar
- logisches Denken

SeppJ

Eigentlich gar nicht (oder zumindest kein großes Aufheben darum machen), da dies der Normalfall ist. Umgekehrt würde ich es kenntlich machen (durch Kommentare/Dokumentation). Ich würde jedoch die Übergabe der Zeigers explizit per Zeiger machen, nicht per Referenz. 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().

SeppJ schrieb:

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

besitzer schrieb:

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.

cooky451

Für jede Art von Besitz gibt's ja die hübschen weak_, shared_ und unique_ptr. Aber das Problem mit dem nicht besitzen kenne ich auch. Bzw. ich kenne einfach keine schöne Variante, diese Art von Abhängigkeit im Code auszudrücken. Offen gesagt bezweifel ich auch, dass das mit C++ sinnvoll geht. Was man machen könnte wäre

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...

cooky451

314159265358979__ schrieb:

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

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

hustbaer

cooky451 schrieb:

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.