Avreferera pekare

Pekare är inte till mycken glädje om man endast kan använda dem till att skriva ut adresser. Som redan tidigare nämnts så kan man även accessera det data som en pekare refererar till. Detta görs genom att använda avrefereringsoperatorn *. Symbolen * har många användningsområden. Allmänt ser det ut så här:

*pekare;

Ett exempel klargör vad det är frågan om:

#include <iostream>

int main () {

  double Tal;
  double * TalPekare = &Tal;

  // skriv ut adressen på talet och pekarens adress
  cout << "Tal har värdet       : " << Tal << endl;
  cout << "*TalPekare har värdet: " << *TalPekare << endl;
}

På den använda maskinen ger programmet följande utskrift:

% Pointers3
Tal har värdet       : 10
*TalPekare har värdet: 10
%

Både Tal och *TalPekare gav samma värde. Så länge som pekaren pekar på Tal kommer det alltid att vara så. Man kan använda en avrefererad pekare i alla sammanhang som man kan använda variabeln som pekaren pekar på. Man kan säga att en avrefererad pekre har samma datatyp som datatypen den pekar på. I exemplet ovan skulle Talpekare kunna användas i alla sammanhang där double kan användas. Man kan t.ex. tilldela eller jämföra en avrefererad pekare.

Pekare som parametrar

Pekare kan förstås även skickas som parametrar till funktioner och även returneras som funktionsvärden. Genom att skicka pekare till en funktion kan den mottagande funktionen ändra på det värde pekaren pekar på. Samma effekt kan nås om man istället för pekare använder referensparametrar som specificeras med tecknet &. De båda påminner mycket om varandra, och största skillnaden är hur man refererar till dem. Pekare måste avrefereras med referensparametrar inte behöver göra det. Om man vill skicka parametrar som skall kunna modifieras till funktioner är det egalt vilket sätt som används. Ett exempel på en funktion som läser in ett värde i en funktion och skriver ut det i en annan:

#include <iostream>

void in (int * Tal) {
  // läs in ett tal
  cout << "Ge in ett tal: ";
  cin >> *Tal;
}

void ut (int * Tal) {
  // skriv ut vårt tal
  cout << "Talet är: " << *Tal << endl;
}

int main () {
  
  int Tal;

  // läs in och skriv sedan ut
  in ( &Tal );
  ut ( &Tal );
}

Pekare kan alltså hanteras som vilken annan datatyp som helst då det gäller att skicka dem som parametrar. Notera att om en pekare skickas som parameter kan endast värdet på det som pekaren pekar på ändras, inte själva adressen den pekar på. I exemplet ovan kan t.ex. in() inte ändra Tal att peka på en annan variabel. Minnesadressen som skickats till int() och ut() kan inte ändras, den är "kopierad" från main(). Vill man kunna ändra den minnesadress en pekare pekar på i t.ex. in() måste en pekare till en pekare skickas som parameter. Detta skrivs med två **. Det är dock sällan man behöver anända pekare till pekare.

Konstanta pekare

Det går även definiera pekare som konstanter på olika sätt. Man kanske vill skicka en pekare till någon speciell datatyp som en parameter till en funktion, men inte vill att mottagaren skall kunna ändra det pekaren pekar på. I så fall kan man skapa konstanta pekare och använda const som extra parameterbeteckning i den mottagande funktionen. En konstant pekare kan deklareras t.ex. på följande sätt:

const int Tal = 100;
const int * KonstantPekare = &Tal;

En funktion som tar en konstant som parameter pekare kan se ut på följande sätt:

void berakna (const int * Tal) {
  ...
}

Man kan även definiera en pekare själv som konstant, trots att det den pekar på inte är det. I så fall kan man använda följande form:

int Tal = 100;
int * const KonstantPekare = &Tal;

I detta fall kan man nog ändra värdet på det som KonstantPekare pekar på, men däremot inte på pekaren själv. Den är alltså "låst" att peka på en och samma minnesadress. Med en const int * kan man nog ändra på själva pekarens värde, d.v.s. vilken minnesadress den pekar på, men däremot inte värdet på det den pekare på. En tredje form kombinerar dessa båda formerna och skapar en konstant pekare där man inte kan ändra på vare sig pekaren eller det pekaren pekar på:

int Tal = 100;
const int * const KonstantPekare = &Tal;

Speciellt den första formen med pekare som inte kan ändra på det de pekar på används ofta då man skickar data som funktionsparametrar. Numera verkar man dock även i de fallen gå över till att använda referensparametrar istället, och definiera parametrarna som const istället. Genom att använda referensparametrar behöver man inte komma ihåg vilka funktioner som skall ha pekare och vilka funktioner som skall ha normala parametrar. Använder man referensparametrar med const på lämpliga ställen är funktionerna lättare att använda ur anroparens synpunkt.