För en del år sedan hade jag hand om fyra programmeringskurser vid Göteborgs universitet. Nedanstående artikel är hämtad ur min disposition för en introduktionsföreläsning om pekare.

Du är välkommen att kopiera och använda texten såframt källan anges. Materialet kan användas som kompendium för både högskola och gymnasium.

Hursomhelst, här kommer texten:

Definition av variabler
När vi definierar en variabel av en viss typ (exempelvis double) reserveras ett litet utrymme i datorns minne. Detta utrymme är exakt så stort att ett värde av denna typ (alltså double) får plats. Vi kan föreställa oss att vi skapar en liten korg som sedan kan innehålla ett värde. Korgen har ett namn (variabelns namn) och en storlek (variabelns datatyp).

Vi kan rita detta:

Om vi nu lägger in ett tal i variabeln, så kan detta också ritas:

Pekare
En pekare används för att beskriva den plats vi har reserverat i datorns minne när vi har definierat någonting (till exempel en variabel, ett objekt eller en funktion).

En sådan plats kännetecknas av:
• att den finns på ett ställe (detta ställe kallas vanligtvis adressen för variabeln)
• att den har en viss storlek (som kan mätas i bytes)
• att den har en viss typ (vilket innebär att enbart värden av denna typ kan lagras på platsen)

Kort sagt: En pekare är en liten mängd information som beskriver en plats i datorns minne genom att lagra platsens adress och platsens datatyp (vilken i sin tur lagrar platsens storlek).

Egentligen är ordet pekare en gemensam benämning på två olika begrepp, nämligen pekarvärde och pekarvariabel. Det blir enklast om vi härefter skiljer på dessa två begrepp, precis som när vi skiljer på exempelvis heltalsvärde och heltalsvariabel.

Pekarvärden
Ett pekarvärde är den adress som beskriver för datorn på vilken plats en variabel, ett objekt eller en funktion finns. Varje ny variabel som definieras får en helt egen adress eftersom varje variabel placeras på en ny plats. Två olika variabler kan aldrig ha samma adress.

Varje adress är ett heltal som skrivs på hexadecimal form, exempelvis 55A2116B. Vi kan aldrig veta i förväg vilken adress som tilldelas till en variabel. Detta avgörs internt av programmet (i en sorts samarbete med operativsystemet) när programmet körs.

Men vi kan rita ett pekarvärde som en pil. Eftersom ett pekarvärde är adressen till en variabel, så låter vi pilen peka på denna variabel. Så här kan det se ut:

Adressoperatorn &
Om vi har en variabel så kan vi få fram ett pekarvärde för denna variabel genom att använda adressoperatorn. Den skrivs med &-tecknet.

Uttrycket &tal ger som resultat det pekarvärde som pekar på variabeln tal, d.v.s. adressen till tal.

Pekarvariabler
Precis som med alla andra värden (heltalsvärden, flyttalsvärden etc.) så går det att skapa en variabel som kan innehålla pekarvärden. En sådan variabel kallas en pekarvariabel.

För att definiera en pekarvariabel måste man använda tecknet * vid definitionen:

Om vi nu tilldelar pekarvärdet &tal till pekarvariabeln pek, så ser det ut så här:

Avrefereringsoperatorn *
Om vi har ett pekarvärde så kan vi få fram det som finns på denna adress genom att använda *-operatorn (även kallad stjärnoperatorn ibland). Den skrivs med tecknet * (förväxla inte denna operator med samma symbol som används vid multiplikation av tal eller, som ovan, vid definiering av pekarvariabler).

Uttrycket *pek ger som resultat det som finns på den adress som lagrats i pekarvariabeln pek.

Man kan använda stjärnoperatorn både vid tilldelningar (jmf. exemplet nedan) eller som ett ingående uttryck i andra typer av satser.

Tom pekare
Säg att vi har skapat en pekarvariabel för senare bruk, men ännu inte satt denna pekare att peka på någonting. Då finns det inget giltigt pekarvärde i pekarvariabeln, vilket kan leda till problem om man försöker använda det som pekaren pekar på – eftersom vi inte vet vart den pekar! För att undvika detta problem bör man använda en så kallad tom pekare (även kallad nollpekare). En tom pekare skapas genom att tilldela pekarvariabeln heltalsvärdet noll.

Man kan rita ett kryss i bilden av pekarvariabeln för att visa att den inte innehåller någon pil.

Ett exempel med pekare

Fält och pekare
I mina texter använder jag ofta benämningen fält för det begrepp som på engelska heter array, eftersom jag tycker, att har man nu översatt större delen av de engelska programmeringsbegreppen till svenska (t.ex. pointer=pekare, value=värde och integer=heltal), så bör man vara konsekvent och hitta lämpliga översättningar på samtliga begrepp. I en del programmeringsböcker föreslås den svenska termen vektor för det engelska array. Men detta är tanklöst eftersom den termen redan är upptagen. Dels används matematiska vektorer flitigt vid avancerade beräkningar i datorprogram och dels finns det en standardmall i C++ med namnet vector.

