Nauka przeciążenia operatorów na przykładzie dodawania współrzędnych punktów.

Question

Cześć :)

Uczę się właśnie przeciążenia operatorów i moim pierwszym mini zadankiem w celu przećwiczenia tego jest deklaracja dwóch punktów, a następnie utworzenia 3, który za pomocą przeciążenia operatora + załatwi całą sprawę dodawania współrzędnych.

Wzorowałem się na treści z tego filmu:

https://www.youtube.com/watch?v=N0R4rjUciuo

A oto i mój kod (praktycznie bez różnic):

main.cpp

#include <iostream>
#include "punkt.h"
using namespace std;

int main()
{
    Punkt X(5, 3);
    Punkt Y(2, 1);
    Punkt Z;
    Z = X + Y;
    return 0;
}

punkt.h

#include <iostream>
using namespace std;

class Punkt
{
private:
    int x, y;
public:
    Punkt(int a = 1, int b = 1);
    void read_object();
    friend Punkt  operator+ (Punkt& object);
};

punkt.cpp

#include <iostream>
#include "punkt.h"
using namespace std;

Punkt::Punkt(int a, int b)
{
    x = a;
    y = b;

}
void Punkt::read_object()
{
    cout << "X: " << x << " " << "Y: " << y << endl;
}
Punkt operator+ (Punkt& object)
{
    Punkt wynik;
    wynik.x = x + object.x;
    wynik.y = y + object.y;
    return wynik;
}

Odnośnie ostatniej definicji funkcji z przeciążeniem operatorów wydaje mi się, że to powinno być:

Punkt Punkt :: operator+ (Punkt& object)
{
    Punkt wynik;
    wynik.x = x + object.x;
    wynik.y = y + object.y;
    return wynik;
}

, ale wtedy pokazuje mi się praktycznie 2 razy więcej błędów niż mam obecnie.

Podaję jeszcze komunikaty, jakie mi wyskakują odnośnie błędów:

main.cpp

-dwuargumentowy "+":"Punkt" nie definiuje operatora lub konwersji do typu akceptowalnego dla wstępnie zdefiniowanego operatora

punkt.cpp

- "y" to niezadeklarowany identyfikator

- "x" to niezadeklarowany identyfikator

Z góry dziękuję za wszystkie odpowiedzi. :)

Comments

Taka jedna uwaga. Punktów geometrycznych się nie dodaje. Dodaje się wektory.

Można też dodać wektor do punktu - efekt to przesunięcie punktu.

Answer 1

Oba lekko pomieszane :)

Albo jako wolna funkcja:

// deklaracja w klasie
    friend Punkt operator+ (Punkt& lhs, Punkt& rhs);

// definicja
Punkt operator+ (Punkt& lhs, Punkt& rhs) { ...

Albo jako metoda:

// deklaracja w klasie (mozna tez od razu zdefiniowac tutaj)
    Punkt operator+ (Punkt& rhs);

// definicja
Punkt  Punkt::operator+ (Punkt& rhs) { ...

(a swoją drogą, to jeszcze `const` się przyda dodać wszędzie)

Answer 2

W takich sytuacjach zawsze warto spojrzeć do dokumentacji https://en.cppreference.com/w/cpp/language/operators

Operator dodawania jest operatorem dwuargumentowym.
Można go zdefiniować na dwa sposoby: jako metodę klasy lub jako funkcję zaprzyjaźnioną.

#include <iostream>

class A {
private:
    int mValue;
public:
    A(int value) : mValue(value) {}
    int value() const {
        return mValue;
    }
    // operator jako metoda klasy
    A operator+ (const A &other) const;
};

A A::operator+ (const A &other) const {
    int value = this->mValue + other.mValue;
    return A(value);
}

class B {
private:
    int mValue;
public:
    B(int value) : mValue(value) {}
    int value() const {
        return mValue;
    }
    // funkcja zaprzyjaźniona przyjmuje dwa elementy
    friend B operator+ (const B &first, const B &second);
};

B operator+ (const B &first, const B &second) {
    int value = first.mValue + second.mValue;
    return B(value);
}

int main()
{
    A a1(1), a2(2);
    B b1(1), b2(2);

    auto test1 = a1 + a2;
    auto test2 = a1.operator+(a2);
    auto test3 = b1 + b2;
    
    std::cout << "test1: " << test1.value() << std::endl;
    std::cout << "test2: " << test2.value() << std::endl;
    std::cout << "test3: " << test3.value() << std::endl;
  
}