Operatoroverstyring..!

Et eksempel:

#include <iostream>
class Point
{
public:
   Point(int aX = 0, int aY = 0) : X(aX), Y(aY)
   {}
   int X, Y;
};

std::ostream& operator << (std::ostream& os, const Point& aP)
{
   os << aP.X << " " << aP.Y;
   return os;
}

const Point operator + (const Point& aA, const Point& aB)
{
   Point P(aA.X + aB.X, aA.Y + aB.Y);
   return P;
}

int main()
{
   Point A(1, 2);
   std::cout << A << std::endl;
   Point B(2, 3);
   Point C = A + B;
   std::cout << C << std::endl;
}

Her oprettes en class (Point), for at kunne udskrive den til cout som med f.ex. en int, laves en "std::ostream& operator <<" som er en overloadet operator.

Der er også en "const Point operator + " som gør at man kan lægge to punkter sammen.

Hvad: Det er en metode der gør det muligt at anvende almindelige operatorer på objekter.

Hvorfor: Fordi det i en række tilfælde er smart at skrive koden med operatorer i stedet for funktioner. Jeg kan bedre lide:
Point C = A + B;
End
Point C = Add(A, B);

Hvornår: Når det er det smarteste at gøre og operatoren giver mening. Man kunne godt have et vindue:
Window MyWindow;
Og så bruge ++ operatoren på Window til at opdatere det, og -- til at lukke det, men det er ikke den forventede opførsel for ++ og -- så lad være.

Jeg kan i øvrigt bedre lide operatoroverloading end operatoroverstyring, operatoren blive erstatter default (hvis der er en), der er ingen overstyring.

Tak Bertel, det hjalp. Jeg har dog stadig et par spørgsmål. Kunne du evt. forklare lidt om selve syntaksen?
f.eks.

const Point operator + (const Point& aA, const Point& aB)
{
   Point P(aA.X + aB.X, aA.Y + aB.Y);
   return P;
}

er lidt forvirrende.

Samtidig har jeg ikke læst om operatoroverloading. Hvad er forskellen på de to begreber?

Mvh. Anders Tornvig

Hvornår: Når det er det smarteste at gøre og operatoren giver mening. Man kunne godt have et vindue:
Window MyWindow;
Og så bruge ++ operatoren på Window til at opdatere det, og -- til at lukke det, men det er ikke den forventede opførsel for ++ og -- så lad være.

Til gengæld kunne man tilføje elementer til vinduet med += operatoren og tilgå elementer med []:

myWindow += new Label("Foo", x, y, width, height);
y += height + 5;
myWindow += new Button("Click on me", x, y, width, height);

myWindow[0].setText("Bar");

Operatoroverstyring og operatoroverloadning er to ord for det samme. Det første er et forfejlet forsøg på at oversætte det til dansk, det er heldigvis ved at glide ud af sproget sammen med "fastpladelager" (harddisk)

Koden:
const Point operator + (const Point& aA, const Point& aB)
{
Point P(aA.X + aB.X, aA.Y + aB.Y);
return P;
}

Er en operator som gør det muligt at addere to Point (aA og aB), som overføres som referencer til const Point, det gør det muligt at skrive:

Point X(1, 2);
Point Y = X + Point(2, 3);

operatoren returnerer et ny Point object.

I operatoren står der:
Point P(aA.X + aB.X, aA.Y + aB.Y);
Det opretter et nyt Point hvor X er summen af aA' X og bB's X og Y er summen af aA's Y og aB's Y.
Det er konstruktoren der bruges.

Syntaxen for operatoroverloads er en anelse mystisk, hvis man vil lave en post-fix ++ operator for Point kunne den se sådan ud:
Point operator ++ (Point& aP, int)

Prefix versionen kunne se sådan ud:
Point& operator ++ (Point& aP)

Det ses at det sidste argument i post-fix versionen ikke bruges til andet end at skelne den fra pre-fix versionen.

Efter lang tids studering af indlæggene, er det endeligt gået op for mig. Jeg siger pænt tak.