C++ tutorijali...

Naxeem, stavljaj Sicky i izbriši nepotrebne komentare.

Solidno opisano , samo zašto sam ja prije kada sam se više bavio računalima cijenio "kućne hackere" od školovanih ljudi na faksovima i raznim tečajevima koji se bave programiranjem...

Zato što su znali daleko jednostavnije objasniti neke stvari bez upotrebe stručnih riječi...

Pa ako već običnim neznalcima pokušavate pomoći što manje stručnih riječi koristite, što jednostavnije pišite i ljudi će puno lakše naučiti programirati i zavoliti ga...

KLASE........OSNOVNO O OOP.



Evo ,započinjem s klasama , osvrt na njih neće biti takav da se svi izgubimo,nego samo ono osnovno.
Takvi će biti i programi,ako tko poželi nešto i dodati,naravno da može!

Klasa je osnova objektnog orijentiranog programiranja(oop).Mi imamo standardne tipove u c++-u kao što
su int,char,float,......ali također imamo i izvedene tipove(koji sami možemo definirati) a tu spada
klasa kao definicija tipa class koja je i ujedno jedna od ključnih riječi c++-a.
Klasa je skup objekata istih svojstava.Klasa je dakle izvedeni tip ,a objekt je primjerak,izvedenica,instanca
klase.Klasa je znači apstrakcija s pomoću koje programer može izvesti svoj vlastiti tip koji se naziva korisničkim tipom!
Za razliku od prije već spomenutih ugrađenih tipova c++-a.
Klasu opisujemo njezinim atributima(sadržajem), i operacijama(ponašanjem) koje se vrše nad objektima te klase.
Podaci unutar definicije klase su atributi a operacije nad objektima su obično funkcije.
Zašto nam klase služe?
Jednostavnije je program koji je ogroman i broji nekoliko tisuća redaka koda podijeliti i na taj način svaki dio za sebe
možemo provjeravati a kad nam zatreba spojimo sve u jednu cjelinu.Ti dijelovi mogu biti klase i na taj način na
jednom projektu može raditi i više programera ,svaki za sebe može pisati i na kraju sve to spojiti.Tako je puno lakše i brže
napisati recimo jednu igru.Svatko radi svoj dio (klasu i objekte) za određenu fazu igre i za to je odgovoran
i kasnije se sve samo spoji.Jako sam to pojednostavio ali kostur je takav.
Manji dio programa koji se koristi na jako puno mjesta možemo staviti u klasu i nataj način je pozivati
kad god hoćemo u programu,prednosti su ogromne.
Naravno pri malim programima od par redaka koda je besmisleno raditi klase ali mi ćemo upravo to raditi
jer iih je tako najbolje razumjeti.
Način na koji ću ja raditi je od jednostavnih primjera(od nekoliko redaka) ka sve kompliciranijim ali ne
isuviše kompliiranim primjerima.Kroz te primjere ćemo se upoznavati s definicijom i deklaracijom klase
,i pojmovima koje sad neću spominjati nego kad e u programu napišu tad ću ih i objasniti.
Zasad toliko dok se ne prihvatim programa.

Evo prvi program koji nam pokazuje kako možemo napraviti jednu jednostavnu klasu :


#include<iostream >
using namespace std ;

 class recenica
   {//ovdje započinjemo klasu
     public:
       void rijec()
         {
           cout << "Ovo je nasa klasa recenica"<< endl;
         }
  };//uvijek ovako zavrsavamo klasu
//*********************************

int main()
{
recenica objekt;//formiramo objekt
objekt.rijec();//pozivamo funkciju tipa void rijec()
cout<<endl;
system ("PAUSE");
return 0;
}

Taj isti program možemo napisati i bez uporabe klase,samo s naredbom cout<<  napravimo ispis,ali
ovako vam jednostavno mogu pokazati kako se klase stavraju.
Definicija a i deklaracija cijele naše klase je narno izvan main funkcije jer je u main funkciji pozivamo.
Započinje naravno s ključnom riječju class i zatim dajemo ime našoj klasi(neko lagano i logično) kao što ih
dajete i varijablama ...zatim otvaramo naš blok u kojem ćemo imati public dio u ovom slučaju,o drugim dijelovima
ćemo kasnije.
U public :
dijelu koji se tako piše----public :    -----dvotočka obična.
Tamo se nalazi samo jedna funkcija tipa void koja ispisuje tekst.
Nalazi se u svom bloku jer se odmah po pozivu i izvršava ,nema return tip jer je void().
Na kraju klasu završavamo s vitičastom zagradom i obvezno s točka zarez!!!!!

Sad otvaramo main () dio glavnio program i da bismo došli do
naše funkcije moramo stvoriti neki put do nje(instancu)...taj put mora biti istog tipa
i zato je naša klasa ujedno i tip ,tako stvaramo objekt pa naše klase,usporedite to  isto kao
kad deklarirate običan tip i običnu varijablu,imena se biraju na isti način,samo ovdje se radi o korisničkom tipu
koji smo mi stvorilli a to je ime naše klase  recenica.
Znači sad kad je stvoren objekt,pomoću njega možemo doći do funkcije  void rijec().
Pristup funkciji ili metodi u našem slučaju jer se funkcije koje se pri pozivu same izvršavaju su metode,
pristup je preko objekta objekt pa točka i zatim naziv funkcije : objekt.rijec();
....naravno obvezno se završava s točkom zarez!
Točka je obvezna!Razdvaja objekt od funkcije koja se vrši nad objektom.
Ovaj oblik deklaracije recenica objekt;
je usporediv s recimo int objekt;  ili char objekt;    ali ovdje se radi znači o ugrađenim tipovima
a mi smo sami (korisnički) stvorili svoj tip.
I sad tim objektom (instancom) pristupamo funkciji.
Na isti način kako možemo formirati više varijabli istog tipa tako možemo i formirati
više objekata našeg korisničkog tipa od naše klase i pozivati funkciju s svakim objektom.
Više različitih objekata(imena)ali isti tip(naša klasa) :

#include<iostream >
using namespace std ;
class recenica
  {
    public:
     void rijec()
        {
         cout << "Ovo je nasa klasa recenica"
         " ali u funkciji void"<< endl;
        }
//mozete i ovako pisati tekst!!!
  };
int main()
{
recenica objektprvi;
recenica objektdrugi;
recenica objekttreci;

objektprvi.rijec();
objektdrugi.rijec();
objekttreci.rijec();
cout<< endl;
system ("PAUSE");
return 0;
}

Također mi možemo mijenjati i ime naše klase kako hoćemo ali logika pri tome mora biti stvar izbora
iako možemo bilo što staviti :

#include<iostream >
using namespace std ;
class bezveze
  {
    public:
     void rijec()
        {
         cout << "Ovo je nasa klasa recenica"
         " ali u funkciji void"<< endl;
        }
//mozete i ovako pisati tekst!!!
  };
int main()
{
bezveze objektprvi;
bezveze objektdrugi;
bezveze objekttreci;

objektprvi.rijec();
objektdrugi.rijec();
objekttreci.rijec();
cout<< endl;
system ("PAUSE");
return 0;
}

Naravno mi možemo samo s jednim objektom tipa naše klase pozivati više funkcija
unutar naše jedne klase...ovaj program to pokazuje.
Primjetite da su i funkcije drugog imena ali objekt je jedan i pomoću njega pozivamo svaku funkciju,vidite da točka
koja razdvaja objekt od funkcije ima svrhu pozivanja funkcije koja će se vršiti nad objektom tipa naše klase,ta točka
je način pristupa članovima klase,u našem slučaju klasa ima zasad samo public ili javni dio,dio koji je svima vidljiv,da se tako izrazim.
O tome će još biti riječi.

#include<iostream >
using namespace std ;
 class rijec                 //formiramo klasu rijec
   {
     public:                 //koja ima public naredbu(dio)
       void prva()          //funkcija tipa void sa naredbom cout
        {
          cout << "Ovo je prva funkcija"<< endl;
        }
        void druga()         //druga funkcija unutar iste klase
        {
          cout << "Ovo je druga funkcija"<< endl;
        }
       void treca()          //treca funkcija
         {
          cout << "Ovo je treca funkcija"<< endl;
         }
   };                          //zavrsetak nase klase
int main()
{
rijec objekt_a;               //formiramo objekt samo jednom
objekt_a.prva();              //koristimo ga za poziv nasih funkcija
objekt_a.druga();
objekt_a.treca();
cout<< endl;
system ("PAUSE");
return 0;
}

Također s jednom formiranim objektom možemo pozivati i više puta jednu funkciju unutar klase:

#include<iostream >
using namespace std ;
class recenica_prva
{
  public:
    void evo()
       {
         cout << "Evo ga!"<< endl;
       }
};
int main()
{
cout<<"Objekt koristimo prvi put!"<<endl;
recenica_prva ob; // samo jednom formiramo objekt!!!
cout<<endl;
ob.evo() ;// koristimo ga prvi put
cout<<endl;
cout<<"Objekt koristimo drugi put!"<<endl;
ob.evo(); //koristimo ga drugi put
cout<<endl;
cout<< endl;
system ("PAUSE");
return 0;
}

Malo vježbajte ,mijenjajte program u smislu da sami mijenjate imena i koliko puta je pozivate,igrajte se s pisanjem
jer tako vam ulazi u naviku pisanje i oblik kako se pišu klase ili bilo što u kodu.

U programu je moguće imati i više klasa ,naravnoi više objekata koji su instance tih naših klasa.
Program to prikazuje a i ono što je u komentarima ,tako javlja grešku,objašnjeno u komentaru :

#include <iostream>
using namespace std;
class prva
{
      public:
             void funk_1()
             {
                  cout<<"Ovo je nasa prva klasa!"<<endl;
             }
};
class druga
{
      public:
             void funk_2()
             {
                  cout<<"Ovo je nasa druga klasa."<<endl;
             }
 };               
int main()
{
    prva objekt_1;
    objekt_1.funk_1();
    cout<<endl;
    druga objekt_2;
    objekt_2.funk_2();
    cout<<endl;
   //objekt_1.funk_2();
   //ovakav poziv ne možete napraviti jer
   //28 C:\Radni\klase_bug\klasebug.cpp 'class prva' has no member named 'funk_2'
   //sto znaci da klasa prva nema članicu funk_2
   //sad vidite da sve mora biti istog tipa ili imati istu pripadnost
    system("PAUSE");
    return 0;
}

