Vektorer som pekare

Pekararitmetik

Eftersom vi nu har visat att varje vektor är en pekare till minnesadressen för första elementet i en följd, kan vi titta lite vidare på aritmetik med pekare. En pekare är ju i grund och botten ett heltal (unsigned int) som pekare på en minnesadress. Vi kan förstås manipulera detta tal med normala aritmetiska operationer, såsom + och -. Vi kan skriva om ovanstående vektorexempel så vi använder pekare istället:

#include <iostream>
#include <iomanip>

int main () {

  int Tal [10];
  
  // iterera och fyll vår vektor med hjälp av vektorn använd som
  // en pekare
  for ( int Index = 0; Index < 10; Index++ ) {
    *(Tal + Index) = Index * Index;
  }

  // deklarera en annan pekare till vektorn
  int * TalPekare = Tal;
  
  // iterera nu och skriv ut talen
  cout << "Tal  kvadrat" << endl;
  for ( int Index = 0; Index < 10; Index++ ) {
    cout << setw (3) << Index << setw (9) << *TalPekare++ << endl;
  }
}

Utskriften är samma som för föregående program. Exemplet kan dock behöva vissa förklaringar. Innan det en pekare pekar på kan användas måste den avrefereras. Det görs t.ex. på raden

*(Tal + Index) = Index * Index;

Här adderas ett tal till pekaren och sedan avrefereras denna. På så vis kan vi få pekaren att iterera över de olika positionerna i vektorn. Vi måste ha en parentes, eftersom avrefereringsoperatorn har samma precedens som +, så utan parentes skulle vi addera Index till det som Tal pekar på. En stor skillnad. Senare skapas en pekare TalPekare och sätts att peka på Tal:

int * TalPekare = Tal;

Denna pekare är inte nödvänding men vi får då en chans att visa hur vi kan ha en temporär pekare att iterera över elementen i en vektor med operatorn ++:

*TalPekare++

Vad som händer här är att ++ fungerar som postfixinkrementerande, d.v.s. TalPekare:s värde ökas efter att den använts. Användingen i det här fallet är att den avrefereras. Efter användningen ökar ++ värdet på sin operand, alltså TalPekare med 1, och sätts således att peka på nästa element i vektorn.

Hur hänger det här ihop då? Den skarpsynte märker att en pekare är en normal unsigned int och operatorn ++ bode öka dess värde med 1, men det som Tal innehåller har troligtvis en storlek av 4 bytes per element. Operatorn ++ har alltså flyttat pekaren fram 4 minnesadresser!

I C++ är operatorn ++ så intelligent så den "vet" vilken datatyp en pekare pekar på, och kan således öka pekarens värde med så mycket som behövs för att flytta till nästa element. I fallet med t.ex. strägar som i bilden ovan flyttar ++ pekaren framåt så mycket som en char upptar, d.v.s. normalt 1 byte. Även --, +=, -= o.s.v. fungerar på samma sätt. I princip adderas (eller subtraheras) ett värde från pekaren som är lika stort som sizeof (datatyp). Med hjälp av ++ och -- kan man göra väldigt korta och effektiva iterationer över vektorer med hjälp av pekare. Ibland lönar det sig dock att offra lite effektivitet för att uppnå lättlästa program. Operatorn [] är trots allt lättare att förstå och läsa en direkt pekararitmetik! För den nyfikna kan nämnas att kompilatorer i de flesta fall översätter indexering med [] till pekararitmetik innan själva koden genereras.

Vektorer som funktionsparametrar

Vektorer kan förstås även skickas som parametrar till funktioner. Det finns två olika sätt att skicka vektorer som argument till funktioner, tack vare att vektorer är pekare. Man kan skicka dem som pekare eller som vektorer. Skickas de som pekare som vet mottagarfunktioner inte någonting om vektorns storlek, utan denna måste vara känd på något annat sätt, t.ex. via en annan parameter. Skickas den som en vektor så ges storleken som en del av parameterdefinitionen. Exemplet nedan använder sig av de två olika sätten:

#include <iostream>

void in (int * Tal, int Antal) {
  // iterera och läs in tal
  for ( int Index = 0; Index < Antal; Index++ ) {
    cout << "Ge in tal " << Index + 1 << ": ";
    cin >> *(Tal + Index);
  }
}

void ut (int Tal[3]) {
  // skriv ut vårt tal
  for ( int Index = 0; Index < 3; Index++ ) {
    cout << "Tal " << Index << " är: " << Tal[Index] << endl;
  }
}

int main () {
  int Tal [3];

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

Funktionen in() tar emot vektorn som en pekare. Enbart på bas av parameterdefinitionen vet man inte om det är frågan om en pekare till en enskild int eller om det är en pekare till första elementet i en vektor, därför skickas den extra parametern Antal med. Funktionen ut() däremot tar emot vektorn som en vektor, och då är ju storleken känd. Det senare sättet verkar ju vara mycket bättre, eftersom man då slipper bekymra sig om storlekar o.dyl., men den är även mera begränsad. Till ut() kan endast vektorer med tre element skickas, ingenting annat duger, medan in() är mycket mera flexibel och kan ta emot vilken storleks vektorer som helst. I båda fallen måste dock datatypen vara densamma hela tiden. Vilket sätt man förederar beror långt på till vad funktionen skall användas.