Jakby komuś się przydało to to jest uml od gadających owoców:


jakby co to metoda "przedstaw_sie()" w klasie Owoc jest metodą abstrakcyjną, natomiast ta sama metoda w klasie Jabłko jest metodą polimorficzną (virtual).
Uwaga: zmienne waga i Nazwa w zmiennej owoc powinny być private!!

To teraz czas na trochę kodu :)

kosz.h:

#ifndef KOSZ_H
#define KOSZ_H
#include "owoc.h"
#include <vector>
using namespace std;
class Kosz
{
private:
    vector<Owoc*> Owoce;
public:
    Kosz();
    void dodajOwoc(Owoc* owocek);
    void przedstawOwoce();
    void podajWage();
};

#endif // KOSZ_H

kosz.cpp:

#include "kosz.h"

Kosz::Kosz()
{
}
void Kosz::dodajOwoc(Owoc* owocek)
{
    this->Owoce.push_back(owocek);
}
void Kosz::przedstawOwoce()
{
    for(int i=0; i<this->Owoce.size();i++)
    {
        this->Owoce.at(i)->przedstawSie();
        cout<<endl;
    }
}
void Kosz::podajWage()
{
    double Waga_kosza;
    for(int i=0; i<this->Owoce.size();i++)
    {
        Waga_kosza+=this->Owoce.at(i)->zwazOwoc();
    }
    cout<<"Owoce w koszyku waza razem "<<Waga_kosza<<" kg.";
}

owoc.h:

#ifndef OWOC_H
#define OWOC_H
#include <stdio.h>
#include <cstdlib>
#include <string>
#include <iostream>

using namespace std;

class Owoc
{
private:
    double waga;
    string Nazwa;
public:
    Owoc(double weight);
    void virtual przedstawSie()=0;
    double zwazOwoc();
};

#endif // OWOC_H

owoc.cpp:

#include "owoc.h"

Owoc::Owoc(double weight)
{
    this->waga=weight;
}
void Owoc::przedstawSie()
{
    cout<<this->Nazwa;
}
double Owoc::zwazOwoc()
{
    return this->waga;
}

jablko.h:

#ifndef JABLKO_H
#define JABLKO_H
#include "owoc.h"
class Jablko: public Owoc
{
public:
    Jablko(double weight);
    virtual void przedstawSie();
};

#endif // JABLKO_H

jablko.cpp:

#include "jablko.h"

Jablko::Jablko(double weight): Owoc(weight)
{
    this->Nazwa="jabluszkiem";
}

void Jablko::przedstawSie()
{
    cout<<"jestem "<<this->Nazwa;
}

gruszka.h:

#ifndef GRUSZKA_H
#define GRUSZKA_H
#include "owoc.h"
class Gruszka: public Owoc
{
public:
    Gruszka(double weight);
    void przedstawSie();
};

#endif // GRUSZKA_H

gruszka.cpp:

#include "gruszka.h"
Gruszka::Gruszka(double weight): Owoc(weight)
{
    this->Nazwa="gruszeczka";
}
void Gruszka::przedstawSie()
{
    cout<<"jestem "<<this->Nazwa;
}

antonowka.h:

#ifndef ANTONOWKA_H
#define ANTONOWKA_H
#include "jablko.h"
class Antonowka: public Jablko
{
public:
    Antonowka(double weight);
    void przedstawSie();
};

#endif // ANTONOWKA_H

antonowka.cpp:

#include "antonowka.h"

Antonowka::Antonowka(double weight):    Jablko(weight)
{
}
void Antonowka::przedstawSie()
{
    Jablko::przedstawSie();
    cout<<" ale najlepszym";
}

no i na koniec main.cpp:

#include <stdio.h>
#include "kosz.h"
#include "owoc.h"
#include "jablko.h"
#include "gruszka.h"
#include "antonowka.h"

int main(void)
{
    Kosz kosz;
    Gruszka *gruszka1=new Gruszka(0.25);
    Gruszka *gruszka2=new Gruszka(0.25);
    Jablko *jablko1=new Jablko(0.25);
    Antonowka *antonowka1=new Antonowka(0.25);
    kosz.dodajOwoc(gruszka1);
    kosz.dodajOwoc(gruszka2);
    kosz.dodajOwoc(jablko1);
    kosz.dodajOwoc(antonowka1);
    kosz.przedstawOwoce();
    kosz.podajWage();
}