Također mi možemo imati isto ime za funkciju a dvije klase i preklapanje imena funkcije :

#include <iostream>
using namespace std;
class prva
{
      public:
             void funk_1()
             {
                  cout<<"Ovo je nasa prva klasa!"<<endl;
             }
};
class druga
{
      public:
             void funk_1()
             {
                  cout<<"Ovo je nasa druga klasa."<<endl;
             }
 };               
int main()
{
    prva objekt_1;
    objekt_1.funk_1();
    cout<<endl;
    druga objekt_2;
    objekt_2.funk_1();   //ovdje vidite isto me ali različit objekt
    cout<<endl;
   
    system("PAUSE");
    return 0;
}

.....ali je zovemo s drugim objektom koji pripada pravoj klassi za tu funkciju.
Vidite kako se igramo s jednostavnim primjerima klasa ali sad ćemo malo po malo
komplicirati i uvoditi i druge pojmove koji su specifični za OOP.

Sad ćemo napisati dva programa u kojima imamo članove klase u private i public dijelu jedne klase.
U private dijelu se nalazi varijabla a u public dijelu su dvije funkcije,u prvom programu je jedana funkcija
void tip a druga int tipa,a u drugom dijelu su obe void tipa.Član u private dijelu je dohvatljiv samo članovima iste klase
ali ne izvan te klase,naravno sve to objasnim još podrobnije ali sad evo programa i proučavajte
ih dok ih ne objasnim ,a i međusobnu komunikaciju private i public dijela kao i komunikaciju kls glavnim programom.

#include<iostream >
using namespace std ;
class g_oblik
{
      private:
              int x;
                  public:
                         void ime()
                         {
                              cout<<"Povrsina : "<<endl;
                         }
                         int povrsina(int a,int b)
                         {
                             x = a*b;
                             return(x);
                         }   

};
int main()
{
    g_oblik pr;
    pr.ime();
    //pr.povrsina(4,7);  //ovako ne može jer nije void()
    cout<<pr.povrsina(4,7);//ovako može jer sad imamo ispis jer se radi o return tipu
    cout<<endl;
system ("PAUSE");
return 0;
}

Sad isti taj program ali void tip obe funkcije,proučite sad malo i to ,a private dio posebno objasnim.

#include<iostream >
using namespace std ;
class g_oblik
{
      private:
              int x;
                  public:
                         void ime()
                         {
                              cout<<"Povrsina : "<<endl;
                         }
                         void povrsina(int a,int b)
                         {
                             x = a*b;
                            cout<<x;
                            cout<<endl;
                         }   

};
int main()
{
    g_oblik pr;
    pr.ime();
    pr.povrsina(4,7);  //ovako  može jer je void()
    //cout<<pr.povrsina(4,7);//ovako ne može   jer se radi o return tipu
    cout<<endl;
system ("PAUSE");
return 0;
}

Malo proučavajte.
Sad prije još programa i objašnjenja istih malo i teorije.
Privatan(private:) - znači da te članove klase unutar private dijela može koristiti samo članovi iste klase,nitko izvana!
Public(public:) - Znači može je koristiti i imati pristup tim članovima klase i druge klase ,ona je vidljivi dio klase.
protected:    taj dio posebno objasnim jer se protected unutar klase koristi kad se radi o naslijeđivanju između klasa ako želimo da private dio jedene
klase bude i dio druge klase tad stavljamo te podatke ili objekte u protected dio,public dio jedne klase naslijeđuju sve klase koje žele taj dio naslijediti
a private ostaje samo klasi u kojoj je primarno i definiran.

Zasad toliko ali kroz programe se najlakše može o tome naučiti ,tako ćemo i napraviti.
To sve spada u kontrolu prava pristupa unutar samih klasa,jer programer može odlučiti dio sakriti za javnost a dio pokazati.

Sve ovo će biti jasnije kroz programiranje ,tako da ću kroz programe bolje to objasniti.

Dosad smo samo u glavnom programu pozivali neku članicu ili funkciju a kad bismo htjeli iz main
programa pristupiti zaštićenom privte dijelu i rezultatu direktno preko objekta te iste klase vidjet ćete da je to
nemoguće.Naprimjer : pr.x;      i vidjet ćete da je to nemoguće,prevodilac javlja grešku.Zato mi moramo ostvariti
pravilo, da članovi unutar iste klase mogu koristiti ono što je u private dijelu a varijable i objekti izvan te klase to ne mogu.
Zato je to private(zaštićen) dio.
Naravno sve su to svojstva OOP u c++-u ali tek kad to svladamo nešto ću reći i o tim svojstvima koja
imaju i svoje ime(enkapsulacija,polimorfizam,naslijeđivanje) ali o tome malo kasnije.
Da bismo pristupili varijabli x u private dijelu moramo napraviti tj.deklarirati varjablu u public dijeli iste klase
i sad pomoću nje pristupiti x varijabli i tad možemo preko objekta iz vanjskog dijela(main) funkcije posredstvom
varijable pristup doći do x varijable i rezultata koji je u nju sprmljen!!!!
Sve ovo što sam napričao vam se nalazi u programu :
#include<iostream >
using namespace std ;
class g_oblik
{
      private:
              int x;
                  public:
                         int pristup;//ovdje deklariramo varijablu za komunikaciju s private dijelom
                         void ime()
                         {
                              cout<<"Povrsina : "<<endl;
                         }
                         int povrsina(int a,int b)
                         {
                             x = a*b;
                             pristup = x;
                            return (x);
                            cout<<endl;
                         }   

};
int main()
{
    g_oblik pr;
    pr.ime();
    cout<<pr.povrsina(4,7);
    cout<<endl; 
    cout<<pr.pristup;                //pomocu varijable pristup smo mogli
                                    // unutar klase prici privatnom dijelu same klase
                  //cout<<pr.x;//ovakav direktan pristup ne ide jer iz glavnog programa
                               //ne možemo pristupiti privatnom (nevidljivom dijelu) i zato
                               //to radimo iz public dijela preko varijable pristup....tako možemo
    cout<<endl;
system ("PAUSE");
return 0;
}

Evo proučite program i pogledajte kako smo riješili komunikaciju s private dijelom ali samo unutar klase.

Naravno ,kad pozivamo void funkciju mi samo navedemo njeno ime i ona se izvršava jer nije return tipa i ništa ne vraća
 a int tip je funkcija koja nešto vraća,e sad da bi vam to pokazao naravno proučičete program i  kako
to return tip funkcije nešto vraća.

#include<iostream>
using namespace std ;
class vjezba
{
   private:
     int c;
      public:
       int funkcija1(int a,int b)
          {
            c = a* b;
            return(c);
          }
       int funkcija2(int a,int b)
          {
            c = a* b;
            return(a);
          }
       int funkcija3(int a,int b)
          {
            c = a* b;
            return(b);
          }
};
int main()
{
vjezba r;
cout<< "return c daje :"<< r.funkcija1(3,4)<<endl;
cout<< "return a daje :"<< r.funkcija2(3,4)<<endl;
cout<< "return b daje :"<< r.funkcija3(3,4)<<endl;
cout<< endl;
system ("PAUSE");
return 0;
}

Sad ga malo proučavajte i nije teško vidjeti da ono što napišemo s return naredbom to nam se i vrati.
Za razumijevanje klasa je bitno poznavanje funkcija i njihovih deklaracija i definicija a također prije u tutorijalu(tamo gdje su funkcije) sam objasnio što je to preopterećenje operatora i prijenos argumenata i parametara u
funkcijama a i kolega je sad sve to malo i ponovio.Stoga  ja sad funkcije ne objašnjavam u klasama,samo ih upotrbaljavam kao dio klasa koje mi sami stvaramo.
Naravno koristimo funkcije povratnog tipa i tipa void() koji ništa ne vraća. U ovom gornjem primjeru zorno se prikazuje
što radi funkcija return tipa i na koji način mi stavljamo i poštivamo parametre stavljajući brojeve u zagrade zA RAZLIKU od void funkcije koju samo pozivamo
i ona se sama izvršava pa je to jedan oblik metode!

U ovom slijedećem programu prikazano je pozivanje void funkcije ,na koji načn smo je pozvali,u oba programa mi moramo definirati objekt tipa naše klase(u main dijelu) da bismo pristupili tim funkcijama i tad funkcije vrše radnju nad objektom a razdvaja ih točka koja je način na koji pristupamo članicama klase!!!

#include<iostream >
using namespace std ;
class vjezba
{
  private:
    int c;
    int a;
    int b;
        public:
        void unos()  //vidite da sve radnje od početka do kraja izvršavamo unutar void funkcije
            {
              cout<<"Unesite vrijednost a :"<<endl;
              cin>>a;
              cout<<"Unesite vrijednost b :"<<endl;
              cin>>b;
            }
        void funkcija()
            {
              c=a * b;
               cout<<"Povrsina je :"<< c<< endl;
            }
};
int main()
{
vjezba pr;    //obvezatno stavramo objekt
pr.unos();     //poziv void() funkcije uvijek u ovom obliku
pr.funkcija();  //sad ih samo po redu pozivamo i igramo se s njima!!!
cout<< endl;
system ("PAUSE");
return 0;
}

Znači sad nije moguće pr.unos(2,4);    ..........   jer je funkcija void tipa!!!!!!!!!!
...nego prazne zagrade jer ništa ne vraća!!!
Naravno nije moguće ni cout<<pr.funkcija(); ................... jer se ispis vrši već unutar funkcije koju smo stvorili ,vidite razliku između
void i int tipa.....ta dva programa koja su iznad vam pokazuju razliku void() funkcije i int tipa funkcije unutar klasa!!!


U ovom slijedećem programu smo napravili kombinaciju void i int funkcije,komunikaciju public i private dijela i u glavnom
programu to sve koristimo za još jedan izračun :

