const Referenz als Zeiger ?

krümelkacker

Mal am Rande bemerkt:

lespaul schrieb:

class X_Ptr {

public:
  // constructors
  X_Ptr();

  explicit X_Ptr(X* ptr)
    : _ptr(ptr)
  {
  }

  // move
  X_Ptr(X_Ptr&& other)
    : _ptr(other._ptr)
  {
    other._ptr = nullptr;
  }

  void operator=(X_Ptr&& other)
  {
    X* tmp = _ptr;
    _ptr = other._ptr;
    other._ptr = tmp;
  }

  // operators
  X& operator*()
  {
    return *_ptr;
  }

  const X& operator*() const
  {
    return *_ptr;
  }

  X* operator->()
  {
    return _ptr;
  }

  const X* operator->() const
  {
    return _ptr;
  }

  ~X_Ptr();

private:
  // hide
  X_Ptr(const X_Ptr&);
  void operator=(const X_Ptr&);

  X* _ptr;
};

Das ist kein guter Move-Assignment-Operator. Man würde nicht erwarten, dass die Resource, die vom Ziel der Zuweisung gehalten wird, auf einmal in der Quelle landet. Die Quelle ist nicht notwendigerweise kurzlebig und könnte so eine Resource unerwartet lang am leben lassen. Mach es lieber so:

void operator=(X_Ptr temp)
  {
    std::swap(this->_ptr, temp._ptr);
    // pass-by-value => temp wird hier automatisch zerstört
  }

Aber ich würde auch nicht jedes Mal das Rad neuerfinden wollen. Du könntest gleich std::unique_ptr benutzen oder — falls Dir die Propagierung der const ness vom Zeiger zum Gezeigten wichtig ist — so eine Ptr-Klasse generisch machen. Bei unique ownership halte ich Deinen const ness-Ansatz für durchaus sinnvoll. std::vector macht das ja auch so. Ob man das dann noch „Ptr“ nennen sollte, ist eine andere Frage, über die man sich streiten kann.

lespaul

manni66 schrieb:

Welchen Sinn soll das haben?

Ich habe es auch so bekommen. Ich nehme an, um vergessene delete zu meiden?

manni66 schrieb:

X_Ptr ist sicher kein unique_ptr.

Ja kein echtes unique_ptr, aber ein "nachgebasteltes" oder nicht?

lespaul schrieb:

manni66 schrieb:

Welchen Sinn soll das haben?

Ich habe es auch so bekommen. Ich nehme an, um vergessene delete zu meiden?

Das kann unique_ptr nicht?

lespaul schrieb:

manni66 schrieb:

X_Ptr ist sicher kein unique_ptr.

Ja kein echtes unique_ptr, aber ein "nachgebasteltes" oder nicht?

Ja, so gut dass du nicht vernünftig an den Pointer kommst.

lespaul

X_Ptr(X_Ptr&& other)
    : _ptr(other._ptr)
  {
    other._ptr = nullptr;
  }

Das ist doch der Move-Kopierkonstruktor. Aber was bedeuten die beiden Referenz-Zeichen "X_Ptr&& other" in der Parameterliste?

Mit einem & wäre es ja eine Referenz, aber 2 ?

Nathan

Mit 2 ist das eine RValue-Referenz. Sie bindet auf RValues, anstatt die LValue Referenz die auf LValues bindet.
Und weil das eine RValue-Referenz ist, ist das der Movekonstruktor. Denn er nimmt nur Temporaries und das Ergebnis von std::move entgegen, während der Kopierkonstruktor LValues entgegennimmt.
Das dient zur Unterscheidung, ob das Objekt bald zerstört ist und man ihm somit die Resourcen klauen kann, oder nicht.

lespaul

Nun habe ich wieder woanders eine Methode

Z::benutzePtrPointer(X & x) const

Zur verfügung habe ich aber: X_Ptr xptr;

wie übergebe ich xptr an benutzePtrPointer(xptr) ?

