C++-manual
Förutgående | Kapitel 21. Överlagring av operatorer | Nästa

# Överlagring av operatorn `+`

En fundamental funktion då man behandlar vektorer är möjligheten att addera vektorer. Vektorer adderas genom att placera dem efter varandra, varvid summan blir vektorn från den första vektorns startpunkt till den andra vektorns slutpunkt, enligt följande figur:

Figur 21-1. Vektoraddition

Addition av vektorerna `Vektor1` och `Vektor2` leder till resultatvektorn `Resultat`. Vill vi kunna göra denna operation med vår nuvarande definition av klassen `Vector` måste vi göra det manuellt med en speciell funktion eller metod som kan heta t.ex. `add()` eller något liknande. Vi kan istället överlagra operatorn `+`. Vi får då följande addition till klassen `Vector`:

    // prototyp
    Vector operator+ (const Vector & V) const;

    // implementation
    Vector Vector::operator+ (const Vector & V) const {
      Vector Result;

      // sätt den nya vektorns värden
      Result.setX ( m_X + V.m_X );
      Result.setY ( m_Y + V.m_Y );
      Result.setZ ( m_Z + V.m_Z );

      // returnera den nya vektorn
      return Result;
    }

Prototypen skall alltså placeras headerfilen och implementationen i implemenationsfilen. Vi skall nu titta lite närmare på denna kryptiska metod. I C++ använder man nyckelordet `operator` för att berätta att man nu behandlar en operator av något slag. Man placerar den önskade operatorn efter nyckelordet `operator`, i vårt fall operatorn `+`. Detta blir alltså metodens namn. Som parameter tar metoden en annan `Vector`, som är den vektor vi vill addera till nuvarande vektor. Vi definierar `V` som en konstant referensparameter för att öka effektiviteten och eftersom vi inte vill ändra den på något sätt. Själva metoden är även `const`, eftersom vi inte ämna ändra nuvarande vektor heller. Däremot är returtypen `Vector`. Detta är resultatet av vår metod och alltså summan av de två vektorerna. Inne i metoden `operator+` definierar vi en ny `Vector` som vi tilldelar korrekta värden på de olika koordinaterna samt till sist returnerar.

## Använda överlagrade operatorer

Vi har nu definierat en överlagrad operator `+`, men hur används denna? Som vi redan såg så heter metoden `operator+()`. Vi kan således använda klassen på följande sätt:

    Vector V1 ( 1, 2, 3 );
    Vector V2 ( 6, 5, 4 );

    // addera vektorerna
    Vector Result = V1.operator+ ( V2 );

Inte speciellt praktiskt, eller hur? Här kommer dock en del magi in i bilden. Man kan istället för att skriva `operator+` skriva endast `+` och även lämna bort parentesen. Ovanstående kod kunde alltså även skrivas:

    Vector V1 ( 1, 2, 3 );
    Vector V2 ( 6, 5, 4 );

    // addera vektorerna
    Vector Result = V1 + V2;

Nu börjar det lika någonting. Vi kan nu helt transparent addera vektorer till varandra. Vi kan även addera flera än två vektorer samtidigt:

    #include <iostream>
    #include "Vector2.h"

    int main () {
      Vector V1 ( 1, 2, 3 );
      Vector V2 ( 6, 5, 4 );
      Vector V3 ( -1, -2, -3 );

      // addera vektorerna
      Vector Result = V1 + V2 + V3;

      cout << "x=" << Result.x () << ", "
           << "y=" << Result.y () << ", "
           << "z=" << Result.z () << endl;
    }

Detta fungerar eftersom den första additionen av `V1` och `V2` returnerar en ny vektor som sedan i sin tur adderas med `V3`. Vi kunde använda parenteser för att framtvinga en viss evalueringsordning, men vektoraddition är kommutativ, så ordningen spelar ingen roll. Körning av programmet ovan ger oss följande (korrekta) utskrift:

    % ./TestVector2_2
    x=6, y=5, z=4
    %

Alla överlagrade operatorer kan anropas utan `operator` X, där X är namnet på operatorn i fråga, men man kan göra det om man vill explicit visa att det är en överlagrad operator som anropas. Vi har här nått en viss transparens för vår klass `Vector`, nu återstår endel andra operatorer innan klassen är användbar i praktiken.

## Överlagring av `+=`

Vi skall ännu i demonstrationssyfte överlagra operatorn `+=` för att skapa en metod som ändrar på objektet för vilket operatorn används. Vi kanske vill kunna skriva kod såsom t.ex.:

    Vector V1 ( 1, 2, 3 );
    Vector V2 ( 6, 5, 4 );

    // addera vektor V2 till V1
    V1 += V2;

Det görs med följande kod:

    // prototyp
    void operator+= (const Vector & V);

    // implementation
    void Vector::operator+= (const Vector & V) {
      m_X += V.m_X;
      m_Y += V.m_Y;
      m_Z += V.m_Z;
    }

Metoden helt enkelt ändrar på medlemmarna för `V1` i exemplet ovan. Notera att metoden inte är definierad som `const` som de tidigare, eftersom den ändrar det anropande objektet.

Förutgående | Hem | Nästa
Överlagring av operatorer | Upp | Överlagring av operatorn `-`