#include<iostream>
using namespace std;
class vjezba
{
  private://  ovdje imamo samo varijable iako u private dijelu mogu biti i funkcije!!!!
  int c;
   int a;
 int b;
     public:        //public dio korist private varijable i to je samo njemu dozvoljeno
      void unos()   //u public dijelu imamo dvie funkcije(void i int tipa)
        {
          cout<<"Unesite vrijednost a :"<<endl;
          cin>>a;
          cout<<"Unesite vrijednost b :"<<endl;
          cin>>b;
         }
      int funkcija()
         {
           c=a * b;
           return(c);
         }
};
int main()
{
int c;     //zbog toga što je c u private dijelu mi u glavnom programu možemo to napraviti!!!!
int g;
vjezba objt;
objt.unos();
cout<<"Unesite varijablu c :"<<endl;
cin>>c;
g=c * objt.funkcija();   //taj c koristimo za još jedan izračun.
cout<<"Ukupni rezultat je :"<<endl;
cout<<g<<endl;
cout<< endl;
system ("PAUSE");
return 0;
}

Malo ga proučite prije nago još par rečenica njemu posvetim,ali kad razmislim napisao sam objašnjenja u komentarima iznad.
Vježbanjem i pisanjem ovih kodova ćete naučiti,to nitko umjesto vas ne može!!!


Evo primjer s dvije void() funkcije u kojima se sve odigrava ,a mi ih u glavnom programu samo pozivamo
s objektima tipa naše klase!!!!

#include<iostream >
using namespace std ;
class vjezba
{
   private:
    int c;
    int a;
    int b;
    int g;
    int h;
         public:
         void unos()
         {
           cout<<"Unesite vrijednost a :"<<endl;
           cin>>a;
            cout<<"Unesite vrijednost b :"<<endl;
           cin>>b;
           cout<<"Unesite vrijednost c :"<<endl;
           cin>>c;
         }
         void funkcija()
         {
           g=a * b;
           cout<<"Rezultat umnoska a*b je :"<<g<<endl;
           h= g*c;
           cout<<"Sad umnozak g i c je :"<< h << endl;
         }
};
int main()
{
vjezba pr;
pr.unos();
pr.funkcija();
cout<< endl;
system ("PAUSE");
return 0;
}

Ovdje kad sve napravimo unutar naše klase ,u glavnom programu ih samo po redu pozivamo!!!

Sve funkcije koje su bile int tipa također mogu biti i float ili double tipa(povratne vrijednosti) tako da ih sami sastavite ako ćete
raditi s decimalama!

#include<iostream >
using namespace std ;
class g_oblik
{
  private:
    float c;
      public:
        void ime()
            {
                cout << "Povrsina "<< endl;
                cout<<endl;
            }
           float povrsina(float a,float b)
              {
                c = a* b;
                return(c);
              }
};
int main()
{               
float a1;
float b1;
g_oblik pr;
pr.ime();     //nas naslov  
cout<<"Unesite a1 :"<<endl;
cin>>a1;
cout<<"Unesite b1 :"<< endl;
cin>> b1;
cout<<"Rezultat je : "<<endl;
cout<<pr.povrsina(a1,b1);     //return je tipa pa možemo unositi!!!!

cout<<endl;
cout<< endl;
system ("PAUSE");
return 0;
}

Evo kombinacija void() i float tipa!!!!!
Vjerujte nije teško ako više puta ispišete programe koji su ovdje napisani da uđete bar u "štos" i razumijevanje klasa i funkcija
i njihovih kombinacija.


Dobro proučite sve dosad što smo prikazali jer sad idemo malo kompliciranije ali to ne danas.

DEKLARACIJA I DEFINICIJA


Ali ipak malo ponovite funkcije i njihovo razdvajanje deklaracije i definicije jer  je to sličo i s klasama
kao što čete vidjeti iz ovog primjera pa ga proučavajte dok se ne vratim.

#include<iostream >
using namespace std ;
//************************************
//DEKLARACIJA(OBJAVA SVEGA STO CEMO UPOTRIJEBITI)
class racun
{
   private:
    int c;
      public:
       int funkcija(int a,int b);
};
//*************************************
//**************************************
//DEFINICIJA FUNKCIJE KOJU SMO DEKLARIRALI!!!
int racun::funkcija(int a,int b)
{
c= a*b;
return(c);
};
//*************************************
int main()
{
cout<<"Naslov"<< endl;
racun pr;
cout<<"Rezultat je : "<<endl;
cout<<pr.funkcija(4,5)<< endl;
cout<< endl;
system ("PAUSE");
return 0;
}

Mi smo dosad u svim programima unutar klasa koje smo stvarali deklarirali i

definirali varijable i funkcije.
Mi to možemo i odvojiti,na način da se deklaracija nalazi na jednom mjestu a

definicija na drugom mjestu.
Sve smo znači radili u okviru ovog bloka :
class ime_klase
     {
           // ovdje javni i privatni dijelovi
           //kao i njihove varijable ali i definicije i deklaracije funkcije
    };    //ovdje sve završimo..

Ali,mi to možemo i razdvojiti :

class ime_klase
    {
       private:
        int varijable;
       public:
        int varijable;
        int funkcija(parametri);   //ovdje je samo deklaracija funkcije(objava)
    };  //završetak naše deklaracije varijabla i funkcija unutar klase

Sad tek dolazi definicija :
 

  int ime_klase::ime_funkcije(parametri)
        {
               //sad ovdje naš kompletan sadržaj što funkcija radi!
         }; // završetak definicije

Sad tek dolazi glavni program.

int main()

{

}

......naravno mi smo sad razdvojili definiciju i deklaraciju koja vama u ovako malom

programu besmisleno izgleda što je i istina .To razdvajanje nam služi u velikim
programima kad imamo mnoštvo deklaracija a prilično velike definicije ,tad se to

još dijeli i u posebene datoteke.....definicije u jedne a deklaracije u druge i sve to
povežemo i uklučimo u glavni program.Sve to će vam biti jasnije kad se napišem

jedan takav program što ču i učiniti na kraju izlaganja o klasama i na taj način čete
bar približno vidjeti kako se to radi.

Duple dvotočke su obvezne pri razdvajanju imena klase i imena funkcije!
s lijeve strane je ime klase a s desne strane ime i parametri funkcije.
Naravno na početku pišemo o kojem tipu funkcije se radi ,int ili float ili void!
Deklaracija uvijek završava s točkom zarez,a definicija naravno ima svoj blok
u kojem je sadržaj funkcije!!!!
 Sad ste znači i to naučili...kako razdvojiti definiciju i deklaraciju.
Slijedeće o čemu čemo pričati a možda i naučiti su konstruktori.

KONSTRUKTORI (u klasama)

Konstruktor je funkcija ili metoda koja se izvršava čim formiramo objekt.
Konstruktor ima isto ime kao i klasa.
Konstruktor može imati i parametre što ga stavlja u rang s funkcijama.
Konstruktor nema tip.
Ne može biti ni void tip čak.
Konstruktor može biti u  private i public dio.
Može ih biti i više unutar jedne klase.
Konstruktor podliježe pravilima preklapanja imena kao i kod funkcija.
Konstruktor nema tip ali njegovi parametri mogu imati tip int ili float ili sam konstruktor
može imati kao ulaz void tip  npr ime_konstruktora(void).
Što je isto kao i funkcija tipa void ali ovo je konstruktor a ne funkcija.
_____________________________________________________________________________________
Da bi samo dio pravila o konstruktorima koje smo dosad napisali usvojili ,slijedi program i programi koji sve to
lijepo nama pokazuju ,naravno sve su to mali programi da bi što bolje shvatili konstruktor :

#include<iostream >
using namespace std ;
class izracun
{
    private:
      int a;
       int b;
          public:
           izracun()             //OVDJE FORMIRAMO KONSTRUKTOR
             {
               cout << "Stranica a :"<< endl;
               cin>> a;
               cout << "Stranica b :"<< endl;
               cin>> b;
             }
          int povrsina()
             {
               return(a*b);
             }
};
int main()
{
izracun t;     //čim smo naveli ime klase i ime objekta pozvali smo konstruktor i on se izvršio automatski
cout<< "Povrsina je : " << t.povrsina() << endl;    //ovdje pozivamo našu funkciju tipa int
cout<<endl;
system ("PAUSE");
return 0;
}

Sad malo proučite program prije nego dio po dio objasnim.Konstruktori su idealni pri pozivanju nekih oblika ili
kretanja kad se rade igre jer se izvršavaju odmah samo pri stavranju objekta.Recimo napravite funkciju koja
nam simulira pucanje i klasa se zove pucanje i vi samo navedete pucanje.sad ....i to je to.
(sad je objekt a pucanje konstruktor).Mogućnsti su velike.

izracun()             //OVDJE FORMIRAMO KONSTRUKTOR

U public dijelu smo vidjeli kako se formira konstriktor,kao i funkcija
ali nema tipa ,imena je klase,u prazne zagrade možete staviti i void jer se u biti radi o konstruktoru koji ima
izvršenje unutar sebe,nemamo return.

izracun t;     //čim smo naveli ime klase i ime objekta pozvali smo konstruktor i on se izvršio automatski

Unutar main() dijela znači konstruktor se izvršava čim smo oformili objekt ,u našem slučaju imena t.
Sad samo pozivamo funkciju tipa int da završi naš program jer se argumenti iz izvršenja konstruktora proslijeđuju parametrima
naše int funkcijie.I to je to.
Sad će slijediti program s više konstruktora:

#include<iostream >
using namespace std ;
class izracun  {
   private:
     int a;
     int b;
       public:
         izracun() //OVDJE FORMIRAMO KONSTRUKTOR
            {
               cout << "Stranica a :"<< endl;
               cin>> a;
                cout << "Stranica b :"<< endl;
                cin>> b;
            }
         izracun(int x,int y)// i ovdje je konstruktor
            {
                 a=x;
                b=y;
              }
         int povrsina() { return(a*b);}
};
int main()
{
izracun t;
cout<< "Povrsina je : " << t.povrsina() << endl;
cout<<endl;
izracun t2(4,3);
cout<<"Za t2(4,3) povrsinaje :"<< t2.povrsina() << endl;
system ("PAUSE");
return 0;}

Sad malo sami proučavajte što se radi u ovom programu jer ako ste dobro sve dosad svaladali ovo vam treba biti
"mačiji kašalj"  sad! Iako ču opet nekoliko riječi reći i o ovom programu,ali ne trenutno.
U ovom programu s dva konstruktora vidimo da smo jedan konstruktor posatvili s dva parametra koja se
"hrane" s dva argumenta unesena iz prvog konstruktora i na kraju pozivamo funkciju t2.površina;
....eto probajte sami sad već shvatiti kako konstruktori rade bar u ovim jednostavnim primjerima jer ako i njh dobro
svladate mislim da vam svladavanje kompliciranijih primjera više neće biti teško.