Hursomhelst, följande gäller: namnet på ett fält är i själva verket ett konstant pekarvärde som pekar på första elementet i fältet. Fältnamnet kan aldrig sättas att peka på någonting annat än första elementet i fältet. När man har definierat ett fält, så finns det alltid detta konstanta pekarvärde av samma typ som fältet.

Med indexoperatorn [ ] kan man få fram ett visst element i ett fält. Men detta skulle man lika gärna kunna göra med hjälp av stjärnoperatorn och additionsoperatorn. Uttrycket hf[3] har samma värde som uttrycket *(hf+3) och är alltså det som finns 3 steg framåt från första elementet i fältet. Storleken på varje steg beror på vilken typ pekarvärdet har. Exempelvis har en int storleken 4 bytes.

Strängar och pekare
Den typen av strängar som vi skapar med hjälp av ett fält av tecken, d.v.s. ett fält vars element har typen char, hänger nära ihop med pekare. Namnet på ett fält är alltid ett konstant pekarvärde som pekar på första elementet i fältet. Detta gäller även för strängar.

Lägg märke till att strängens sista element är talet 0. När detta tal tolkas som ett tecken kallas det ett nolltecken och markerar strängens slut. Förväxla inte talet 0 med tecknet ’0’ som har värdet 48.

Det går som bekant även att i sin kod (C eller C++) skriva in teckenfältsliteraler (konstanta teckenfält, d.v.s. strängar som inte ligger i ett definierat fält). En teckenfältsliteral är alltid ett pekarvärde som pekar på sitt eget första element. Detta kan också ritas:

Dynamisk minnesallokering
Med new-operatorn (och new[ ]-operatorn) kan man direkt allokera minne (d.v.s. reservera minne) under programkörningen. Operatorn new gör två saker:
1) Den reserverar ett minnesutrymme av samma typ som den man anger när operatorn används.
2) Den lämnar ett pekarvärde som resultat. Pekarvärdet pekar på det utrymme som har reserverats.

Här har vi en situation där det reserverade minne inte har något eget namn, varken direkt (t.ex. ett variabelnamn) eller indirekt (t.ex. namnet på ett statiskt definierat fält). Det enda sättet för programmeraren att komma åt det reserverade utrymmet är via det pekarvärdet som lämnades som resultat av new-operatorn då denne användes. Därför är det viktigt att inte ”slarva bort” detta pekarvärde utan genast spara det i en lämplig pekarvariabel, precis som i exemplet ovan där pekarvärdet sparas i pekarvariabeln pp.

Pekararitmetik
Aritmetik betyder räknelära eller en mängd regler för hur man får räkna. Helt beroende på vilka enheter beräkningarna innehåller (exempelvis reella tal, hela tal, äpplen, pekarvärden i C++ eller tidpunkter) så används olika aritmetiker. För alla våra vardagliga siffror används den aritmetik som vi lär oss redan i grundskolan, nämligen den som innehåller de fyra räknesätten: addition, subtraktion, multiplikation och division. Men det är långt ifrån alla aritmetiker som har fyra räknesätt (i C++ talar man om s.k. operatorer istället för räknesätt).

För pekarvärden finns det två grundläggande aritmetiska operationer vi kan utföra: 1) Lägga till ett heltal och 2) dra ifrån ett heltal. Om vi adderar ett pekarvärde, säg p, med ett heltal, säg h, så får vi som resultat ett nytt pekarvärde som pekar h steg framåt, räknat från p. Det samma gäller vid subtraktion.

Om vi bara vill ändra pekaren till att peka ett steg fram eller tillbaka i minnet, så används med fördel operatorerna ++ och –– (öknings- och minskningsoperatorn).

Ett exempel med pekaraddition

Mer om indexeringsoperatorn
Indexeringsoperatorn [ ] skulle man i princip kunna ta bort ur språket C++, eftersom allt den gör är att sätta ihop en pekaraddition och en *-operation. Men det underlättar onekligen läsningen av vår källkod om vi använder indexeringsoperatorn när vi arbetar med fält.

Hursomhelst, ISO-standarden för C++ säger att:
a[b] == *(a+b), där a är ett pekarvärde och b är ett heltal.

En lite bisarr konsekvens av detta blir att eftersom addition är kommutativ (detta gäller även i pekararitmetiken), så får vi följande:

a[b] == *(a+b) == *(b+a) == b[a]

Exempelvis kan vi istället för text[4] skriva 4[text] om vi vill ha tag i element nummer 4 i ett fält som heter text. Eller ännu värre:

Uttrycket ”Hejsan”[3] har som resultat tecknet ’s’ eftersom indexeringsoperatorn tar fram element nummer 3 (alltså det fjärde elementet) i teckenfältsliteralen (”Hejsan” är ju ett pekarvärde). Men med ovanstående resonemang kan vi lika gärna skriva 3[”Hejsan”] – och visst, det går bra!