Zdefiniowanie operatora "+=" – potrzebne podpowiedzi

Witam, w klasie Koszyk mam zdefiniować operator+=, tak, aby możliwe było dodanie produktów do koszyka, nie mogę sobie z tym poradzić, jakieś podpowiedzi?

Moja biblioteka

#include <iostream>
#include <vector>

using namespace std;

class Produkt
{
    public:
    string nazwa;
    double cena;

    public:
    Produkt(string, double);
    ~Produkt();

    friend ostream& operator <<(ostream&, const Produkt&);
};

class Nabial : public Produkt
{
    double tluszcz;

    public:
    Nabial(string, double, double);
    ~Nabial();

    friend ostream& operator <<(ostream&, const Nabial&);
};

class Chemiczny : public Produkt
{
    string ostroznosc;

    public:
    Chemiczny(string, double, string);
    ~Chemiczny();

    friend ostream& operator <<(ostream&, const Chemiczny&);
};

class Spozywczy : public Produkt
{
    string termin;

    public:
    Spozywczy(string, double, string);
    ~Spozywczy();


    friend ostream& operator <<(ostream&, const Spozywczy&);
};

class Koszyk
{
    public:
    friend ostream& operator+=(ostream&, const &Koszyk);
};


biblioteka.cpp
#include "kasa.h"

Produkt::Produkt(string _nazwa, double _cena) : nazwa(_nazwa), cena(_cena)
{

}

Produkt::~Produkt()
{

}

Nabial::Nabial(string _nazwa, double _cena, double _tluszcz) : Produkt(_nazwa, _cena), tluszcz(_tluszcz)
{

}

Nabial::~Nabial()
{

}

Chemiczny::Chemiczny(string _nazwa, double _cena, string _ostroznosc) : Produkt(_nazwa, _cena), ostroznosc(_ostroznosc)
{

}

Chemiczny::~Chemiczny()
{

}

Spozywczy::Spozywczy(string _nazwa, double _cena, string _termin) : Produkt(_nazwa, _cena), termin(_termin)
{

}

Spozywczy::~Spozywczy()
{

}



ostream& operator<<(ostream& os, const Produkt &p)
{
    os << "cena: " << p.cena << "  nazwa produktu: " << p.nazwa << endl;

    return os;
}

ostream& operator<<(ostream& os, const Nabial &n)
{
    os << "cena: " <<  n.cena << "  nazwa: " << n.nazwa << "  zawartosc tluszczu: " << n.tluszcz << "%" << endl;

    return os;
}

ostream& operator<<(ostream& os, const Chemiczny &ch)
{
    os << "cena: " << ch.cena << "  nazwa: " << ch.nazwa << "  srodek ostroznosci: " << ch.ostroznosc << endl;

    return os;
}

ostream& operator<<(ostream& os, const Spozywczy &s)
{
    os << "cena: " << s.cena << "  nazwa: " << s.nazwa << "  data waznosci: " << s.termin << endl;

    return os;
}

Podpowiedź:

void operator+=(const Produkt &produkt);

jako składnik klasy Koszyk.

rozumiem, że chcesz wypisać zawartość swojej klasy koszyk, czy co? std::ostream jako operator przeciążający += ? to zły pomysł. Zmień to tak, aby zaprzyjaźniona metoda dodawała produkty do koszyka. Wydaje mi się, że w tym wypadku nie musi być zaprzyjaźniona, jeden argument wystarczy. Użyj this i będzie oks

Żeby nie powtarzać w kółko tego samego kodu w operator<< możesz użyć takiego czegoś:

ostream& operator<<(ostream& os, const Nabial& nabial)
{
  const Produkt& produkt(nabial);
  os << produkt;
  os << "     zawartosc tluszczu: " << nabial.tluszcz << "%";
  return os;
}

MasterBLB napisał(a):

Podpowiedź:

void operator+=(const Produkt &produkt);

jako składnik klasy Koszyk.

Ajaj, źle się wyraziłem, chcę aby mój koszyk przechowywał produkty, a dokładniej nabiały, chemiczne oraz spożywcze i wypisać ten koszyk. Czy chodzi o to, abym do każdego napisał ten operator?

void Koszyk::operator+=(const Nabial &n)
{
n.cena << n.nazwa << n.tluszcz;
}

void Koszyk::operator+=(const Spozywczy &s)
{
s.cena << s.nazwa << s.termin;
}

Czy da się to jakoś inaczej załatwić?

Jak powinno wyglądać wnętrze tej funkcji, aby dodać to do koszyka? Brakuje tam ewidentnie "zapisu".

Dobrze kombinuje?

void Koszyk::operator+=(const Produkt& produkt)
{
    new Produkt(produkt.nazwa, produkt.cena);
}

void Koszyk::operator+=(const Nabial& nabial)
{
 new Nabial(nabial.nazwa, nabial.cena, nabial.tluszcz);
}

Generalnie dobrze, ale tak, ale Nabiał to też Produkt. Tutaj tak jak ci Brat Delor podpowiada poczytaj o dziedziczeniu, funkcjach wirtualnych i polimorfizmie. Podpowiedź - nie potrzebujesz oddzielnej definicji operatora specjalnie dla nabiału jak dobrze to skonstruujesz.

A, i skoro chcesz także wypisywać zawartość koszyka, to przyda się przeciążenie operatora << dla klasy Koszyk.

Operator dla klasy Koszyk