NASLIJEĐIVANJE

Priznajte da je lijep naslov ,kao da se radi o medicini i prijenosu gena ,vjerujte ima sličnosti.
Naravno u ovom dijelu prvo ćemo napisati program a tek onda objasniti o čemu se radi.
Primjetite samo da se radi o klasi koja želi nešto naslijediti ona mora biti prijatelj te klase a originalna klasa
da bi dopustila svoje naslijeđe prijateljskoj klasi ne smije tj.mora imati dio koji se može naslijediti ,naravno to je public dio
ali i potected dio koje koriste obe klase,što znači da se protected dio ponaša kao i private samo što njega ,za razliku od private
dijela, može koristiti i prijateljska klasa!Znači najednostavnije vam je zasad shvatiti ovako : ako neku klasu želimo
koristiti unutar druge klase(bar neku njenu funkciju) tad umjesto private dijela u tu klasu stavite protected dio.Na taj način ono
što je u protected dijelu mogu koristiti prijateljske klase.
Ja sam ovo pojednostavio da bolje shvatite odnose public,private,protected jer mislim da je tako bolje nego da ulazim
u neke definicije u kojima se gubimo.
Evo program :
#include <iostream>
using namespace std;
class zbrajanje
{
      protected:    //varijablu moramo staviti u protected dio da bi mogli primjeniti naslijedjivanje
                int x;
      public:
             void unesite()
             {
                  cout<<"Unesite jedan broj :"<<endl;
                  cin>>x;
             }
             int zbroj()
             {
                 return (x+x);
             }
};  // ovdje zavrsavamo nasu klasu zbrajanje broja koji smo unijeli

class zbrajanje_2 : public zbrajanje
{
      public:
             int izracun()
             {
                 return (x+x+x);
             }
};  //zavrsetak klase koja naslijedjuje klasu zbrajanje i njenu funkciju                           

int main()
{
    zbrajanje zbroj_1;
    zbroj_1.unesite();
    cout<<"Zbroj nasa dva unesena broja je : "<<zbroj_1.zbroj()<<endl;
    cout<<endl<<endl;
   
    zbrajanje_2 zbroj_2;
    zbroj_2.unesite();
    cout<<"Sad zbroj iz prve klase mnozimo s našim brojem koji unesemo : "<<zbroj_2.izracun()<<endl;
    cout<<endl;
     system("PAUSE");
    return 0;
}

U ovom dijelu se vrši naredba za naslijeđivanje koja naslijeđuje public dio
naše prve klase,ali imamo pozivanje vlastite funkcije druge klase u main dijelu,znači iskoristili smo jednu funkciju unesite ()  iz
prve klase a iz druge novu funkciju ,vlastitu funkciju druge klase.

class zbrajanje_2 : public zbrajanje


Vidite stvaramo objekt za našu drugu klasu i pošto je ta klasa naslijedila funkciju iz public dijela prve klase mi je možemo
koristiti tako da je pozovemo :
zbrajanje_2 zbroj_2;
    zbroj_2.unesite();



A ovdje koristimo funkciju iiz naše druge klase  :  cout<<"Sad zbroj iz prve klase mnozimo s našim brojem koji unesemo : "<<zbroj_2.izracun()<<endl;

Vidite kako se možemo nadograđivati i ne pisati stalno jedno te isto kad nam nešto zatreba iz nekih drugih klasa,tad samo
tu klasu postavimo kao prijatelja i omogućimo pristup pomoću protected dijela jer u tom dijelu se nalazi varijabla koja se koristi u public dijelu
ali sad je može koristiti i prijateljska klasa jer joj tako omogućavamo pristup.
Da ste ovaj dio :
protected:    //varijablu moramo staviti u protected dio da bi mogli primjeniti naslijedjivanje
                int x;
Stavili u private dio ,ne bi se ništa moglo naslijediti iz tog private dijela jer private omogućava
pristup samo toj klasi u kojoj se nalazi.

Upamtite samo puno vježbanja jednih te istih izraza i naredbi doprinosi da sve shvatite!!!!
Evo s ovim kratkim osnovnim pregledom klasa i pogledom koji je jednostavan završavam s ovim postom o klasama
jer dalje će biti malo teži program i veći,također će se raditi o klasama i spremanje u datoteke,tj. deklaraciju u jednu datoteku ,definiciju u
drugu ,a sve to uključujemo u glavni program,znači napraviti ćemo jedan program i razdvojiti ga u više datoteka(cpp,.h.i main.cpp).
Sve to slijedećem postu.To će biti još bolje upoznavanje s objektnim pristupom u c++-u!
Možda prije toga se u kratkom postu osvrnem na spremanje u datoteke brojeva i slova,vidjet ću što mi
dođe prije.Eto ,to vas čeka od mene u slijedećim postovima.


Znači korisničke tipove i njihova imena mi biramo!!!
To je znači izvedeni tip u c++-u!
To bi bilo zasad sve.

svaka vam čast ljudi kakva to treba biti volja da to ideš pisat, mislim da bi vam Bugovci trebali poslat majce

najbolje je dok sam svom prijatelju rekao da ovdje ima tutorijale jer je htio nešti u C++ naučit, a on meni danas veli da mu je to preveć za čitati da nema tolko volje

Kako se stavljaju slike ovdje? Je to uopce moguce?

PROGRAM U VIŠE DATOTEKA

UVOD(kratki)

Spremanje nekog velikog programa u datoteke ćemo objasniti
koristeći Dev okruženje ,tako da znate o čemu se radi kad budem opisivao,ali

princip je svugdje isti.
Mi moramo imati razdvojene deklaracije i definicije programa i dakako
main.cpp dio programa u kojem sve to i pozivamo .
U ime programa koje mi hoćemo spremamo deklaracije u ime_programa.h
U ime_programa.cpp spremamo definicije programa s time da u tu datoteku
uključujemo
#include "ime_programa.h"
našu header datoteku koja je pod navodnicima što je  to opet znak pretprocesoru

da
tu datoteku  prvo potraži u našim vlastitim datotekama programa koji mi pišemo.
Na kraju u glavnom programu također moramo uključiti
#include "ime_programa.h"
Ovo je samo jako kratki osvrt na ono što želim prikazati u ovom postu.
Vrlo su bitni nastavci .cpp i .h kao i imena prije njih jer njima upoznajete
kompajler na što mora obrtaiti pažnju i što s čime spojiti.
Naravno ovo vam sad sve djeluje apstraktno ali kad sve to pokažemo u programu
biti će vam puno jasnije.
Program i objašnjenja će malo čekati jer nisam izdržao napisati bar ovaj uvod
i stoga mi ne zamjerite što ćete možda malo i čekati.

Znači datoteke koje korisnik(programer) radi ,znači deklaracije funkcija ili metoda

stavlja u header datoteke(datoteke zaglavlja ) ali njih se stavlja između navodnika

,za razliku od standardnih zaglavla između <> tih znakova.Procesor tj.prevoditelj

(kompajler) prvo gleda u "domaće" uratke zaglavlja koje uključuje u program

(main),naravno ,uključuje i standardna jer bez njih ne bi mogao raditi.
Često u programima koje se rade imamo puno zaglavlja u koja su uključena druga

zaglavlja i tako jako puno.Da bismo izbjegli ponavljanje određenih zaglavlja

tj.deklaracija koje nam trebaju(naših korisničkih zaglavlja pod navodnicima) ,više

puta u jednom programu koristimo tehniku
spremanja na taj način da pretprocesoru dajemo do znanja ako neka deklaracija

nije definirana niti jednom ,onda se ona samo jednom definira i na taj način je

poznata za sve slijedeće susrete s njom u daljnjem prevođenju,znači izbjegnuta je

višestruka deklaracija.Jednom je dovoljno.To se postiže s naredbama:

#ifndef      //direktiva za uslovno prevođenje ako nije niti jednom još definirano      

          //(korišteno zaglavlje)
#define    // zatim definira to zaglavlje
.....
......//sadržaj (deklaracija)
......
#endif   //naravno kraj

Naprimjer tako je izbjegnuto da se ponavlja stalno:

#include "ime_isto.h"
#include "ime_isto.h"
S ifndef i define ,naravno na kraju mora doći endif,sve se to izbjegava i nema ponavljanja.
Ovo je sve bila teorija ,slijede i programi i zajedno ćete sve lijepo naučiti i shvatiti
jer vam sad ovo djeluje jako čudno.Kao što rekoh malo strpljenja bih zamolio.

Prije jednog malo većeg programa pokazati ću vam na vrlo malom programu kako se radi
spremanje u datoteke i njihovo uklučivanje.Radi se o Dev okruženju gdje kad pokrenete program i kad vam se otvore
projekti vi morate osim main.cpp koju smo mi u ovom programu nazvali drugačije,morate na desni klik i otvoriti još
dvije nove datoteke koje ćete nazvati kako hoćete,u našem programu oblik.h i oblik.cpp !
Sjećate se prije kad sam spomenuo razdvajanje deklaracije i definicije ,sad to i primjenjujemo!
U header oblik.h datoteku idu deklaracije naše klase i što se sve nalazi u toj klasi....znači samo objava!!!!
Naravno ,velika slova na ovaj način koji ja predstavljam u definiranju ifndef i define su obvezna i taj oblik.
Naprimjer mogli smo dati ime blabla.h   i tad bi to ovako izgledalo : #ifndef  BLABLA_H
#define  BLABLA_H

Shvatite to kao pravilo zasad.

Datoteka oblik.h :

#ifndef OBLIK_H
#define OBLIK_H
#include <iostream>
using namespace std;
class g_oblik
{
   private:
   int c;
     public:
       void ime();
       
       int povrsina(int a,int b);
      
};
#endif

Primjetite da nema nniti jedne definicije nego samo što nam treba,objava!
Ako se vratite malo unazad po postovima ,vidjet ćete ovaj program pisan u samo jednoj datoteci a sad ga ja
namjerno razdvajam da vam pokažem kako to razdvajanje u više datoteka ide.
Na malim programima je to besmisleno ali tako se može bolje objasniti.
 
