pekare

Försöker lära mig c++ men boken jag läser kan omöjligt vara krångligare skriven.. Jag har fattat hur man skapar pekare och hur man använder dom men vad jag inte fattar är vad man ska använda dom till.... nån dom har lust att förklara på ett bra sätt?

Jag tror att ämnet har varit uppe ett par gånger tidigare, kanske en sökning ger bättre svar än vad jag ger. :)

Jag har förstått det så att en pekare är mycket snabbare än vad en vanlig lagring är, eftersom att en pekare innehåller adressen till ett värde i minnet medan en vanlig lagring måste letas upp i minnet av programmet. Det kanske beror lite på om man deklarerar sina pekare på stacken eller heapen, men jag håller ingen koll på sånt. :)

Har du använt en array någon gång?

Om ja, så har du använt pekare.

Ex: int filbunke[10];

filbunke är nu en int-pekare till första elementet i arrayen.
Så det finns två sätt att skriva ut t.ex. första elementet i arrayen.
Antingen genom filbunke[0] eller genom *filbunke.

Möjligt användningsområde:

En länkad lista - Innebär att du skapar en "kedja" med noder där varje nod innehåller data och en pekare till nästa nod i kedjan.

Ex: [5]->[7]->[2]->[42]->NULL

Första noden i kedjan innehåller sitt data(5) och en pekare till nästa nod vilken innehåller data(7) osv.

Har lite bråttom (FEST! :birp ) så jag har inte lagt ner någon större möda på att få det pedagogiskt nu.
Det finns säkert någon mer här som förklarar det mer ingående om du inte förstår av min beskrivning.

Capsning nästa! :birp :birp

Kan lägga till på den festande Phorphers beskrivning att alla språk använder pekare, skillnaden med C/C++ är att man som programmerare kommer åt dem direkt. Ett vanligt användningsområde är länkade strukturer / listor och arrays som sagt.
Array:

int array[100];
int *pek;
for(pek=array;pek<&array[100];pek++)
       _gör_nåt_med_pek_som_representerar_array[index]_

Länkad lista:

struct list {
int data;
struct list *next;
};

void stegaLista(const struct list *pek){
      while(pek!=NULL) {
           _gör_nåt_med_listelementet_data_som_här_är_en_int_
          pek = pek->next;
    }
}

Typungefär :)

Pekare används ofta för att allokera minne på heapen.

Ofta är det svårt att veta hur mycket minne man ska allokera på stacken, då kan man allokera på heapen med new eller malloc. Oavsett vilket man väljer, så får man en pekare.

Du ska alltså använda pekare när du vill allokera minne.

Låt säga att du har en klass som ska koppla upp sig mot en databas då instansen av objektet skapas. Låt säga att detta tar väldigt massa tid att göra. Du anropar funktionen Foo som tar din klass som parameter.

Funktionshuvud :

Foo(dinklass klassen)

Då Foo anropas kommer en lokal kopia lagras på stacken, dvs en ny instans av dinklass skapas och vid skapandet så kopplade objektet upp sig mot databasen (och det tog ju en massa tid).

Om man istället tar en pekare till dinklass i funktionen Foo så är det ju samma instans av dinklass-objektet som används och inget nytt objekt skapas.

Foo(dinklass* klassen)

I C++ finns ett alternativ till pekare som heter referenser. En referens är egentligen en pekare, en förenklad sådan för att minimera felrisken. Funtionen är den samma, men man kan inte göra bort sig som man kan med pekare. En referens kan man t ex inte göra ++ på och få den att peka till oinitierat minne.

Pekare används även vid dynamisk bindning med abstrakta klasser i C++.

Funktionspekare :-)

Sen är ju pekare en nödvändighet för att kunna "returnera" multipla värden från en funktion!

Du kan ju returnera en struct t ex.

Nej, du kan använda referenser, strukturer eller klasser.