MfG, C++Progger

Pointer braucht man bei dynamischer Speicherverwaltung.

bis bald
akari

Hi, ich habe gelesen dass Anfänger wie ich Pointer zwar hassen, aber dass Experten sie lieben. Was nützen also Pointer?

MfG, C++Progger

C++ experten werden pointer auch eher weniger lieben. C++ Experten lieben eher Referenzen.

Du kannst zB einen Pointer auf ein Objekt/Struktur übergeben, was von der Performance her besser geeignet ist.

Wenn du stattdessen das gesamte Objekt/Strucktur übergibts, so wird auf dem Stack eine Kopie davon angelegt.

Pointer sind 4 byte klein. Wenn du zB eine 32 byte Struktur direkt übergibst, so werden 32 bytes aquf den stack geschoben.

Übergibst du dagegen nur einen pointer auf die struktur, so werden grad mal 4 bytes auf den stack geschoben => effizienter.

Im übrigeb braucht man pointer für callbacks und anderes.

Du kannst zb einen pointer auf etwas als ein handle nutzen.

wie funktioniert das hier?

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

MfG

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;
}

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

warum nicht? das ist dann wie ein doppelpointer

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.

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

wird er wieder umschwenken und pointer und referenzen meiden

Sind Referenzen inzwischen auch der Teufel?

EDIT: Quote tag korrigiert

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

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.

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

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 *& ?

Meine_Klasse* &Instanz;

dasselbe wie

Meine_Klasse Instanz;

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?

Wenn ich zb schreibe

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

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

jo, klar.

[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;

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]

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

Man kann Zeiger nicht durcheinander teilen.

wie muss hier noch der funktionsaufruf aussehen?

ich denke da an sowas:

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

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