Które rozwiązanie jest lepsze i dlaczego?

pytanie zadane 6 lipca 2022 w C i C++ przez Daaa22 Dyskutant (8,250 p.)

Chce stworzyć strukturę która jest parą uporządkowanych liczb. Które z tych rozwiązań powinno zostać użyte i dlaczego? A może jeszcze jakieś inne?

template<typename T>
struct Point
{
	T x, y;

        //pierwsze
	Point operator + (Point point)
	{
		return { x + point.x, y + point.y };
	}

        //drugie
	Point operator + (Point point) const
	{
		return { x + point.x, y + point.y };
	}

        //trzecie
	inline Point operator + (Point point)
	{
		return { x + point.x, y + point.y };
	}

        //czwarte
	inline Point operator + (Point point) const
	{
		return { x + point.x, y + point.y };
	}
};

Zauważyłem też że można "inline" dodać przed "Point" i po "Point", czym to się różni?

Jeszcze mogę w argumentach operatora wpisać (Point& point), powinienem to zrobić?

2	komentarz 6 lipca 2022 przez j23 Mędrzec (194,920 p.) Jawne inline'owanie metod, które są zdefiniowane wewnątrz klasy, jest zbędne, ponieważ takie metody są domyślnie inline.

1 odpowiedź

odpowiedź 6 lipca 2022 przez Oscar Nałogowiec (29,290 p.)

Podany operator + (tak jak i normalne, matematyczne) jest symetryczny względem argumentów, więc IMHO powinien być zaimplementowany jako funkcja (być może zaprzyjaźniona) a nie jako metoda klasy, bo w tym drugim przypadku oba argumenty traktowane są różnie. Metoda jest fajna dla np. operatora +=.

Przekazanie parametrów jako referencji jest całkiem OK - mniej pomocniczych konstruktorów się wykona.

Żaden z argumentów się nie zmienia więc przydałoby się parę const.

komentarz 6 lipca 2022 przez Daaa22 Dyskutant (8,250 p.)

Czyli coś takiego?

template<typename T>
struct Point
{
    T x, y;
 
    const Point<T>add( Point<T>&point )
    {
        return { x + point.x, y + point.y };
    }
}

Czy to jest idealne rozwiązanie?

komentarz 6 lipca 2022 przez j23 Mędrzec (194,920 p.)

Raczej to:

template<typename T>
struct Point {
    T x, y;
    
    using this_type = Point<T>;

    this_type operator+(const this_type &p) const
    {
        return { x + p.x, y + p.y };
    }

// lub

    friend this_type operator+(const this_type &p1, const this_type &p2)
    {
        return { p1.x + p2.x, p1.y + p2.y };
    }

};