Objektno programiranje

Odi po ocjenu, odnesi index i u njemu plavu kuvertu pa ce ti profesor to sve objasniti :D

Napišem i ja koju riječ o klasama i instancama(objektima) i samom pojmu klase i objekta ,ali kad budem imao vremena.

KLASE,OBJEKTI,KONSTRUKTORI,DESTRUKTORI....

U c++ -u dakle postoje tipovi koji su ugrađeni u sam jezik (int,float,double)..i sad da ne

nabrajam....Zato mi možemo stvoriti svoj "Tip" da se tako izrazim , tada to postaje korisnički

tip...za to nam služe klase jer pomoću njih stavramo naše tipove .Klasa recimo list postaje

naš tip list i sad možemo stavrati objekte tog tipa...tip list kao što imamo tip float
pa si u deklaraciji imao float broj;  ..sad možeš napraviti svoj tip:
list  broj;
i tad s tom deklaracijom si napravio objekt broj tipa list;
Pomoću tog objekta is napravio instancu klase list a ta instanca je naš objekt broj.
Klasa može sadržavati varijable ,funkcije,podatke....
Pojam enkapsulacije obuhvaća zaštitu podataka od korisnika izvana...zato postoje
zaštićeni podaci unutar klase kojima samo mogu pristupiti funkcije koje pripadaju toj klasi
i funkcije pa i same klase koje smo proglasili prijateljima toj klasi,ti podaci su dakle privatni i
spadaju pod dio private:

u deklaraciji klase ....također imamo i javni dio koji
je svima pristupačan i pod rezerviranom rječju public:
također postoji i protected: dio unutar deklaracije klase koji je isto kao i private---zaštičen

izvana ali taj dio mogu koristiti rođaci te klase tj.svi koji su izvadeni iz te osnovne klase u

kojoj se nalazi protected: dio .
Zatim ,pojam polimorfizam koji je već objašnjen..i sad na temelju svih tih pojmova
temelji se i OOP programiranje...U biti nasljeđivanje,enkapsulacija i polimorfizam su osnovni

pojmovi u OOP.
Podaci koje mi sami stavramo s pomoću klasa nazivamo abstrakcija.

Privatan--dostupno samo unutar iste klase.
protected---dostupno unutar iste klase i izvedenih klasa i prijatelja klasa.
public---dostupan svima.
Sve to je princip enkapsulacije.

Prijatelji klase recimo su funkcije koje deklariramo unutar klase kao prijatelje
rezerviranom rječju friend tip ime_funkcije(argumenti);
Znači ona ima pristup svemu kao da je i sama članica klase iako je definiramo
van klase.
Sad ako napravimo klasu koja je izvedena od naše osnovne (base) klase ta "nova" klasa
ne naslijeđuje friend funkciju ,nego je opet moramo deklarirati i za tu izvedenu klasu.
Objekti ,da ponovimo, su dakle instance dotične klase i ona može imati više objekata
(instanci)
Klasa je naš korisnički tip.
Pomoću klasa i objekata mi postižemo enkapsulaciju i abstrakciju podataka koja još s
polimorfizmom stavra dojam OPP programiranja.
Princip enkapsulacije i objektnog principa  temelji  se na tome
da možemo mijenjati program gdje želimo
i kako želimo prema našim potrebama i to s minimalnim (nekad i malo većim)
zahvatima u kodu , ne smiju se dakle dirati
javni članovi  dok privatne možemo mijenjati .Možemo mijenjati definicije javnih funkcija
ali im ne smijemo mijenjati argument i povratni tip.
U klasi koja je napisana dakle možemo izmjeniti privatni dio da bi bila još bolja!(to još stavim..primjere)
Prije nego se prouče ove izmjene samo malo o konstruktorima.