Sad idu definicije svega u klasama.......ponovite post o razdvajanju deklaracije i definicije.

Datoteka oblik.cpp :

#include<iostream >
#include "oblik.h"   //ovdje znači obvezno uključujemo našu header dat!!!!!
using namespace std ;  
        int c;   
        void g_oblik:: ime()
         {
          cout << "Povrsina "<< endl;
          cout<<endl;
         }
       int g_oblik:: povrsina(int a,int b)
         {
          c = a* b;
          return(c);
         }

/*u programu su samo definicije i varijable koje nam trebaju*/

Sad kad smo to sve razdvojili i napravili možemo i napisati glavni program i u tom
glavnom programu također uključujemo našu korisničku datoteku koju smo mi napravili
jer program ne bi radio bez nje(probajte-pogledajte koju grešku javlja)
Naš program main.cpp smo nazvali klase5.cpp a vi ste ga mogli ostaviti i main.cpp da znate da je glavni :


#include<iostream >
#include "oblik.h"        //korisnička header dat.
using namespace std ;

int main()
{
g_oblik pr;
pr.ime();                      //poziv funkcije ime()
cout<<"Rezultat je : "<<endl;
cout<<pr.povrsina(3,4);        //poziv funkcije povrsina()
cout<<endl;
cout<< endl;
system ("PAUSE");
return 0;
}

Vidite da je glavni program isti kao i u jednoj datoteci ali smo uključili našu
oblik.h i preko nje sve drugo pozivamo u programu jer je pretproces pogledao u nju i shvatio što sve po redu
trba izvršiti,i tako imamo program koji je mali u tri umjesto u jednoj datoteci.....
Zamislite sad veliki program i puno deklaracija i definicija a vi sve to možete staviti u par datoteka
i podijeliti zadatke programerima da svatko radi svoju datoteku i vodi računa o njoj
i vidite da je tako lakše sve obavljati kad se radi o velikom programu nego sve pisati odjednom i sam
....tad je mogučnost pogreške veća neko kad više umova i očiju rade veliki program.
Znači na desnoj strani u Dev -u pri otvorenom projektu morate imati  ovakav raspored  :

-projekt(ime koje ste vi izabrali)
    -klase5.cpp
    -oblik.cpp
    -oblik.h

Sad se malo igrajte s ovim programom i nadam se da ću opet brzo naći vremena za dalje.
Nadam se da dovoljno dobro objašnjavam jer nije mi namjera komplicirati i unaprijed se ispričavam
na gramatičkim greškama jer dosad je puno toga napisano pa se jednostavno nemam vrenmena vraćati i
pregledati.

 
Nadam se da ste dosad bar shvatili principe klasa i naslijeđivanja jer sad ide malo teži i kompliciraniji program koji
obuhvaća poznavanje cijelog dosadašnjeg tutorijala ,bar funkcije i klase!
Prvo ću vam program staviti a vi ga malo proučavajte i naravno objasnim ga kako i zašto je sve tako posatvljeno :

datoteka Zaposlenici.h

#ifndef ZAPOSLENICI_H
#define ZAPOSLENICI_H
#include <string>
using namespace std;
class  zaposlenici
{
      public:
             zaposlenici(const string & ,const string &,const string &,
                                 double =0.0,double = 0.0);
             void setIme(const string&);//void setIme
             string getIme() const;     //string getIme
            
             void setPrezime(const string&);//void setPrezime
               string getPrezime() const;   //string getPrezime                
           
              void setJmbg(const string&); // void setJmbg
              string getJmbg() const;   //string getJmbg
             
              void setVeleProdaja(double); //void  setVeleProdaja
              double getVeleProdaja() const;  //double getVeleProdaja
             
               void setDobit(double);  //void setDobit
               double getDobit() const;  //double getDobit
              
               double zarada() const;   // double zarada
               void ispis() const;       //void ispis
              
     protected:
               string ime;   //ime
               string prezime;    //prezime
               string jmbg;  //jmbg
               double veleprodaja;    //  veleprodaja
               double dobit;  // dobit
              
};
#endif
         

....naravno iza te datoteke ide i Zaposlenici.cpp :

#include <iostream>
#include "Zaposlenici.h"
using namespace std;

//konstruktor   zaposlenici::zaposlenici(prvi,zadnji,sjmbg,prodaja,rata)
zaposlenici::zaposlenici(const string &prvi,const string &zadnji,const string &sjmbg,double prodaja, double rata)

    {
              ime =prvi;   //ime = prvi
              prezime= zadnji;   //prezime = zadnji
              jmbg = sjmbg;  //jmbg = sjmbg
              setVeleProdaja(prodaja)  ;      //setVeleProdaja(prodaja)
              setDobit (rata)  ;    //setDobit (rate)
    }
   
 //prvo ime
 void zaposlenici::setIme(const string &prvi)
    {
          ime = prvi;
    }
   
 string zaposlenici::getIme() const
    {
        return ime;
    }
 //________________________________________________________________________  
     void zaposlenici::setPrezime(const string &zadnji)//setPrezime
    {
          prezime = zadnji;
    }
   
 string  zaposlenici::getPrezime() const//getPrezime
    {
         return prezime;
    }
 //**********************************************************
    void zaposlenici::setJmbg(const string &sjmbg)// setJmbg
    {
         jmbg= sjmbg;
    }
   
 string  zaposlenici::getJmbg() const   //getJmbg
    {
         return jmbg;
    }
   
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
void zaposlenici::setVeleProdaja(double prodaja)  //setVeleProdaja
{
     veleprodaja = (prodaja<0.0)?0.0:prodaja;
}
double zaposlenici::getVeleProdaja() const   //getVeleProdaja
{
    return veleprodaja;
}
//##########################################################

void zaposlenici::setDobit(double rata)
{
      dobit=(rata>0.0 && rata<1.0)?rata : 0.0;
}
 double zaposlenici::getDobit() const
{
    return dobit;
}
//*========================================================
double zaposlenici::zarada() const
{
          return dobit * veleprodaja;
}
//::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
  void zaposlenici::ispis() const
 {
      cout<<"Ime Zaposlenika : "<<ime<<' '<<prezime<<endl;
      cout<<"JMBG : "<<jmbg<<endl;
      cout<<"Ukupna prodaja :"<<veleprodaja<<endl;
      cout<<"Zarada po prodanom : "<<dobit<<endl;
 }
                                                                

                                                         
.....sad ide datoteka koja tu klasu naslijeđuje i koristi protected dio i ima svoj vlastiti ispis :
....datoteka Bzaposlenici.h:

#ifndef BZAPOSLENICI_H
#define BZAPOSLENICI_H
#include <string>
#include "zaposlenici.h"  // "zaposlenici.h"
using namespace std;
class Bzaposlenici : public zaposlenici  //naslijeđuje class zaposlenici
{
      public:
            Bzaposlenici(const string &,const string &,const string &,double = 0.0,
                                        double = 0.0,double = 0.0);
                                       
             void setBProdaja(double);   //void  setBProdaja
             double getBProdaja() const;  //double getBProdaja
            
             double zarada() const;
            void ispis() const;
            
             private:
                     double bprodaja;
};
#endif                                             

...naravno ide i Bzaposlenici.cpp :

#include <iostream>
#include "Bzaposlenici.h"
using namespace std;
//konstruktor       (&prvi,&zadnji,&sjmbg,&prodaja,&rata,&placa):zaposlenici(prvi,zadnji,sjmbg,prodaja,rata)
Bzaposlenici::Bzaposlenici(const string &prvi,const string &zadnji,const string &sjmbg,
                                               double prodaja,double rata,double placa):
                                                      zaposlenici(prvi,zadnji,sjmbg,prodaja,rata)
    {
                                   setBProdaja(placa);
    }
   
    //**************************************************************
   void Bzaposlenici::setBProdaja(double placa)
    {
         bprodaja =(placa<0.0)?0.0:placa;
    }
    //************************************************                                                                                                                                                                                
  double Bzaposlenici::getBProdaja() const
   {
         return bprodaja;
   }
   //***************************************************************
    double Bzaposlenici::zarada() const
    {
             return bprodaja +(dobit * veleprodaja);
    }
   
//****************************************************************
    void Bzaposlenici::ispis() const  //vlastiti ispis Bzaposlenici i koristimo varijable iz class zaposlenici
{
     //sad možemo pristupiti protected dijelu
     cout<<"Ime i prezime  :"<<ime<<' '<<prezime<<endl;
     cout<<"JMBG :"<<jmbg<<endl;
     cout<<"Ukupna prodaja :"<<veleprodaja<<endl;
     cout<<"Zarada po komadu : "<<dobit<<endl;
     cout<<"Osnova place :"<<bprodaja
     <<endl;
}

....sve to u glavnom programu koji sam nazvao klasebug.cpp spajamo  :

#include <iostream>
#include <iomanip>
#include "Bzaposlenici.h"

using namespace std;

int main()
{
    Bzaposlenici
          radnici("Bug","Bugic","456-78-3789",10000,.04,300);
         
          cout<<fixed<<setprecision(2);
         
          cout<<"Informacije o zaposlenicima s get  funkcijom : "<<endl;
          cout<<"Prvo ime je : "<<radnici.getIme()<<endl;
           cout<<"prezime je : "<<radnici.getPrezime()<<endl;
           cout<<"JMBG je :"<<endl;
           cout<<radnici.getJmbg()<<endl;
           cout<<"Ukupna prodaja : "<<radnici.getVeleProdaja()<<endl;
             cout<<"Dobit po prodanom je : "<<radnici.getDobit()<<endl;
             cout<<"Pojedinacna prodaja : "<<radnici.getBProdaja()<<endl;
             cout<<endl;
             radnici.setBProdaja(1000);
             cout<<"Print funkcija ali od Bzaposlenici klase : "<<endl;
             radnici.ispis();
             cout<<"Zarada zaposlenika : "<<endl;
             cout<<radnici.zarada()<<endl;
   
   
    system("PAUSE");
    return 0;
}


....sad kompajl!

U desnom dijelu Dev-a gdje se nalazi vaš "solution explorer" da ga tako nazovemo mora ovako izgledati(kod mene) :

-klasebug(ime koje sam ja dao za projekt)
     -Bzaposlenici.cpp
     -Bzaposlenici.h
     -klasebug.cpp
    - Zaposlenici.cpp
    -Zaposlenici.h
