Was nützen *Pointer?

volkard

jasch schrieb:

Eine Referenz auf einen Pointer ist m. E. nicht sinnvoll, da die Referenz ja eigentlich ähnliche Aufgaben erfüllt wie ein Pointer, also kann man auch den Pointer selbst übergeben.
MfG

hast recht, es ist nicht sinnvoll.
aber deine begründung ist falsch, wie folgender anfängercode zeigt

template<typename T>
void saveDelete(T*&t){
   delete t;
   t=0;
}

net 0

jasch schrieb:

Eine Referenz auf einen Pointer ist m. E. nicht sinnvoll...

warum nicht? das ist dann wie ein doppelpointer

volkard

ptr schrieb:

hi, wie kann man eine referenz auf einen pointer aus einer funktion zurückgeben? macht das sinn?
wie funktioniert das hier?
int* foo::operator->()
{
     return &(ptr->val);
}

macht selten sinn. ausgabe aus ner suchschleife, und die suchschleife gibt nicht den zeiger auf den gefundenen datensatz, sondern ne referenz auf diesen zeiger, so we er in der datenstruktur lebt, damit man diesen zeiger auch löschen und nullsetzen oder anderswie verbiegen kann. wird faktisch wohl nie eingesetzt werden, weil man da zeiger auf zeiger nimmt, um noch zu geringsten kosten anzeigen zu können, daß der wert gar nicht gefunden wurde.

volkard

C++Progger schrieb:

aber dass Experten sie lieben.

das war vermutlich einer, der erst seit 3 jahren c++ kann und sich als experte fühlt. keine bange, wenn der erste entdeckerstolz verraucht ist, wird er wieder umschwenken und pointer und referenzen meiden (außer in trivialen fällen wie übergabeparameter auf 4 bytes schrumpfen).

GPC

volkard schrieb:

wird er wieder umschwenken und pointer und referenzen meiden

Sind Referenzen inzwischen auch der Teufel?

EDIT: Quote tag korrigiert

gi, ja mit referenz auf pointer habe ich dann ja call by reference, nur mit pointer call by value...vielleicht machts deshalb sinn?;)

wie kann ich einen pointer als referenz aus einer funktion zurückgeben?

volkard

GPC schrieb:

volkard schrieb:

wird er wieder umschwenken und pointer und referenzen meiden

Sind Referenzen inzwischen auch der Teufel?

ob du ne dynamische datenstruktur mit pointers oder mit referenzen machst, ist egal. tücken.
ob du call by ref oder call by pointer machst, ist auch egal. keine tücken.
mir ist rect egal, ob ich zum benutzen des bezeichners ein * davorschreibe oder ob der das im geheimen automagisch selber macht. das ist nur syntax und praktisch irrelevant bei der teufelfrage.
es ist nicht so, daß referenzen irgend einen vorteil gegenüber zeigern hätten. beide sind gleichermaßen praktisch und gefährlich.

volkard

ptr schrieb:

wie kann ich einen pointer als referenz aus einer funktion zurückgeben?

//ungetestet und bestimmt nicht ganz korrekt
class List{
private:
struct Node{
double d;
Node* n; 
};
Node* a;//aka anchor,root,head
Node*& findPlaceToInsertOrReplace(double x){
   for(Node**p=&a;*a;p=&(*p)->n)
      if((*p)->d==x)
         return p;
   return &a;
}
...

int* foo::operator->() 
 { 
      return &(ptr->val); 
 }

mit &(ptr->val) bekomm ich die adresse?

for(Node**p=&a;*a;p=&(*p)->n)

schau verwirrent aus;)

Node*& findPlaceToInsertOrReplace(double x){
    ...
    return &a;   <--- adresse des pointers?
}

du sagst die adresse ist *& ?

Soweit ich weiss ist

Meine_Klasse* &Instanz;

dasselbe wie

Meine_Klasse Instanz;

Jester

Bei nem Objekt a ist*&a das gleiche wie a.
Aber nicht bei Typen:

A a = ...; -> a ist Objekt vom Typ A.
A *& a = ...; a ist Referenz auf Pointer auf Objekt vom Typ A.

edit: btw. volkard: in Deiner for-Schleife kommt mir das *a als Bedingung komisch vor, soll das vielleicht *p heißen?

ne frage (klink mich mal einfach so ein ):

Wenn ich zb schreibe

zeiger1=zeiger1/zeiger2 wird da die variable auch überschrieben oder nur der Zeiger?

volkard

Jester schrieb:

edit: btw. volkard: in Deiner for-Schleife kommt mir das *a als Bedingung komisch vor, soll das vielleicht *p heißen?

jo, klar.

Jester

Was meinst Du mit dem /?
Generell kann man aber sagen: Wenn Du einen Zeiger veränderst, dann verändert sich auch nur dieser. Wenn Du dereferenzierst, dann kannst Du das Objekt verändern auf das gezeigt wird. Dadurch ändert sich aber der Zeiger nicht (es sei denn er zeigt auch sich selbst oder ähnliche Konstruktionen).

volkard

ptr schrieb:

[cpp]
Node*& findPlaceToInsertOrReplace(double x){
    ...
    return &a;   <--- adresse des pointers?
}

ups, da war wohl return a; gemeint (und entsprechend return *p).
normalerweise verwende ich zeiger auf zeiger für sowas und unten return 0; statt return a;

mit dem "/" meine ich einen divisions operator ^^

ich versteh folgende 2 kontrukte noch nicht;/

int* foo::operator->() 
{ 
       return &(ptr->val); 
}

mit &(ptr->val) bekomm ich die adresse?

Node*& findPlaceToInsertOrReplace(double x){ 
     ... 
     return &a;   <--- adresse des pointers? 
}

adresse auf referenz auf pointer? wie sagt man dass;)
wie muss hier noch der funktionsaufruf aussehen?
...bei nem array weiss ich auch das ein arr[i] das gleich ist wie ein *&arr[i]

Jester

asking a question schrieb:

mit dem "/" meine ich einen divisions operator ^^

Man kann Zeiger nicht durcheinander teilen.

volkard

ptr schrieb:

wie muss hier noch der funktionsaufruf aussehen?

ich denke da an sowas:

Node*& t=findPlaceToInsertOrReplace(3.14);
t=new Node(t->next,2.71);

Dravere

Jester schrieb:

asking a question schrieb:

mit dem "/" meine ich einen divisions operator ^^

Man kann Zeiger nicht durcheinander teilen.

Wieso nicht?

CObject *pOne, *pTwo; // Zwei Zeiger
int x = reinterpret_cast<int>(pOne);
int y = reinterpret_cast<int>(pTwo);
int r = x / y;
CObject *pResult = reinterpret_cast<CObject*>(r);

Wird bis auf ein paar Warnmeldungen und einigen seltsamen Blicken aktzeptiert. Der Verwendungszweck dabei bleibt mir allerdings auch schleierhaft ^^

Grüssli