Oni se uvijek pozivaju čim se u programu stvori objekt i na taj način  mi smo sigurni da
je nešto stvoreno i popunjeno s nečim a krajnji korisnik ne mora brinuti da li je objekt
koji je stvoren stavran ili ne ..o tome se brine program i konstruktor koji je u biti funkcija koja
ima isto ime kao i klasa ,nema povratni tip,može se preklopiti i naravno ima argumente.
S konstruktorima mi osiguravamo mjesto u memoriji za dotični objekt koji je tad pravilno
napravljen i popunjen(inicijaliziran).
S ovim se logično i zaključuje kad se poziva konstruktor--kad se napravi objekt dotične klase.
Posebni su konstruktori kopije koji mogu primiti kao argument tipa same klase.O tome možda
još nešto više kažem ali kasnije.
Kada pravimo konstruktor bez argumenata to se zove defaultni konstruktor.Ako nismo mi sami
niti jedan konstruktor napravili tad sam prevodilac to za nas napravi.
Destruktor je dakle suprotno od konstruktora,on uništava konstruktor(objekt) na kraju života
objekta koji smo stvorili i tako nam čisti memoriju za koju smo odgovorni.
Destruktori imaju znak ~(tilda) u C++-u ispred imena klase(kao i konstruktori)...oni se ne
mogu
preklapati niti imaju argumente!!Nemaju ni povratni tip.
Kako se pozivaju konstruktori ,destruktori se pozivaju obrnuto od pozivanja konstruktora.
Što se tiče destruktora u virtualnom smislu i kojim redom oni uništavaju objekte
pročitaj što je kolega o tome napisao i zašto je to važno!!!
Kad se recimo poziva konstruktor izvedene klase prvo se poziva konstruktor osnovne klase
koji tada inicijalizira podobjekt osnovne klase unutar objekta izvedene klase.
Kroz sve ovo se provlači i pojam izvedena ili naslijeđana klasa i slično.
Radi se o klasi koja naslijeđuje sve od svoje izvorne(bazne) klase i to public dio
a uz to još može imati i svoje vlastite podatke i funkcije zajedno s naslijeđenim funkcijama
iz svoje bazne klase.
O naslijeđivanju ću još malo ali sad prouči ovaj teoretski dio pa reci što ti nije jasno
a i kod koji slijedi (stavim ga ovih dana)...tj primjeri iz koji možeš vidjeti o čemu sam pisao
možda ti bude jasnije.
Pojam učahuravanje je u biti povezan s pojmom enkapsulacije koju sam već prije naveo
a može se povezati još i s pojmom ugniježđenih klasa,možda i o tome nešto napišem.

Slijede primjeri koji su rađeni u VisualStudiu a možeš i u Express izdanju.

Nisam išao u detalje nego samo temeljne postavke naslijeđivanja i kapsuliranja.

Primjena znači private,pzblic i protected rezerviranih riječi...odvajanje definicije i deklaracije

čak sam se dotaknuo i polimorfizma tako da možeš lijepo sagledati OOP u C++-u
ali jako skraćeno i uopćeno .Sad možeš dalje googlati i sam potražiti slične ili još
bolje primjere.
Ovdje u samom naslijeđivanju pripazi na koji način se naslijeđuje.vidiš da
funkciju ispis_0() koriste obe klase ,a pogotovo klasa student a ima još i svoju funkciju
koja je dodana i na taj način dodana je još jedna funkcionalnost nove klase,jer
osim što ima ono što i stara ima nešto i svoje!!

#include<iostream>
#include<string>  //ako budes htio string
using namespace std;
//:::::::::::::::::::::::::::
//::::::::DEKLARACIJE:::::::
//:::::::::::::::::::::::::::
class CProf
{
private:
    char* m_Ime;
    int m_God;
public:
    void m_Ispis_0();
    CProf(int,char*);
    ~CProf();
};

//:::::::::::::::::::::::::::::::
//:::::::DEFINICIJE::::::::::::::
//:::::::::::::::::::::::::::::::
void CProf::m_Ispis_0()
{
    cout<<"Ja sam : " <<m_Ime<<" i imam : "<<m_God<<endl;
}
CProf::CProf(int g,char* i):m_God(g),m_Ime(i)
{
    cout<<"....konstruktor..."<<endl;
}
CProf::~CProf(){
    cout<<"...........Destruktor.........."<<endl;
}

//:::::::::::::::::::::::::::::::::::::::
//::::::::::::DRUGA KLASA::::::::::::::::
//:::::::::::::::::::::::::::::::::::::::


class CStudent:public CProf  //naslijedjuje javni dio klase
{
private:
    char* m_ImeStudenta;  //treba nam samo ime studenta jer ostalo imamo
public:
    void m_Predavac();
    CStudent(int,char*,char*);
    ~CStudent();
};
CStudent::CStudent(int god,char* ime_1,char* ime_2):CProf(god,ime_1)
{
    m_ImeStudenta= ime_2;
    cout<<"Konstruktor izvedeni....!!!"<<endl;
    
}

CStudent::~CStudent()
{
    cout<<"Destruktor izvedene klase...."<<endl;
}

void CStudent::m_Predavac()
{
    cout<<"Predajem studentu : "<<m_ImeStudenta<<endl;
}


//::::::::::::::::::::::::::::::::
//:::::::::GLAVNI PROGRAM:::::::::
//::::::::::::::::::::::::::::::::
int main()
{

    CProf prof(45,"Hrvoje");
    CStudent stud(21,"Koki","Branimir");
    prof.m_Ispis_0();
    stud.m_Ispis_0();
    stud.m_Predavac();

    
    return 0;
}

I sad sve je isto(skoro) ali funkcija Ispis_0() je promijenjena u virtual void tako da se može koristiti

njena nova verzija a poziva se preko argumenta bazne klase.Pročitaj gore polimorfizam!

#include<iostream>
#include<string>  //ako budes htio string
using namespace std;
//:::::::::::::::::::::::::::
//::::::::DEKLARACIJE:::::::
//:::::::::::::::::::::::::::
class CProf
{
protected:
    char* m_Ime;
    int m_God;
public:
    virtual void m_Ispis_0();
    CProf(int,char*);
    ~CProf();
};