Program działa mogą być jakieś zbędne includy tam ale to już sobie znajdźcie :P

według mnie tak łatwiej, tyle że print powinnienem zrobić z owoców ale juz mi się nie chce zmieniać :D

#include "antonowka.h"



antonowka::antonowka(float wagAnt)
{
    this->waga=wagAnt;
   // this->imie="jablko";
}

void antonowka::print()
{
    jablko::print();
    //cout<<"jestem " <<imie<< endl;
    cout<<" |     |"     <<endl;
    cout<<" |      -rodzaju antonowka. jestem najsmaczniejsza" <<endl;

}

#ifndef ANTONOWKA_H
#define ANTONOWKA_H

#include "jablko.h"
#include <iostream>

using namespace std;

class antonowka:public jablko
{
public:
    antonowka(float wagAnt);
    void print();
};

#endif // ANTONOWKA_H

--------------------------------------------------
#include "gruszka.h"


gruszka::gruszka(float waga)
{

    this->imie=" gruszka ";
    this->waga=waga;
}



void gruszka::print()
{
    std::cout<<"jestem [gruszka] o wadze: " << waga<<" kg." << std::endl;
}

#ifndef GRUSZKA_H
#define GRUSZKA_H

#include "owoce.h"
#include <iostream>

using namespace std;

class gruszka:public owoce
{
public:
    gruszka(float waga);

    void print();
};



#endif // GRUSZKA_H
----------------------------------------------------
#include "jablko.h"

jablko::jablko()
{


}


jablko::jablko(float wagJab)
{
     this->imie=" jablko ";
    this->waga=wagJab;
}


void jablko::print()
{
    std::cout<<"jestem [jablko] o wadze: " << waga<<" kg." << std::endl;
}
#ifndef JABLKO_H
#define JABLKO_H

#include "owoce.h"
#include <iostream>

using namespace std;


class jablko:public owoce
{
public:
    jablko(float wagJab);
    jablko();
   // virtual
    void print();
};

#endif // JABLKO_H

-------------------------------------------------
#include "owoce.h"

float owoce::jakaWaga()
{
    return this->waga;
}


#ifndef OWOCE_H
#define OWOCE_H
#include <iostream>
#include <string>

using namespace std;

class owoce
{
protected:
    string imie;
    float waga;
    //kosz* koszOwocow;

public:
    //void dodajKoszWlasciciel(kosz* k);
    virtual void print()=0;
    float jakaWaga();
};

#endif // OWOCE_H

--------------------------------------------------
#include "kosz.h"

kosz::kosz(std::string nazKosz)
{
    //ow->dodajKoszWlasciciel(this);  owoce* ow
    this->nazwa_kosz=nazKosz;
    //this->owoceVector.push_back(ow);
}

void kosz::dodajOwoce(owoce* o)
{
    //o->dodajKoszWlasciciel(this);
    this->owoceVector.push_back(o);
}

float kosz::wagaOwocow()
{
    float masa=0;
    for(int i=0;i<owoceVector.size();i++)
    {
        owoce* ow=owoceVector.at(i);
        masa=masa+ow->jakaWaga();

    }
    return masa;
}

void kosz::print()
{
        std::cout<<nazwa_kosz<<std::endl<<std::endl;
        std::cout<<         "[kosz] ma [owoce](klasa) o nazwie: "<<std::endl;
        std::cout<<         "=,"  <<std::endl;
        for(int i=0; i<owoceVector.size(); i++)
        {
            owoce* o=owoceVector.at(i);
            std::cout<<     " | "<<std::endl;
            std::cout<<     "  -";
            o->print();
            std::cout<<std::endl;
        }


}


#ifndef KOSZ_H
#define KOSZ_H

#include <string>
#include <vector>
#include "owoce.h"


class kosz
{
private:
    std::string nazwa_kosz;
    std::vector<owoce*> owoceVector;

public:
    kosz(std::string nazKosz);
//owoce* ow
    void dodajOwoce(owoce* o);
    float wagaOwocow();
   void print();
};

#endif // KOSZ_H