pekare.xmlDenna kod är public domain. Om ni hittar fel eller vill ändra något i koden blir jag jätteglad om ni skickar dessa ändringar till jesper [at] fantasi [punkt] se.
<?xml version="1.0"?>
<article category="software" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="article.xsd">
<keyword>Pekare</keyword>
<keyword>Adress</keyword>
<keyword>Referens</keyword>
<keyword hidden="true">pekaren</keyword>
<keyword hidden="true">referensen</keyword>
<keyword hidden="true">referenser</keyword>
<keyword hidden="true">adressen</keyword>
<keyword hidden="true">adresser</keyword>
<topic>Pekare / Referenser</topic>
<ingress>
Pekare, referens och adress... Kärt barn har många namn. Det
pekaren pekar på, referensen refererar till och adressen
lokaliserar är helt enkelt en plats i datorns minne. En
minnescell. Man kan se minnet i datorn som en gigantisk array av
bytes, och adressen är då helt enkelt indexet i arrayen. Det
finns många skäl till att man som programmerare bör känna till
pekare och ha någorlunda koll på hur de fungerar och framför allt
hur de inte fungerar, även om man endast jobbar i högnivåspråk som
av en eller annan anledning påstår att de inte har några pekare.
</ingress>
<text>
Allt data som vi hanterar i våra program kommer att ligga
någonstans i datorns minne. Denna plats i minnet kommer att ha en
adress som pekar ut just den minnescell där datat ligger. Om vi
någonstans i vårt program skapar ett objekt kanske detta råkar
hamna på minnesposition 400. När vi lite senare vill komma åt
detta objekt så måste datorn veta var i minnet det ligger - vilken
adress det ligger på. Adressen fick vi från datorn när vi skapade
objektet (det fungerar så i många programmeringsspråk), och
eftersom vi var förutseende så sparade vi den i en pekare.
Pekaren, som alltså är en helt vanlig variabel, innehåller siffran
400 - objektets adress.
</text>
<subtopic>Pekare i Java</subtopic>
<text>
Programmeringsspråket Java är tänkt att vara ett högnivåspråk. Man
brukar säga att det inte finns några pekare i Java och man ska
inte behöva veta något om pekare eller andra detaljer för att
kunna använda språket. Dock märker man ganska snabbt att det krävs
en viss förståelse för pekare om man vill skriva större program,
och tittar man lite under ytan så ser man att Java är fullt av
pekare. Precis allting är pekare - fast man kallar dem för
referenser istället.
</text>
<text>
I Java kallas pekare oftast för <em>referenser</em>, men de är inget
annat än vanliga adresser där heller. När man i Java skriver
<code>String ord;</code> så har man skapat en
<em>referensvariabel</em>. Detta är en variabel som senare kan
innehålla en adress till ett strängobjekt. Än så länge så är den
dock tom, vi har inte skapat något objekt ännu. För att skapa
objekt i Java använder man kommandot <code>new</code> och
det är först när vi skriver <code>new String("Hej");</code> som vi
faktiskt skapar strängobjektet. Kommandot <code>new</code>
returnerar adressen till det nya objektet, om vi vill ha kvar den
måste vi alltså spara den i en referensvariabel. <code>ord = new
String("Hej")</code> är alltså det vi vill skriva.
</text>
<text>
Vi kan nu skicka <code>ord</code> som argument till metoder som
vill hantera strängen. Det är nu vi kan se själva poängen med
referenserna. Det argument som skickas till metoden är alltså bara
en adress till objektet, inte hela objektet. Detta spar både tid
och plats eftersom en adress är mycket mindre än ett objekt. Att
förstå skillnaden mellan referenser och objekt är ett av de första
svåra stegen när man lär sig Java.
</text>
<subtopic>Pekare i C</subtopic>
<text>
Pekare i Java är ändå ganska snälla. Man kan inte göra särskillt
mycket med dem, och man behöver aldrig använda dem till annat än
att just referera till objekt med. Ett annat språk där pekare är
betydligt mer mångsidiga och därför mycket svårare att hantera är
C.
</text>
<text>
Om vi i C skulle deklarera strängen "Hej" så skulle det kunna
göras med <code>char *ord = "Hej";</code>. <code>ord</code> är nu
en pekare till den plats i minnet där "Hej" allokerats (på
stacken) och precis som i Java kan vi skicka <code>ord</code> som
argument till en funktion.
</text>
<text>
I C är adressen bara är ett tal, som vilket annat tal som helst,
och man kan därför utföra allehanda aritmetiska operationer på
dem. <code>ord</code> pekar sedan tidigare på "Hej". Skulle vi
utföra en helt vanlig addition på adressen och lägga till ett
(<code>ord++;</code>) så har vi alltså stegat fram adressen till
nästa minnescell.
</text>
<text>
En annan sak som gör att det är lite krångligare i C än exempelvis
Java, är att allt inte nödvändigtvis är pekare. Det är därför
viktigt att man tänker sig för när man skickar agrument till
funktioner i C. Om man gör fel är det nämligen inte bara adressen
som skickas utan hela objektet, vilket, som vi sagt tidigare, tar
onödig plats och tid. Skulle vi deklarera en variabel <code>struct
string mening;</code> så är <code>mening</code> inte en pekare,
utan själva objektet. Vill vi ha en pekare till
<code>mening</code> så måste vi ta ut adressen med
<code>&amp;mening</code>. <code>&amp;</code> och
<code>*</code> är två viktiga operatorer när det handlar om
pekare. Mycket magi kan blandas till med dessa, men i grunden är
de enkla att förstå. <code>*</code> använder man om man har en
adress och vill ha ut det som ligger på den adressen (man följer
en pekare). <code>&amp;</code> använder man om man har ett
objekt och vill ha dess adress.
</text>
<text>
Pekare och referenser förekommer i nästan alla program. Vill man
inte veta så mycket om dem så väljer man att programmera i ett
högnivåspråk, tycker man att de verkar trevliga så kan man mycket
väl experimentera med dem i C eller något annat lågnivåspråk.
</text>
</article>
| 
