C++/ przeciążenie operatorów

Cześć,
mam problem z jednym zadanie, jeżeli ktoś mógłby łopatologicznie wyjaśnić mi jak mam do tego podejść.

Polecenie:
Stwórz klasę CFigura, która zawiera:

• chronione pola int a, b
  - chronione pole int typ (może być równe 1 – koło, 2 – prostokąt, 3 – kwadrat, 0 – puste)

Mam tu zadeklarować nową klasę o nazwie TYP przechowującą pola typu int o nazwach koło, prostokąt, kwadrat etc. ?

Tego punktu za bardzo nie rozumiem.

• publiczny konstruktor dwuparametrowy inicjujący pola a, b
• publiczne czysto-wirtualne metody float pole() oraz void wypisz()
• publiczny operator +=. Jeżeli oba argumenty operatora są tego samego typu (pole typ)
  wtedy zwiększamy pola a i b lewego argumentu polami a i b prawego argumentu,
  jeżeli nie to pola a i b lewego argumentu są zerowane a typ jest ustawiany na 0.
  Operator ma być typu void.

Niektóre punkty to oczywista oczywistość:

class CFigura
{
	protected:
		int a, b;
                  
	public:
		CFigura(int x, int y): a(x), b(y)
		{
		} 
	virtual void wypisz()=0;
	virtual float pole()=0;
	
	void operator+=()
	{

	
};

 

Nie za bardzo rozumiem punkty pogrubiony dlatego też stoję z tym operatorem.
Jesli ktoś mógłby mi to wytłumaczyć w ludzki sposób o co chodziło autorowi zadania, byłbym wdzięczny.

Nie. Doczytaj co to enum - typ wyliczeniowy.

Faktycznie, zapomniałem. OK, zaraz wrzucę poprawiony kod ;) Dzięki !

 
class CFigura
{
        protected:
                int a, b;
                enum typ{kolo=1, prostokat=2, kwadrat=3, puste=0};
 
        public:
                CFigura(int x, int y): a(x), b(y)
                {
                } 
        virtual void wypisz()=0;
        virtual float pole()=0;
 
        void operator+=()
        {
 
 
};

Tak lepiej ?

Tak, ale teraz chyba już wiesz jak zrobić ten operator...

hunky napisał(a):

Stwórz klasę CFigura, która zawiera:

• chronione pola int a, b
  - chronione pole int typ (może być równe 1 – koło, 2 – prostokąt, 3 – kwadrat, 0 – puste)
  Niestety podejrzewam, że poziom zadającego zadanie jest niezbyt wysoki (sugeruje to min. nazewnictwo wzięte z MFC!). Prawdopodobnie sugeruje, żeby nie używać typów wyliczeniowych, a tylko "umawiamy się" że 1 to koło, 2 to prostokąt itd. (pole typ ma być typu int) . Oczywiście tak się tego nie powinno robić.

Shalom, dzięki. No własnie tak nie za bardzo:

 
// to bedziemy mieli w pliku z deklaracjami, o rozszerzeniu .h

void operator+=(typ &pierwszy_obiekt, typ&drugi_obiekt);

// a to juz w pliku o rozszerzeniu .cpp

void CFigura::operator+=(typ &pierwszy_obiekt, typ &drugi_obiekt)
{
	
}

Źle ten początek ?

.h

class CFigura
{
    /* ... */

    /* enum mówi nam, że pod takimi a takimi nazwami kryją się takie a takie wartości */
    enum TypFigury {kolo=1, prostokat=2, kwadrat=3, puste=0};

    /* musimy jeszcze gdzieś tą wartość przechować dlatego potrzebna nam zmienna (tj. pole klasy) */
    TypFigury typ;

    /* tak powinna wyglądać deklaracja operatora +=, dodajemy CFigura do CFigura */
    void operator+=(const CFigura &drugi_obiekt);
}

.cpp

/* tak powinna wyglądać definicja operatora += */
void CFigura::operator+=(const CFigura &drugi_obiekt)
{
    if (typ == drugi_obiekt.typ) { // porównujemy typy
        /* ... */
    } else {
        /* ... */
    }
}

operator+= to operator dwuargumentowy prawda ?
Linia const CFigura &drugi_obiekt oznacza ze jest to wskazanie na nowy obiekt klasy CFigura ? Tak ?

Dzieki wielkie za odpowiedź :)

To jest zagadnienie związane min. z wydajnością.

Zmienne można przekazywać przez wartość ("zwyczajnie"):

void JakasFunkcja(CFigura drugi_obiekt)

do funkcji trafia kopia zmiennej.

Można przekazywać przez referencję:

void JakasFunkcja(const CFigura &drugi_obiekt)

wtedy zmienna nie jest kopiowana, a do funkcji trafia referencja czyli tylko taki odnośnik do zmiennej. Użyłem const-referencji - dzięki temu JakasFunkcja nie będzie mogła zmodyfikować zmiennej do której prowadzi odnośnik a tylko ją odczytać (tak samo jak przy przekazywaniu przez wartość, bo wtedy funkcja dostaje własną kopię zmiennej a oryginalna zmienna jest nieruszana).

Referencje są opłacalne przy większych obiektach. Przy małych (np. int) nie opłaca się bo sama referencja (np. 8 bajtów) może mieć podobny rozmiar od zmiennej (np. 4 bajty). Aby z referencji otrzymać wartość trzeba tą referencję "dereferować" co wymaga niewielkich obliczeń więc nawet przy podobnych rozmiarach bardziej opłacalne jest jednak kopiowanie zmiennej niż przekazywanie przez referencję.