Fehler: no matching function for call to 'Z::benutzePtrPointer(X_Ptr (&)()) const' x_ref.benutzePtrPointer(*xptr);

Nathan

Na, du nutzt den Dereferenzierungsoperator wie bei normalen Pointern.

lespaul

Nathan schrieb:

Na, du nutzt den Dereferenzierungsoperator wie bei normalen Pointern.

Hab ich ja schon, weswegen die Fehlermeldung kam..

lespaul schrieb:

x_ref.benutzePtrPointer(*xptr);

LordJaxom

Der Fehlermeldung nach ist xptr kein X_Ptr sondern eine Funktion, die ein X_Ptr zurückgibt. Hast du xptr zufällig wie folgt definiert?

X_Ptr xptr();

EDIT: Nein, mit der Dereferenzierung passt die Fehlermeldung nicht mehr. Aber so etwas in der Richtung wird es sein.

lespaul

LordJaxom schrieb:

Hast du xptr zufällig wie folgt definiert?

Ja, die Klammern hab ich doch glatt übersehen..
Ich danke für diesen Hinweis

lespaul

Hallo Leute,
ich habe eine Funktion welche eine const Referenz auf ein X_Ptr Objekt erhält.

bool
Z::calc_X_Ptr(const X_Ptr & local_xptr, double & local_DoubleRef)
{
  // calc stuff!
  return true;
}

etwas drüber habe ich dann ein const X_Ptr Objekt:

const X_Ptr x_ptr;

Ich schaffe es nicht die Methode aufzurufen

myProg.cpp:210: Fehler: no matching function for call to 'Z::calc_X_Ptr(const X &, double&)'
Z::calc_X_Ptr(x_ptr, doubleValue);
^

Du willst dem Compiler wohl ein X_Ptr für ein X vormachen.

lespaul

manni66 schrieb:

Du willst dem Compiler wohl ein X_Ptr für ein X vormachen.

Ich dachte ich will ein X_Ptr als Referenz weitergeben?
Ich habe ja ein:

const X_Ptr x_ptr;

und möchte dies einpflanzen in

const X_Ptr & local_xptr

patrick246

lespaul schrieb:

Hallo Leute,
ich habe eine Funktion welche eine const Referenz auf ein X_Ptr Objekt erhält.
bool
Z::calc_X_Ptr(const X_Ptr & local_xptr, double & local_DoubleRef)
{
  // calc stuff!
  return true;
}

Der Compiler sagt aber was anderes. Und zwar

Compiler-Fehlermeldung schrieb:

Z::calc_X_Ptr(const X &, double&)

lespaul

patrick246 schrieb:

Der Compiler sagt aber was anderes. Und zwar

Compiler-Fehlermeldung schrieb:

Z::calc_X_Ptr(const X &, double&)

Sorry

Z::calc_X_Ptr(const X_Ptr &, double&)

wäre richtig.

LordJaxom

x_ptr ist kein X_Ptr, sondern ein X.

lespaul

LordJaxom schrieb:

x_ptr ist kein X_Ptr, sondern ein X.

Aber ich habe es so definiert?

const X_Ptr x_ptr;

Wieso ist es denn dann ein X und kein X_Ptr ?

LordJaxom

no matching function for call to 'Z::calc_X_Ptr(const X &, double&)'

Der Compiler behauptet, Du rufst die Funktion mit einem X auf. Entweder der Compiler lügt oder Du

lespaul

Ich stehe nun vor dem Problem solch ein X_Ptr Objekt in ein Container wie ZB std::vector zu packen.
Schwierig da der Kopierkontruktor verboten wurde..

SeppJ

lespaul schrieb:

Ich stehe nun vor dem Problem solch ein X_Ptr Objekt in ein Container wie ZB std::vector zu packen.
Schwierig da der Kopierkontruktor verboten wurde..

Denkst du, es liest sich nun irgendjemand einen drei Seiten langen, mehrere Monate alten Thread durch, um den Kontext deiner zwei Sätze zu verstehen, die noch nicht einmal eine klare Frage enthalten?
Wie man Fragen richtig stellt