Evo sad imate dosta vježbe dok sve malo bolje ne objasnim.
A poslije toga taj isti program ćemo napisati tako ali bez protected dijela i tako da shvatite malo
razliku naslijeđivanja i stavljanja jedna klase u drugu i razliku .Malo vježbajte s ovim ispisima jer samo tako se uči.

KLASE (treći dio)

Nažalost moram ovako razdvajati jer postaje teško editirati postove koristeći IE.

O samoj definiciji što je to klasa i otprilike čemu služe ste kroz tut o klsama već
malo i skužili.Jedna od važnijih karakteristika je enkapsulacija .To je jasno

razdvajanje public dijela od unutrašnjosti same klase(koristeći private i protected dijelove).
Na taj način možemounutrašnjost klase napisati a ne rušeći koncepciju cijelog programa,
 a krajnjem korisniku ponuditi funkcionalnost i rad motora i njegovih dijelova(objekata)
,a on ne mora znati kako i od čega je motor sastavljen nego samo da radi!Klasa je

korisnički tip a objekti su nešto tog tipa.Možete napraviti koliko hoćete objekata tip

a te klase.Proces pravljenja objekata određene klase se zove instanciranje.Znači

OPP smo već spominjali a glavne su mu karakteristike već gore

navedene,enkapsulacija,nasljeđivanje i ostaje još polimorfizam....kao treći

najvažniji aspekt OPP-a .Polimorfizam je svojstvo da se objekt koji potiče iz iz

izvedene klase izvršava operaciju svojstvenu izvedenoj klasi a pristupa mu se kao

osnovnoj klasi.Naprimjer u osnovnoj klasi imamo objekt koji kad ga pozovemo

izvršava funkciju piši() i sad mi izvedemo par klasa iz osnovne  klase i u svakoj toj

izvedenoj klasi možemo pozvati funkciju piši a ona izvršava ono što i treba-ispis a

ne mora znati što će ispisati ni što to znači...na taj način mi neki objekt koji je

davno stvoren možemo više puta koristiti na sasvim novim klasma ,a te klase

recimo ispisuju različite riječi....to je polimorfizam.
Taj objekt..funkcija izvršava

radnju u izvedenoj (novoj klasi) ali pristup je kao u osnovnoj klasi.Sad vidite

prednost ..možemo neki proizvod samo nadograđivati a ne moramo se odricati

staroga,samo dodajemo mijenjajući oblik ali osnovne funkcije zadržavamo.Znači tri

glavne karakteristike OPP-a su : naslijeđivanje,enkapsulacija

(sakrivanje),polimorfizam.Naravno to je samo okosnica ,a sve detalje u klasama i

objekte ,njihovo korištenje i rad s klasama samim time stavra sliku objektne

orijentiranosti.

Ovo je samo dio i osnova o čemu ja pišem jer se o tome može

napisati jako puno.U programu koji sam uzimao za primjer protected naslijeđivanja

i bez protected naslijeđivanja ,to  je samo da vidite razliku,s protected zonom koju

klasa Bzaposlenici naslijeđuje je elegantnije napisana,a druga bez protected zone
je malo robusnija ali u oba slučaja se radi o nalijeđivanju,samo što u jednom

slučaju klasa koja naslijeđuje naslijedi i private članove osnovne klase a u drugom

slučaju ne!O programeru ovisi koji kod će mu bolje koristiti a koji ne.Oba imaju

svoje nedostatke i prednosti.

Samo mala digresija od tema klasa iako je i povezano s tom temom .

Nedavno sam imao pitanje zašto nisam nešto i o strukturama rekao i pristupu članovima struktura.
Zasad neću otvarati poseban post o strukturama i unijama ali mislim i njih obraditi ,osim ako me neki autor ne pretekne.
Zasad samo krati program kako se pišu strukture i kako se pristupa njezinim članovima.
Više onjima će svakako biti kao što rekoh do jeseni,ali zasad proučite na koji način smo pristupili članovima strukture
i kako je sve to posloženo,naravno vježbajte,a pristup npr.članovima unije i poljima je sličan ovom pristupu.
Zasad samo to proučite,nisam ništa posebno objasnio jer će biti i poseban post,ako netko želi od drugih autora
objasniti neka objasni.Osnovna razlika između struktura i klasa je naravno u ključnoj riječi(pogodite kojoj) i naravno
svi članovi u strukturama su po defaultu javni(public) a u klasama ako ne navedete ništa oni su zaštičeni(private).
Evo koda pa proučavajte :
#include<iostream>
#include<string>
using namespace std;
struct BOOK
{
 char Naslov[80];
 char Author[80];
 char Izdavac[80];
 int   Godina;
};
BOOK Novel =
{
 "Naslov knjige",
 "Ime i prezime",
 "Izdavac",
 1984
};

int main()
{
 BOOK* p=NULL;
 p=&Novel;
 cout<<Novel.Author<<endl;
 cout<<Novel.Izdavac<<endl;
 cout<<Novel.Naslov<<endl;
 cout<<Novel.Godina<<endl;
   cout<< p->Author<<endl;
   cout<<p->Izdavac<<endl;
   cout<<(*p).Godina<<endl;//znaci isto sto i p->Godina
 cout<<endl;
 system ("pause");
 return 0;
}
 /*U OVOM PROGRAMSKOM KODU BAVIMO SE STRUKTUROM.
// SLICNE SU KLASAMA ALI OVAJ PRIMJER NAM SAD SLUZI SAMO DA
// PRIKAZEM KAKO SE MOZE PRISTUPITI CLANU STRUKTURE.
// PREKO TOCKE (TKZ.MEMBER ACCES OPERATOR)---OBLIK DIREKTNOG
// PRISTUPA POJEDINIM CLANOVIMA STRUKTURE.
// I NARAVNO POSREDNI PRISTUP PREKO POKAZIVACA KOJI NARAVNO
// MORAMO NA POCETKU DEKLARIRATI KAO PRIPADNIKA STRUKTURE
// I TEK ONDA PREUSMJERIMO NA STO CE POKAZIVATI I ETO VAM
// OBJASNJENJA OPERATORA ->   
// NARAVNO TO JE ISTO STO I p->Godina */

Naravno ,vidim da ima pitanja i o destruktorima...e to ćemo prije jeseni još obraditi(bar ja).
Do slijedećeg nastavka.

Nasao sam zadatke i prvog odmah nisam znao rijesiti a tu nisam nigdje nasao rjesenje problema

Ovako zadatak glasi

Napravi C++ program koji ce zbrojiti sve dvoznamenkaste brojeve.

Ja sam sve napravio osim zbroja jer jednostavno nemam ideje kako to napraviti

Ako netko moze pomoci unaprijed zahvaljujem

Kad radite programe u VS-u ili VS Express izdanju tad ako ne radite Empty project a kliknete finish na Wizardu ,ne dodajete nikakav
cpp.file(ako radite jednostavne programe console) nego sve pišete unutar stvorene tmain() funkcije samo dodate potrebne headere.
Evo slike i jednostavnog programa da vidite o čemu pričam:
edit:@unknown
što ispočetka?
post prije?ili ovo u svezi VS-a?
ok,početak je na file->new project->izaberete kao jezik c++ i na Win32 klik i ->klik na win32 console app->imenujete projekt i to je to.
slika koja ide prije svih onih slika dolje je ova zadnja(zbog uređivanja posta),pa sami posložite,ako još ima nejasnoća oko empty i console app
u odabiru pri pokretanju VS-a pitajte.

nisam citao topic od pocetka, pa ne znam jel sppomenuto al ovo je meni pomoglo dok nisam bas nista kuzio (nisam ni sad nesto bolji, but still...):

http://www.3dbuzz.com   -- za pocetnike ima nekoliko video tutorijala o C i C++-u izmedju ostalog, samo se registrirajte da bi dobili pristup   -- fora je nacin na koji   prezentiraju i zezaju se stalno; mnostvo ostalih tutoriala za one koji se misle bavit 3d-om, igrama i sl.

Svaka čast, nemam riječi, klanjam ti se  BIG RESPECT za ovaj tutorijal.

Sad jedna zamolba za bugovce. Da ovaj tutorijal izvezu u .pdf da to mogu komotno isprintati, zamorno je ovak iz browsera to čitati...

Svaka čast v_maxcpp i ostalima koji su sudjelovali, registrirao sam se samo davam se zahvalim na odličnom tutorijalu. Mislim da će mi puno pomoći u svladavanju c++.

Puno hvala i ljiep pozdrav

Iskaz switch() se ne može primjenjvati na znakovne nizove ili objekte jer nisu cjelobrojne vrijednosti(int).Da bi to funkcioniralo moraš ubacivati if else naprimjer.
U zagradi swicth(int tip) mora uvijek biti cjelobrojna vrijednost ili zamjena za nju koja je isto u biti int tip jer se u swicth() uvjetima radi o
biranju int odluke koja onda pokazuje znakovne odgovore i slično.

#include <iostream>
#include<string>

using namespace std;

int main()
{
   
   
 string  ime ;
 string  pozdrav = "Pozdrav ,";
 int izbor = 0;
 

cout << "Kako se zovete:";

cin >> ime;
cout<<"Pritisnite jedan!"<<endl;
cin>>izbor;

 
    switch(izbor)

    {

    case  1:
    cout<<pozdrav<<ime<<"!"<<endl;


     break;

 

        default:
        cout<<"Niste nista unijeli"<<endl;
    }
    
    
    system("PAUSE");
    return 0;
}
No,ovo je samo na brzinu napisano ali uvijek u switch() uvjetu mora biti int vrijednost.

Evo još jedan primjer i dokaz da u switch() iskazu mora biti integrer,a možeš sam kombinitrati i s stringovima  i char poljima :

#include <iostream>
using namespace std;
int main()
{
    char slovo =false;                       //ovdje mozes staviti i nulu jer je ona u biti false(a oba su int tip!!! char slovo =0;
    cout<<"unesite malo slovo : "<<endl;
    cin>>slovo;
    cout<<endl;
    switch(slovo*(slovo >= 'a' && slovo <='z'))
    {
          case 'a':
               case 'e':
                    case 'i':
                         case 'o':
                              case 'u':
                                   cout<<"Unijeli ste samoglasnik!"<<endl;
                                   break;
                                   case 0:
                                        cout<<"To nije malo slovo!"<<endl;
                                        break;
                                        default:
                                                cout<<"Unijeli ste suglasnik!"<<endl;
    }
    system ("pause");
    return 0;
}
                                          