//:::::::::::::::::::::::::::::::
//:::::::DEFINICIJE::::::::::::::
//:::::::::::::::::::::::::::::::
void CProf::m_Ispis_0()
{
    cout<<"Ja sam : " <<m_Ime<<" i imam : "<<m_God<<endl;
}
CProf::CProf(int g,char* i):m_God(g),m_Ime(i)
{
    cout<<"....konstruktor..."<<endl;
}
CProf::~CProf(){
    cout<<"...........Destruktor.........."<<endl;
}

//:::::::::::::::::::::::::::::::::::::::
//::::::::::::DRUGA KLASA::::::::::::::::
//:::::::::::::::::::::::::::::::::::::::


class CStudent:public CProf  //naslijedjuje javni dio klase
{
private:
    char* m_ImeStudenta;  //treba nam samo ime studenta jer ostalo imamo
public:
    void m_Predavac();
    CStudent(int,char*,char*);
    ~CStudent();
};
CStudent::CStudent(int god,char* ime_1,char* ime_2):CProf(god,ime_1)
{
    m_ImeStudenta= ime_2;
    cout<<"Konstruktor izvedeni....!!!"<<endl;
    
}

CStudent::~CStudent()
{
    cout<<"Destruktor izvedene klase...."<<endl;
}

void CStudent::m_Predavac()
{
    cout<<"Predajem studentu : "<<m_ImeStudenta<<endl;
}

//:::::::::::::::::::::::::::::::::::::::::::
//::::::::::::TRECA KLASA::::::::::::::::::::
//:::::::::::::::::::::::::::::::::::::::::::
class CRadnik:public CProf
{
private:
    char* ImeRadnika;
public:
    void Ispis_0();  //ovo je isto funkcija ispis ali samo druga verzija
    CRadnik(int ,char*,char*);
    ~CRadnik();
};
CRadnik::CRadnik(int G, char* I,char* I_2):CProf(G,I)
{
    ImeRadnika = I_2;
    cout<<"Konstruktor...Radnika.."<<endl;
}
CRadnik::~CRadnik()
{
    cout<<"Destruktor radnika...."<<endl;
}
//ovdje sad nova verzija funkcije za ispis
void CRadnik::Ispis_0()
{
    cout<<"Ja sam radnik "<<ImeRadnika<<" ."<<endl;
}


//:::::::::::::::::::::::::::::::::::::::::::
//::::::::::::CETVRTA KLASA::::::::::::::::::
//:::::::::::::::::::::::::::::::::::::::::::
class test
{
public:
    void testiraj(CProf); //ovoj funkciji predajemo argument tipa CProf(a to je naravno instanca)
};
void test::testiraj(CProf Test)
{
    Test.m_Ispis_0();
}
//ova klasa je samo za testiranje svega sto smo napisali....




//::::::::::::::::::::::::::::::::
//:::::::::GLAVNI PROGRAM:::::::::
//::::::::::::::::::::::::::::::::
int main()
{

    CProf prof(45,"Hrvoje");
    CRadnik radnik(56,"Franjo","Petar");
    CStudent stud(21,"Koki","Branimir");
    test t;
    t.testiraj(prof);//evo ovdje proslijedjujemo argument tipa CProf
    t.testiraj(radnik);//i ovdje ali naravno bitna je instanca
    t.testiraj(stud);//kao i ovdje   iako poziv ide preko osnovne klase
    //prof.m_Ispis_0();
    //stud.m_Ispis_0();
    //stud.m_Predavac();

    
    return 0;
}

/*Pozivanje virtualne funkcje je tkz. late binding iliti kasno vezanje u toku izvršavanja koda
znaci da sam poziv funkcije unutar same definicije i prevođenja još ne zna koju funkciju treba pozvati
ali kad dolazi do izvrsavanja koda tad se povezuje s pravom funkcijom*/

Zapazi kako se malo koda dodaje kad se radi o naslijeđivanju ili virtualnim mehanizmima
a to je i svrha OOP-a --neovisnost a opet povezanost.Ne morate mijenjati osnovnu klasu a možete
dodavati nove klase ,nove funkcije........znači u globalu stari softwer ne morate bacati nego
samo dodati novu funkcionalnost što opet znači ne morate ništa ispočetka raditi ako imate
osnovu.Dakle ,onaj koji napravi neki kostur funkcionalnosti i to vam proslijedi

vi dalje možete razvijati svoj vlastiti softwer(kod) koristeći stari ili onaj koji je osnova,
samo dodajete.To je prednost OOP-a,jedna od.....

Ovo probaj sve korak po korak shvatiti.Jezik je naravno C++ ali ako si nađeš
jednostavnije u C# samo naprijed,mislim ako misliš da će tako bolje ići.

Ispričavam se na možda sitnim greškama ali pokušao sam ne ići u širinu jer su ti teme za
seminarski rad stvarno ogromno područje!!!Eto ako se nekome da neka i objasni sve još bolje
ili ispravi sve ono što ja nisam.

Pa dobija si valjda skriptu :(

Samo me eto radi znatiželje zanima koji je to faks?