ostream& operator<<(ostream& os, const Koszyk &kosz)
{
    os << kosz.nazwa << endl;

    return os;
}

Coś mi nie wychodzi..., w klasie Produkt dodałem:

virtual void operator+=(const Produkt&);

W Nabiale itd.:

void operator+=(const Nabial&);

.cpp:

void Produkt::operator+=(const Produkt &p)
{
    new Produkt(p.nazwa, p.cena);
}

void Nabial::operator+=(const Nabial &n)
{
    new Nabial(n.nazwa, n.cena, n.tluszcz);
}

Przeczytałem o polimorfizmie, virtualach, dziedziczeniu i nic :{ Co robię źle?

Turoczek napisał(a):

void Produkt::operator+=(const Produkt &p)
{ ... }

void Nabial::operator+=(const Nabial &n)
{ ... }

Chcesz dodawać Produkt do Produktu i Nabiał do Nabiału?

void Produkt::operator+=(const Produkt &p) // <- dodaje Produkt do Produktu
void Nabial::operator+=(const Nabial &n) // <- dodaje Nabial do Nabialu
void Koszyk::operator+=(const Produkt &p) // <- dodaje Produkt do Koszyka (podpowiedź z poprzednich postów)
ostream& operator <<(ostream&, const Koszyk&); // <- wypisanie Koszyka
ostream& operator <<(ostream&, const Produkt&); // <- wypisanie Produktu

Wybierz co Ci potrzebne.

No chyba nie oczekujesz Bracie @Turoczek że zaimplementujemy je za ciebie?
Podpowiedź - aby Koszyk rzeczywiście przechowywał Produkty to klasa ta potrzebuje jakiegoś pojemnika na nie, na przykład std::vector<Produkt> produktyWKoszyku;. Jak już taki pojemnik utworzysz to w operatorze+= od klasy Koszyk robisz implementację dodawania nowego elementu do wektora, a Produkt do dodania dostaniesz jako parametr wywołania operatora.

No właśnie tej bariery przeskoczyć nie mogę, coś mi nie wychodzi.
Mam klasę Koszyk

class Koszyk
{
    public:
    string nazwa;
    Koszyk(string);
    Koszyk(const Koszyk&);

    vector<Produkt> prod;

    Produkt& operator+=(const Produkt &p);

    friend ostream& operator <<(ostream&, const Koszyk&);

};

Tak próbowałem to poskładać(pewnie kompletne bzdury), ale wyskakuje, iż class koszyk nie ma ceny. Wiem, że do vector dodaje się poprzez push.back(), ale jak to ugryźć :{ Jakaś podpowiedź?

Produkt& Koszyk::operator+=(const Produkt &p)
{
    this->nazwa += p.nazwa;
    this->cena  += p.cena;
    return (*this);
}

Jazda poczytać na cppreference.com o std::vector, a nie dyrdymały tworzyć!

Turoczek napisał(a):

Tak próbowałem to poskładać(pewnie kompletne bzdury), ale wyskakuje, iż class koszyk nie ma ceny. Wiem, że do vector dodaje się poprzez push.back(), ale jak to ugryźć :{ Jakaś podpowiedź?

Produkt& Koszyk::operator+=(const Produkt &p)
{
    this->nazwa += p.nazwa;
    this->cena  += p.cena;
    return (*this);
}

1. Dlaczego uparłeś się, żeby operator+= dla klasy Koszyk zwracał referencję do obiektu klasy Produkt? Widzisz tutaj logikę? Bo ja nie bardzo... ;)
2. W treści zadania nigdzie nie jest wspomniane, że klasa Produkt i dziedziczące po niej mają mieć zdefiniowany operator<<.
3. Żeby Koszyk mógł przechowywać obiekty różnego typu, musi korzystać ze wskaźników na typ bazowy.

Zlepiając to do kupy:
Klasa Produkt powinna posiadać wirtualną funkcję, która będzie wypisywała dane do strumienia. Ta funkcja powinna być nadpisywana przez klasy dziedziczące po klasie Produkt.
Klasa Koszyk powinna przechowywać obiekty w std::vector<Produkt*> (powinno w sumie być unique_ptr<Produkt>, ale domyślam się, że nie, bo nie i mają być wskaźnikowe golasy)
W klasie Koszyk definiujesz operator<<, który iteruje po wektorze produktów i wywołuje dla każdego obiektu metodę wypisującą dane.

2. Tak, wiem, to tylko dla siebie napisałem.

class Koszyk
{
    public:
    string nazwa;
    Koszyk(string);
    Koszyk(const Koszyk&);

    vector<Produkt*> prod;

    void kup(Produkt*);

    friend ostream& operator <<(ostream&, const Koszyk&);

};

void Koszyk::kup(Produkt* _p)
{
    prod.push_back(_p);
}

Wypisywanie

ostream& operator<<(ostream& os, const Koszyk &kosz)
{
    os << kosz.nazwa << endl;
    for(int i = 0 ; i < kosz.prod.size() ; i++)
    {
    os << "- " << (*kosz.prod[i]) << endl;
    }
    return os;
}

Tak zrobiłem, działa, ale dodawać operatorem += nie udaje się

Przewietrzenie pomogło :P W zasadzie masz już zrobione, jesteś na ostatniej prostej. Zdefiniuj operator+= jako składową klasy Koszyk tak:

void operator+=(const Produkt *p)

i wewnątrz niego dać:

kup(p);