Överlagring av operatorn -

Överlagring av den binära operatorn - är i princip en liknande operation som att överlagra + (se ovan). Enda skillnaden är hur de olika komponenterna kombineras. I detta fall subtraheras komponenterna från varandra.

Vi kan definiera den överlagrade operatorn på följande sätt:

// 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;
}

Vi kan nu skriva kod som t.ex. följande:

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

// subtrahera vektorerna
Vector Result = V1 - V2;

Båda operatorerna + och - kan förstås kombineras ihop i diverse uttryck. Dessa evalueras enligt normal precedensordning, d.v.s. från vänster till höger om inte parenteser används för att indikera annan ordning.

Funderar vi lite närmare på operatorn - märker vi snabbt att den inte enbart fungerar som en binär operator för subtraktion, utan kan även användas unärt, d.v.s. men endast en parameter. I detta fall är det frågan om en negation av ett värde, eller i vårt fall, en vektor. Vi kan överlagra även den unära versionen av - i klassen Vector:

// prototyp
Vector operator- () const;

// implementation
Vector Vector::operator- () const {
  Vector Result;

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

  // returnera den nya vektorn
  return Result;
}

Metoden skapar en ny vektor som har ursprungsvektorns alla komponenter negerade. Vi får två metoder som heter operator-, men det är inget problem, eftersom de skiljer sig i vilka parametrar de accepterar, och kompilatorn vet således vilken metod som skall användas i olika situationer. Vi kan nu använda negationen i t.ex. följande kod:

Vector V1 ( 1, 2, 3 );

// negera vektorn
Vector Result = -V1;