Nadam se da je malo jasnije.

KONSTRUKTORI I DESTRUKTORI(KLASE)

Ne znam da li sam nešto rekao o konstruktorima ali od ponavljanja i viška sigurno ne boli glava.
Konstruktor je specijalna funkcija koja se odmah izvršava u glavnom programu
čim oformimo objekt(instancu dotične klase).
Znači odmah se izvršva čim navedemo ime objekta.
Zašto je tako ima i kratko objašnjenje.
Kad ste objekt definirali unutar jedne funkcije i on je lokalan unutar nje,on se i uništi
čim ta funkcija završi i na taj način se oslobađa memorija.Ali,kod globalnih objekata
on se uništava tek na kraju cijelog programa i zato postoje npr. konstruktori i destruktori.
općenito oznake su :

ime konstruktora je klasa
ime destruktora je ~klasa

Nemaju povratni tip.
Sad ću samo pokazati kako se piše kod bez izvršavanja:

     class  CKlasa

           {
                 char* pok;

                 int duzina;

               
              public:

                 CKlasa();      //konstruktor
                ~CKlasa()     //destruktor
                 //sad ovdje pišemo ostatak programa
          };   //završetak naše klase tj .  deklaracija u fajlu cpp.

Sad definicije naših konstruktora i destruktora u .h datoteci idu ovako:

CKlasa::CKlasa()             //u imenu je samo naziv nase klase i na taj način čim u glavnom programu
                                      //oformimo objekt tad se i stvori i izvrši konstruktor

  {
       pok = new char[1];
       *pok = '\0';
       duzina = 0;
  }

                                      //naravno čim nam više ne treba konstruktor tj. objekt  aktivira se destruktor
    CKlasa::~CKlasa()

        {

              delete [] pok
        }
                                     //znači da bi sad razumjeli ovaj početak u svezi konstruktora i destruktora
                                    //ponovite dinamičku alokaciju memorije i new i delete povezanost!!!
                                   //to sam već u tutorijalu objasnio pa da se ne vraćamo na to.

Taj ~ znak dobijete AltGr + broj 1.

Naravno sad slijede primjeri u obliku programa gdje će vam ovo sve biti
puno jasnije .Naravno ,strpite se.

Jednostavni primjer konstruktora i destruktora (napisano u VS-u) :

#include <iostream>
using namespace std;
//definicija klase u globalnom dijelu programa

class CKutija           //uobicajeni naziv(i klasa) kad se pisu knjige o c++-u
{
private:
    double visina;
    double duzina;
    double sirina;
public:

    CKutija(double v,double s,double d)//definicija konstruktora
    {
        cout<<"Pozvani konstruktor"<<endl;
        duzina=d;
        visina = v;
        sirina = s;
    }
    ~CKutija()
    {
        cout<<"Destruktor smo pozvali"<<endl;
    }

    //sad ide funkcija koja izracunava volumen nase kutije
    double volumen()
    {
        return duzina * visina * sirina;
    }
};
int main()
{
    CKutija kutija_1(23.4,34.5,45.6);    //deklaracija kutije_1 ali odmah i izvrsavanje

    CKutija kutija_2(12.3,34.4,56.6);    //jer je konstruktor pozvan
    double volumen_kutije =0.0; //deklaracija varijable u koju cemo spremiti izracun
        volumen_kutije = kutija_1.volumen();
    cout<<"Volumen prve kutije je : "<<volumen_kutije<<endl;
    cout<<"Volumen druge kutije je : "<<kutija_2.volumen()<<endl;
    cout<<endl;


    return 0;
}

//kad izvrsite program primjetite da se konstruktor i destruktor pojavljuju
//onoliko puta koliko smo objekata stvorili ,destruktor uvijek ide iza konstruktora

Dolje niže možete vidjeti sliku izvršenog programa!Pod nazivom CKutija_exe.
Detaljnije objašnjenje slijedi ali malo kasnije kad stignem.
Prije tog objašnjenja napraviti ću malu digresiju i samo konstruktor malo detaljnije objasniti
jer on ima veće značenje nego sam destruktor koji samo oslobađa memoriju(što je također važno).
Slijedi program koji možete u DEV-u napraviti :

#include<iostream>

using namespace std;

class P
   {
        private:
          int a;
         int b;
          public:
                             //sad dolazi definicija konstruktora
             P()
               {
                    cout<<"Unesite a: "<<endl;
                    cin>>a;
                    cout<<"Unesite b: "<<endl;
                     cin>>b;
                }
            //sad funkcija s povratnim tipom ali se unutar sebe izvrsava
           int izracun(void)       //ali je void sto se tice parametara!!!!
                {
                     return(a*b);

                  }
   };//zavrsetak nase klase P

int main ()
   {
      P p ;      //cim smo dozvali klasu i deklarirali objekt odmah se i izvrsio nas konstruktor!!!!
      cout<<"Povrsina je " << p.izracun()<<"."<<endl;
     system("pause");
     return 0;
   }
 
    Znaci konstruktor je funkcija ilin metoda koja se izvrsava u trnutku formiranja objekta!!!!
 Uocite razliku izmedju funkcije int ali void parametara    i konstruktora.
Konstruktor tj . njegovo ime je ime klase.
I naravno primjetite kad se konstruktor izvršava!!!

Prije nego objasnim kod s klasom kutija ,samo da se vratim na prvi primjer koji sad napišite i
izvršite u Dev-u:

#include <iostream>
using namespace std;
class CKlas
 {
      private:
              char* p;
              int duzina;
              public:
                     CKlas()
                     {
                            cout<<"konstruktor"<<endl;
                            p = new char[1];
                            *p = '\0';
                            duzina = 0;
                     }
                     ~CKlas()
                     {
                             cout<<"Destruktor"<<endl;
                         delete [] p;
                     }
                     
   };
   int main()
   {
       CKlas ();
       
       system("pause");
       return 0;
       }
      

Inače programi se pišu bez da kažete unutar programa što se
izvršava kao što sam ja napisao,to je samo da vidite kad je naredu konstruktor a kad destruktor.
Eto ,dovoljno je samo navesti ime klase i pozivate konstruktor i njegov destruktor.
Naravno ,naredbe new i delete su međusobno povezane i one se koriste pri stavranju konstruktora i destruktora.

Sad možemo na objašnjenje drugog programa gdje sam također stavio da se pokaže
kad je naredu konstruktor a kad destruktor i naravno vi to u komercijalnim programima nećete stavljati,to je samo
za potrebe učenja.

CKutija(double v,double s,double d)//definicija konstruktor

Znači ,naš konstruktor ima parametre tipa double
Pomoću njh dolazimo do private članova tako da ih iniciijaliziramo s njima.

        duzina=d;
        visina = v;
        sirina = s;

Sad kad je to napravljeno ,odmah pri pozivu konstruktora se vrijednosti smještaju na svoja mjesta.

 CKutija kutija_1(23.4,34.5,45.6); //ovo je u biti taj oblik CKutija(double,double,double)

Vidite samo poštivamo poredak i proslijeđujemo argumente parametrima i konstruirali smo objekt i na njemu
odmah možemo vršiti radnju(funkciju).

kutija_1.volumen();//jer svi parametri su pomoću konstruktora unutra.

I sad kad je program gotov i da se ne bi memorija gušila podacima odmah slijedi destruktor i
čisti sve za nama!
U programu može biti i više konstruktora a ne samo jedan.
Nadam se da ste osnovni koncept postojanja i stavranja konstruktora shvatili .
Nije mi bio cilj zakomplicirati nego samo osnovna pravila o konstruktorima i njihovim destruktorima
objasniti.
Još će biti riječi o njima ali zasad toliko.
________________________________________________________________________________

Sad kad bi kod izmjenili tj.dodali deklaraciju treće kutije ali bez parametara:

#include <iostream>
using namespace std;
//definicija klase u globalnom dijelu programa

class CKutija           //uobicajeni naziv(i klasa) kad se pisu knjige o c++-u
{
private:
    double visina;
    double duzina;
    double sirina;
public:

    CKutija(double v,double s,double d)//definicija konstruktora
    {
        cout<<"Pozvani konstruktor"<<endl;
        duzina=d;
        visina = v;
        sirina = s;
    }
    ~CKutija()
    {
        cout<<"Destruktor smo pozvali"<<endl;
    }

    //sad ide funkcija koja izracunava volumen nase kutije
    double volumen()
    {
        return duzina * visina * sirina;
    }
};
int main()
{
    CKutija kutija_1(23.4,34.5,45.6);    //deklaracija kutije_1 ali odmah i izvrsavanje

    CKutija kutija_2(12.3,34.4,56.6);  
    CKutija kutija_3;                       //ovdje je deklaracija trece kutije i kad kompajlate doci ce do pogreške      
                                                  //jer je konstruktor pozvan
    double volumen_kutije =0.0; //deklaracija varijable u koju cemo spremiti izracun
        volumen_kutije = kutija_1.volumen();
    cout<<"Volumen prve kutije je : "<<volumen_kutije<<endl;
    cout<<"Volumen druge kutije je : "<<kutija_2.volumen()<<endl;
    cout<<endl;


    return 0;
}

//kad izvrsite program primjetite da se konstruktor i destruktor pojavljuju
//onoliko puta koliko smo objekata stvorili ,destruktor uvijek ide iza konstruktora

Došlo je do greške jer :
CKutija kutija_3;

kao takva deklaracioja traži defaultni konstruktor da bi se mogla izvršiti!!!
DEFAULTNI KONSTRUKTOR  je u biti konstruktor bez parametara ili argumenata.
Njega moramo dodati u public dio da bi program pravilno radio jer  deklaracija treće kutije traži baš takav
konstruktor a njegov naziv je gore spomenut i objašnjen.Znači ,defaultni konstruktor je bez argumeneta i
sad ćemo cijeli kod preurediti:

#include <iostream>
using namespace std;
//definicija klase u globalnom dijelu programa

class CKutija           //uobicajeni naziv(i klasa) kad se pisu knjige o c++-u
{
private:
    double visina;
    double duzina;
    double sirina;
public:

    CKutija(double v,double s,double d)//definicija konstruktora
    {
        cout<<"Pozvani konstruktor"<<endl;
        duzina=d;
        visina = v;
        sirina = s;
    }
    ~CKutija()
    {
        cout<<"Destruktor smo pozvali"<<endl;
    }
    CKutija()
    {    //ovdje je definicija i deklaracija naseg defaultnog konstruktora!!!!
        cout<<"Defaultni konstruktor je pozvan!!!"<<endl;
    }

    //sad ide funkcija koja izracunava volumen nase kutije
    double volumen()
    {
        return duzina * visina * sirina;
    }
};
int main()
{
    CKutija kutija_1(23.4,34.5,45.6);    //deklaracija kutije_1 ali odmah i izvrsavanje

    CKutija kutija_2(12.3,34.4,56.6);  
    CKutija kutija_3;      //bez argumenata pozivamo defaultni konstruktor
    //jer je konstruktor pozvan
    double volumen_kutije =0.0; //deklaracija varijable u koju cemo spremiti izracun
        volumen_kutije = kutija_1.volumen();
    cout<<"Volumen prve kutije je : "<<volumen_kutije<<endl;
    cout<<"Volumen druge kutije je : "<<kutija_2.volumen()<<endl;
    cout<<endl;


    return 0;
}

//kad izvrsite program primjetite da se konstruktor i destruktor pojavljuju
//onoliko puta koliko smo objekata stvorili ,destruktor uvijek ide iza konstruktora
//naravno i za defaultni konstruktor ide isti destruktor!!!!

Evo proučite dobro ove kodove i shvatiti čete zašto je default konstruktor u programu.
U slijedećem programu ćemo postavljati defaultne vrijednosti za naše parametre unutar konstruktora!
Mislim da sam negdje objasnio tamo pri prijenosu po vrijednosti defaultne argumente u funkciji i što
se dešava pri njihovom pozivu,naravno i ovo je sličan princip pa bi bilo dobro da ponovite funkcije,biti
će vam jasnije sve ovo dalje.
Naravno nastavljamo kad nađem vremena.
_________________________________________________________________________________

Još uvijek smo u defaultnim konstruktorima samo što u ovom slijedećem programu
smo parametrima  konstruktora proslijedili defaultne vrijednosti .Kad sad u glavnom programu zatražimo
konstruktor kutije_3 bez parametara,tad se defaultni konstruktor pojavljuje ali sad
sami obratite pažnju gdje sam izvršio izmjene i što sam izbrisao od prošlog programa gore iznad?
_________________________________________________________________________________

#include <iostream>
using namespace std;
//definicija klase u globalnom dijelu programa

class CKutija           //uobicajeni naziv(i klasa) kad se pisu knjige o c++-u
{
private:
    double visina;
    double duzina;
    double sirina;
public:
//sad nam je ovdje defaultni konstruktor ali i obicni "konstruktor"
    CKutija(double v=1.0,double s=1.0,double d=1.0)//definicija konstruktora
    {
        cout<<"Pozvani konstruktor"<<endl;
        duzina=d;
        visina = v;
        sirina = s;
    }
    ~CKutija()
    {
        cout<<"Destruktor smo pozvali"<<endl;
    }
    

    //sad ide funkcija koja izracunava volumen nase kutije
    double volumen()
    {
        return duzina * visina * sirina;
    }
};
int main()
{
    CKutija kutija_1(23.4,34.5,45.6);    //deklaracija kutije_1 ali odmah i izvrsavanje

    CKutija kutija_2(12.3,34.4,56.6);  
    CKutija kutija_3;      //bez argumenata pozivamo defaultni konstruktor
    //jer je konstruktor pozvan
    double volumen_kutije =0.0; //deklaracija varijable u koju cemo spremiti izracun
        volumen_kutije = kutija_1.volumen();
    cout<<"Volumen prve kutije je : "<<volumen_kutije<<endl;
    cout<<"Volumen druge kutije je : "<<kutija_2.volumen()<<endl;
    cout<<"Volumen trece kutije ali po defaultu(konstruktoru) je : "<<kutija_3.volumen()<<endl;
    cout<<endl;


    return 0;
}

//kad izvrsite program primjetite da se konstruktor i destruktor pojavljuju
//onoliko puta koliko smo objekata stvorili ,destruktor uvijek ide iza konstruktora
//naravno i za defaultni konstruktor ide isti destruktor!!!! U ovom programu smo
//konstruktoru dodijelili defaultne vrijednosti ako se u glavnom  programu
//zatrazi volumen kutije_3.......

Nadam se da sami vidite razliku i kako smo napravili defaultni konstruktor i na koji način se on poziva u programu.
Ovi kodovi su pisani u VS-u i tamo izvršavani.Ako ove kodove pišete u Dev-u ,neke linije u cmd-u vam se neće pokazati.
Razlika je naravno u veličini VS-a i njegovim headerima ,Dev je mali IDE ali posve funkcionalan za učenje.
Kratko objašnjenje ovog programa iznad možda uslijedi kasnije jer možete i sami dio po dio koda pisati i
vjerujem da vam nakon par ponavljanja neće biti teško sve povezati!!!
Samo upornim vježbanjem možete naučiti(osnove) ili bar shvatiti c++.
Nikako tek nakon čitanja ili pisanja par programa ne možete reći da sve znate....za tako nešto
minimalnoo tisuće i tisuće linija koda morate ispisati!
_______________________________________________________________________________________________

U isti program koji sam dosad objasnio unijeti ću male promjene tako da ima i poseban naziv:
INICIJALIZACIJSKA LISTA
Za usporedbu sam i ostavio "stari program" tako da uočite razliku:

/*#include <iostream>
using namespace std;
//definicija klase u globalnom dijelu programa

class CKutija           //uobicajeni naziv(i klasa) kad se pisu knjige o c++-u
{
private:
    double visina;
    double duzina;
    double sirina;
public:
//sad nam je ovdje defaultni konstruktor ali i obicni "konstruktor"
    CKutija(double v=1.0,double s=1.0,double d=1.0)//definicija konstruktora
    {
        cout<<"Pozvani konstruktor"<<endl;
        duzina=d;
        visina = v;
        sirina = s;
    }
    ~CKutija()
    {
        cout<<"Destruktor smo pozvali"<<endl;
    }
    

    //sad ide funkcija koja izracunava volumen nase kutije
    double volumen()
    {
        return duzina * visina * sirina;
    }
};
int main()
{
    CKutija kutija_1(23.4,34.5,45.6);    //deklaracija kutije_1 ali odmah i izvrsavanje

    CKutija kutija_2(12.3,34.4,56.6);  
    CKutija kutija_3;      //bez argumenata pozivamo defaultni konstruktor
    //jer je konstruktor pozvan
    double volumen_kutije =0.0; //deklaracija varijable u koju cemo spremiti izracun
        volumen_kutije = kutija_1.volumen();
    cout<<"Volumen prve kutije je : "<<volumen_kutije<<endl;
    cout<<"Volumen druge kutije je : "<<kutija_2.volumen()<<endl;
    cout<<"Volumen trece kutije ali po defaultu(konstruktoru) je : "<<kutija_3.volumen()<<endl;
    cout<<endl;


    return 0;
}

//kad izvrsite program primjetite da se konstruktor i destruktor pojavljuju
//onoliko puta koliko smo objekata stvorili ,destruktor uvijek ide iza konstruktora
//naravno i za defaultni konstruktor ide isti destruktor!!!! U ovom programu smo
//konstruktoru dodijelili defaultne vrijednosti ako se u glavnom  programu
//zatrazi volumen kutije_3.......
*/

#include <iostream>
using namespace std;
//definicija klase u globalnom dijelu programa

class CKutija           //uobicajeni naziv(i klasa) kad se pisu knjige o c++-u
{
private:
    double visina;
    double duzina;
    double sirina;
public:
//sad nam je ovdje defaultni konstruktor ali i obicni "konstruktor"
    CKutija(double v=1.0,double s=1.0,double d=1.0):duzina(d),visina(v),sirina(s)//definicija konstruktora kao inicijalizacijska lista

    {
        cout<<"Pozvani konstruktor"<<endl;
        
    }
    ~CKutija()
    {
        cout<<"Destruktor smo pozvali"<<endl;
    }
    

    //sad ide funkcija koja izracunava volumen nase kutije
    double volumen()
    {
        return duzina * visina * sirina;
    }
};
int main()
{
    CKutija kutija_1(23.4,34.5,45.6);    //deklaracija kutije_1 ali odmah i izvrsavanje

    CKutija kutija_2(12.3,34.4,56.6);  
    CKutija kutija_3;      //bez argumenata pozivamo defaultni konstruktor
    //jer je konstruktor pozvan
    double volumen_kutije =0.0; //deklaracija varijable u koju cemo spremiti izracun
        volumen_kutije = kutija_1.volumen();
    cout<<"Volumen prve kutije je : "<<volumen_kutije<<endl;
    cout<<"Volumen druge kutije je : "<<kutija_2.volumen()<<endl;
    cout<<"Volumen trece kutije ali po defaultu(konstruktoru) je : "<<kutija_3.volumen()<<endl;
    cout<<endl;


    return 0;
}

//kad izvrsite program primjetite da se konstruktor i destruktor pojavljuju
//onoliko puta koliko smo objekata stvorili ,destruktor uvijek ide iza konstruktora
//naravno i za defaultni konstruktor ide isti destruktor!!!! U ovom programu smo
//konstruktoru dodijelili defaultne vrijednosti ako se u glavnom  programu
//zatrazi volumen kutije_3.......

U ovom dijelu programa sam uveo tu promjenu u samu deklaraciju dok je tijelo između vitičastih zagrada ostavljeno za
ispis cout.

 CKutija(double v=1.0,double s=1.0,double d=1.0): duzina(d),visina(v),sirina(s)
//definicija konstruktora kao inicijalizacijska lista,primjetite dvotocku i kako se pridruzuju varijable!!!!

    {
        cout<<"Pozvani konstruktor"<<endl;      //u "tijelu " konstruktora nam je ostao samo ispis
        
    }

Primjetite i usporedite s prijašnjim programom i uočite kako se piše inicjializacijska lista!
Ovakav oblik postavljanja podataka često se koristi pa je bilo poželjno da o njemu nešto i kažem.
________________________________________________________________________________