C++ tutorijali...

http://www.geekinterview.com/question_details/30963

Svake pohvale onima koji su pisali sve ove tutove!

No, imam jedno pitanje. Mogu li se u Win32 CA programima pisati hrvatska slova? Vidio sam negdje da se moraju pisati ASCII znakovi, no ja ne znam kako 

Imam 1 lako pitanje (al meni je teško), kako napravit npr. pritiskom tipke "+" (mislim na onu iz tipkovnice) da se aktivira recimo button5?

class template  : malo o tome



Evo nakon poduže vremena .
Vidim da je kolega krenuo s template(predlošcima) klasa.Ja ću se samo nadovezati na temu i naravno svi mogu dodati ili me ispravljati!
Prije nego krenete s čitanjem u ovom postu molim ponovite (negdje na sredini) o predlošcima funkcja koje sam napisao ovdje na forumu
tj. na ovim tutovima.

Prvo općenito:
Sintaksa class tmplate je slijedeća:

template<class T> deklaracija
-pod onim deklaracija može stajati deklaracija klase ili funkcije,parametar T(ili argument T,ovisi kako tko piše) se zamjenjuje s stvarnim tipom koji
upotrebljavamo ili koji želimo u programu kasnije.
Znači ovom sintaksom smo stvorili predložak klase koju ćemo koristiti na slijedeći način:

naziv_predloška<tip>
ili :

predložak<argumenti> deklaracije
Naravno,sve između <> tih zagrada je naš tip T koji zamjenjujemo s onim tipom koji nam treba u programu.

Stoga sintaksa samo za jedan parametar je :

template<class T>
class ime_klase
{
    deklaracija
};
Naravno ,T se može koristiti i u deklaracijama s time da se zamjenjuje tipom koji odgovara trenutnom pozivu(int ili double ili naziv klase).
Evo samo jednostavan primjer kako napisati predložak:

template<class T>
class P
  {
      T a,b;
   };

...i sad da bi je koristili navodimo ime naše klase a to je P i u uglato-oštrim  zagradama navedemo tip umjesto T  :

   P<int>
   P<double>
...na taj način T je ili int ili double a sadrži znači a i b tog tipa.
To je bio samo početak o ovoj temi jer sad idemo malo kompliciranije .
Ovdje niže dolje je predložak klase koju ćemo upotrijebiti u glavnom programu nakon što malo i ovo objasnim
ali malo kasnije kad stignem:

template <class T> class CPrimjer

{
public:
    //konstruktori
    CPrimjer(const T vrijednosti[],int brojac);
    CPrimjer(const T& vrijednost);
    CPrimjer()
    {
        m_P=0;
    }
    bool Zbr(const T& vrijednost);
    T Max() const;
private:
    T m_Vrijednosti[100];
    int m_P;
};
//sad konstruktori
//______________________________________________
template <class T> CPrimjer<T>::CPrimjer(const T vrijednosti[],int brojac)
{
    m_P = brojac<100?brojac:100;
    for(int x = 0;x<m_P;x++)
        m_Vrijednosti[x] = vrijednosti[x];
}
//**********************************************

template <class T> CPrimjer<T>::CPrimjer(const T& vrijednost)
{
    m_Vrijednosti = vrijednost;
    m_P=1;
}
//______________________________________________
template<class T> bool CPrimjer<T>::Zbr(const T& vrijednost)
{
    bool OK = m_P < 100;
    if(OK)
        m_Vrijednost[m_P++] = vrijednost;
    return OK;
}
//********************************************

template<class T> T CPrimjer<T>::Max()const
{
    T tMax= m_P ?m_Vrijednosti[0] : 0;
    for(int x = 1; x<m_P;x++)
        if(m_Vrijednosti[x]>tMax)
            tMax =m_Vrijednosti[x];
    return tMax;
}
//_______________________________________________

Ali prije nego krenem u opsežno objašnjavanje gore navedenog primjera samo jednostavan program koji pokazuje najednostavniju primjenu
predloška klase gdje je vaša jedina dužnost da samo mijenjate tip koji se koristi kad formirate klase.Proučite ga i vidite sličnost
s predlošcima funkcija koje sam prije obradio:

#include <iostream>
using namespace std;
//OVDJE NAM JE JEDAN PREDLOŽAK KOJI ĆEMO KORISTIT ZA TRI TIPA KAO DA IMAMO TRI KLASE!
template<class T>
class Templ
{
public:
    T a,b ,c;


};
int main()
{
    Templ<int> klas;
    klas.a;
    Templ<double> bklas;
    bklas.a;
    Templ<float> cklas;
    cklas.a;
    return 0;
}
Sad recimo prvi primjer int tipa c++ prevodioc ovako to sebi prikaže:


class Templ<int>              //ovdje je <class T> znaci zamijenjeno
                              //s tipom int i imamo klasu s tipom int

{
    int a,b,c;
};

Sad vidite da po predlošku klase s početka programa(koda) prije int main() možemo napaviti klasu s tri različita tipa
a ne moramo je tri puta pisati!!!!Eto to je najjednostavniji prikaz kako se predložak klase može koristiti....nastavljamo s
kompliciranijim programom.Naravno ne kompliciram s objašnjenjem jer je bit da shvatite kako predložak sam po sebi ima svrhu.
Također ,predlošci klasa mogu imati i svoje parametre a njihov općeniti oblik je :

template <parametar,parametar......parametar> definicija(ili deklaracija) klase čiji predložak radimo

Znači ti parametri su forma koja se popunjava realnim argumentima u trenutku izvršavanja programa......parametri mogu biti
tipovi ugrađeni u c++ ili konstante.U programu kao i kod funkcija moramo poštivati sve navedene parametre.

Sad ćemo se vratiti malo na onaj kompliciraniji dio i naravno opet jedan uvod o predlošcima jer od viška glava ne boli.
(ali kad stignem).

class template -    nije samo po sebi klasa ,ona je više kao primatelj klase koju kada kompajler generira kod za klasu.
U primjeru koji slijedi želimo klasu (predložak) koja može primiti više podataka različite vrste da se tako izrazim.
A svaka klasa mora imati funkciju koja izračunava maksimalnu vrijednost iz podataka.
Na temelju toga što sam spomenuo mi ćemo napraviti predložak klase CPrimjer.
T nam je sve prisutan jer on je bitan pri kopajliranju i izvršavanju koda za različite klase koje će se koristiti našim ppredloškom.
Naravno ne zaboravite na prije spomenute ključne riječi i oblik kako se piše predložak!

Napominjem da ponovite prijenos po adresi i vrijednosti u na ovim stranicama prije ,jer se "tip" T mora zamijeniti sa stavrnom vrijednošću u programu da bi
mogli raditi s vrijednostima koje su stavrne.Ovo ćete razumjeti ako pročitate postove prije ovoga u tutorijalu.

template <class T> class CPrimjer

{
public:
    //konstruktori 
    CPrimjer(const T vrijednosti[],int brojac);  //deklaracija konstruktora koji prima "array" s podacima
    CPrimjer(const T& vrijednost);             //koji prima pojedinačnu vrijednost
    CPrimjer()                               //defaultni konstruktor(podupire stavranje praznog objekta-bez podataka)
    {
        m_P=0;
    }

//deklaracije funkcija

    bool Zbr(const T& vrijednost);
    T Max() const;
private:
    T m_Vrijednosti[100];     //"Array" za podatke
    int m_P;                   //pokazatelj (index ) za našu slobodnu lokaciju
};
//sad konstruktori
//i njihove definicije znači tijela
//______________________________________________
template <class T> CPrimjer<T>::CPrimjer(const T vrijednosti[],int brojac)
{
    m_P = brojac<100?brojac:100;
    for(int x = 0;x<m_P;x++)
        m_Vrijednosti[x] = vrijednosti[x];
}
//**********************************************

template <class T> CPrimjer<T>::CPrimjer(const T& vrijednost)
{
    m_Vrijednosti = vrijednost;
    m_P=1;
}
//______________________________________________
//ako je mjesto prazno stavi u njega vrijednost

template<class T> bool CPrimjer<T>::Zbr(const T& vrijednost)
{
    bool OK = m_P < 100;
    if(OK)
        m_Vrijednost[m_P++] = vrijednost;
    return OK;
}
//********************************************
//funkcija koja provherava sve vrijednosti i nalazi najveću!!!

template<class T> T CPrimjer<T>::Max()const
{
    T tMax= m_P ?m_Vrijednosti[0] : 0;
    for(int x = 1; x<m_P;x++)
        if(m_Vrijednosti[x]>tMax)
            tMax =m_Vrijednosti[x];
    return tMax;
}
//_______________________________________________

Ovo je znači predložak koji ćemo upotrijebiti za neke klase u programima koje se međusobno razlikuju po
tipovima podataka,broju podataka  ili uopće nemaju podataka...uviđate već sad prednosti predloška klasa?
Ne moramo pisati svaki put novu klasu s tipom koji nam treba za izračun ...imamo predložak i njega koristimo
s različitim klasama tj.njega koriste različite klase.Sad kad ste sve ovo dosad proučili možemo i dalje.
Ja se trudim ne komplicirati previše jer želja mi je shvatiti bit predloška klase ,a sama upotrebljivost koda ide na vašu odgovornost.
Naravno ispričavam se i znalcima c++-a ako isuviše pojednostavljujem.
Svi ste tu i da me ispravite i dopunite......
Prelazimo na glavni program u kojem ćemo i upotrijebiti naš predložak klase(ali kasnije opet):

___________________________________________________________________________

Mala samo digresija:
Stvaranje objekta iz class template

Da bi kreirali objekat baziran na predlošku klase morate uvijek navesti tip između <> koji naravno slijedi nakon imena klase.

CPrimjer<double>moji_podaci(24.9);

Znači ovako stavramo objekat tipa double ,moji_podaci,u koji sad možemo spremiti vrijednost tipa double.

____________________________________________________________________________

Sad naravno čitav program pa dio po dio objasnim,naravno možete ga i vi sami proučavati
i ako ste dosad sve lijepo pratili ne bi vam trebalo biti teško razumjeti .
Evo kod:

#include<iostream>
using namespace std;

class CKutija
{
public:
    //Definicija kostruktora
    CKutija(double v = 1.0,double s = 1.0,double d = 1.0):visina(v)
    {
        duzina = d > s ? d: s;
        sirina = s < d ? s : d;
    }
    double Volumen() const
    {
        return duzina * visina * sirina;
    }
    int CKutija::operator>(const CKutija &aKutija)const
    {
        return this->Volumen() > aKutija.Volumen();

    }
    int operator>(const double &vrijednost)const
    {
        return Volumen()> vrijednost;
    }
    CKutija operator+(const CKutija &aKutija)const
    {
        return CKutija(duzina > aKutija.duzina?duzina:aKutija.duzina,
            sirina > aKutija.sirina?sirina:aKutija.sirina,
            visina + aKutija.visina);
    }
    void PokaziKutiju() const
    {
        cout<<duzina<<" "
            <<sirina<<" "
            <<visina<<endl;
    }


private:
    double sirina;
    double visina;
    double duzina;
    };
int operator>(const double &vrijednost,const CKutija &aKutija);
//**********************************************************
template <class T> class CPrimjer

{
public:
    //konstruktori samo njihove deklaracije
    CPrimjer(const T vrijednosti[],int brojac);
    CPrimjer(const T& vrijednost);
    CPrimjer()
    {
        m_P=0;
    }
    bool Zbr(const T& vrijednost);
    T Max() const;
private:
    T m_Vrijednosti[100];
    int m_P;
};
//sad konstruktori i funkcije i njhove definicije i ponovite
//ranije u tutorijalu razdvajanje definicije i deklaracije 
//______________________________________________
template <class T> CPrimjer<T>::CPrimjer(const T vrijednosti[],int brojac)
{
    m_P = brojac<100?brojac:100;
    for(int x = 0;x<m_P;x++)
        m_Vrijednosti[x] = vrijednosti[x];
}
//**********************************************

template <class T> CPrimjer<T>::CPrimjer(const T& vrijednost)
{
    m_Vrijednosti = vrijednost;
    m_P=1;
}
//______________________________________________
template<class T> bool CPrimjer<T>::Zbr(const T& vrijednost)
{
    bool OK = m_P < 100;
    if(OK)
        m_Vrijednost[m_P++] = vrijednost;
    return OK;
}
//********************************************

template<class T> T CPrimjer<T>::Max()const   
{
    T tMax= m_P ?m_Vrijednosti[0] : 0;
    for(int x = 1; x<m_P;x++)
        if(m_Vrijednosti[x]>tMax)
            tMax =m_Vrijednosti[x];
    return tMax;
}
//_______________________________________________



int main()
{
    //OVDJE KORISTIMO SAMO KLASU CKutija
    CKutija mala(4.0,2.0,1.0);
    CKutija srednja(10.0,4.0,3.0);
    CKutija aKutija;
    CKutija bKutija;

    aKutija = mala + srednja;
    cout<<"Velicina aKutije je : ";
    aKutija.PokaziKutiju();

    bKutija  = aKutija + mala + srednja ;
    cout<<"bKutija je velika  : ";
    bKutija.PokaziKutiju();
    //TEK SAD U OVOM KODU ISPOD KORISTIMO PREDLOZAK KLASE
    cout<<"**********************************************"<<endl;
CKutija kutije[] =
{
    CKutija(7.0,4.8,3.0),
    CKutija(5.8,4.0,3.0),
    CKutija (3.0,5.0,3.0)
};
CPrimjer<CKutija> mojeKutije(kutije,sizeof kutije/sizeof CKutija);
CKutija najKutija = mojeKutije.Max();
cout<<"Najveca od kutija ima volumen : ";
cout<<najKutija.Volumen()<<endl;
    return 0;
}
Čitav ovaj kod je pisan u Visual Studiu kao Empty Project i Add cpp file na source file u Solution Exploreru....ako kome ovo nije jasno objasnim kako raditi u VS-u
iz praznog projekta.
Kod izvršavanja programa ,kompajler kreira instancu predloška za funkciju koju mi pozivamo u programu ..a to je naravno Max() funkcija.
U biti mislim da sam dosta rekao o predlošcima klasa i na vama je samo da dio po dio koda analizirate i ako ste dosad
prošli sve u tutorijalu ,neće vam biti teško ovdje sve dio po dio prolaziti.Sami prođite redak po redak koda i sve vam mora biti jasno.
Samo upornim ponavljanjem i pisanjem koda možete svladati C++ ili bilo koji drugi programski jezik.To znači puno sati vježbanja i učenja.
Ako pri prvom prolasku ne razumjete pojedine dijelove ,samo upornim vježbanjem čete i to svladati,nisam ni ja drugačije učio.
Naravno ,ako baš zapnete ima autora na ovom tutu koji osim mene mogu pomoći a vjerujem i na ovom forumu.
______________________________________________________________________________________________________

//evo sam taj primjer tj. rekruzivnu funkciju objasnti ću na primjeru Fibonaccijevog niza
/*  FIBONACCI NIZ*/
/*To je niz brojeva kod kojih je svaki slijedeći broj u nizui jedank zbroju dvaju prethodnih:
      0,1,1,2,3,5,8,13......idt:
   Opća formula je :   F(n+1) = F(n) + F(n-1)
   ili :
   F(i) = F(i-1) + F(i-2) ...sve to je već davno napisano...samo ponavljam */  
 //************************************************************************


   #include <iostream>
   using namespace std;
   long fibonacci(long);
   int main()
   {
       //Ovdje postavljamo da zelimo niz od deset fibonacci brojeva
       for(int brojac =0;brojac<=10;brojac++)
       cout<<"Fibonacci ("<< brojac << ") ="
       <<fibonacci(brojac)<<endl;
      // cout<<"Fibonacci (11) :" <<fibonacci(11)<<endl;//ovo u zagradi je jedanaesti zbroj znači i dalje smo je pozvali
        //cout<<"Fibonacci (30) :" <<fibonacci(30)<<endl;//ovo je trideseti zbroj
       system("pause");
       return 0;
       }
       long fibonacci(long broj)
       {
            if((broj == 0) || (broj == 1))
            return broj;
            else
            return fibonacci(broj -1)+ fibonacci(broj -2);
            }
                                 
//znaci mi smo sad prikazali niz od deset fibonacci brojeva
//pomoću for petlje smo je pozvali deset puta da nam to izračuna
//u if uvjetu nam je ako je nula pocni s nulom a tako i s jedinicom(vrati broj)
//to ti je kad kompajlaš ona prva dva broja
//dalje se primjenjuje iza else uvjeta sve,znači (2-1) + (2-2) = 1
//tako dobiješ 0,1,1
//dalje probaj sam.....(3-1) + (3-2) = 3....itd i tako deset puta pozivaš funkciju
//znači unutar for petlje ona samu sebe poziva deset puta.
//znači rekurzivna funkcija dok se ne ispuni for petlja uvjet.

//zbriši komentare s fibonacci(30)

//sad vidiš logiku rekurzivne funkcije

//još koji program napišem za rekruzivnu funkciju.

Ako još nije jasno javi jer na sličnom principu radi i kod funkcije koji si naveo u pitanju samo ima više redaka ali princip je isti.

#include <cstdlib>
#include <iostream>
using namespace std;
double funk_racun(double x,int n);
int main()
{
    double x = 2.0;
    
    for(int pokazatelj = 0;pokazatelj<=3;pokazatelj++) //ovdje sam uveo samo pozitivne brojeve      
    {
      cout<<x<<"\t na  "<<pokazatelj<<" je "
      <<funk_racun(x,pokazatelj)// ,a ispis takav zbog petlje koja
      //kreće od nule (to je int n ).
      <<endl<<endl;
      }  
    system("PAUSE");
    return 0;
}
double funk_racun(double x,int n)              //unutar funkcije dva tipa koja pošticamo u programu
{
  if(n<0)                                //ponovite if-else
  {
    x=1.0/x;
    n= -n;
  }
  if(n>0)
  {
  return x * funk_racun(x,n-1);// x je stalno tri a n je pokazatelj
  }
  else
  return 1.0;
}
//....zatim ako je n>0 a to je tri oduzmi jedan i to je dva na drugu
//pa onda dva na prvu i na kraju dva na nulu.Ali petlja je do tri i tako i na treću
//u for petlji možeš napisati i umjesto tri  broj četiri pa dobiješ dva na četvrtu i tako dalje......
//ono n-1 je zato da bi došla do kraja.

Malo sam izmjenio kod  pa probaj sad sve ponoviti i točno mi reci koji baš dio ne razumiješ
ili baš funkciju ne razumiješ pa ću ponoviti još detaljnije sve kad budem imao više vremena.
Dva if uvjeta su samo zato da nam kažu ako je negativan idi tako ,a ako je pozitivan idi opet ....

Sad u ovom kodu koji sam ti dao probaj ovo:

/*if(n<0)                                //ponovite if-else
  {
    x=1.0/x;
    n= -n;
  }*/

Znači staviti komentar,ali sad možeš samo pozitivne brojeve pisati!


Evo značenje n-1......opet sam malo promijenio kod da vidiš što znači n-1......a one nule je zato što sam izostavio x i nema množenja!(pogledaj ispis i usporedi)

#include <cstdlib>
#include <iostream>
using namespace std;
double funk_racun(int n);  //ovdje sam izvršio promjene
int main()
{
    double x = 2.0;
    
    for(int pokazatelj = 0;pokazatelj<=3;pokazatelj++) //ovdje sam uveo samo pozitivne brojeve      
    {
      cout<<x<<"\t na  "<<pokazatelj<<" je "
      <<funk_racun(pokazatelj)// ,a ispis takav zbog petlje koja
      //kreće od nule (to je int n ).
      <<endl<<endl;
      }  
    system("PAUSE");
    return 0;
}
double funk_racun(int n)              //unutar funkcije dva tipa koja pošticamo u programu
{
       double x;
  /*if(n<0)                                //ponovite if-else
  {
    x=1.0/x;
    n= -n;
  }*/
  if(n>0)
  {
  return x * funk_racun(n-1);// x je stalno tri a n je pokazatelj
  }
else
  return 1.0;
}
Eto ,još budem ako treba.

#include <iostream>

using namespace std;
int funkcija(int x,int n);

int main()
{
    int x=2;
    int n;
    cout<<"X je broj dva"<<endl;
cout<<"Unesite n : " <<endl;
  cin>>n;
   cout<<endl;
   
   
   cout<<"X na n-1 je :"<<funkcija(x,n);
   
   cout<<endl;
   
    
    system("PAUSE");
    return 0;
}
int funkcija(int x,int n)
{
    
    cout<<n<<" ";//ispiši trenutnu vrijednost koju uneseš
    cout<<endl;
    if (n==1)  //ovo je uvjet završetka rekurzije
    return 1;
    else
    return x*funkcija(x,n-1); //pozivaš funkciju za n-1 ali množiš s x   (ponovo pozovi)
    cout<<endl;
     //ponovno zvanje funkcije s argumentom n-1
}
...pzivaš funkciju ali množiš s n-1!
Tako i u onom kodu ,množiš samo s n-1.
Kod funkcija da bi se pozivale moraju biti poštivani parametri s argumentima .
Napravim post samo s detaljnim objašnjenjem rekurzije.

#include <iostream>
#include<iomanip>                //zbog setw()
using namespace std;
unsigned long factorial(unsigned long);
int main()
{
    //faktorial od 0 do 10
    for(int y =0;y<=10;y++)
    cout<<setw(2)<<y <<" : "<<factorial(y)<<endl; //znaci ovje funkcija se vrti za svekai broj
    //ako je tri naprimjer tad ide zbog n-1 ....3*(3-1)*(3-2)=6
    //i tako sve do deset
 
    system("PAUSE");
    return 0;
}
unsigned long factorial(unsigned long  x)
{
         if(x<=1)     //uvjet  koji također kaže dok ne dođes do jedan
         return 1;
         else         // ovo je korak rekurzije
         return x*factorial(x-1);   pomnoži x s x-1 i pozivaj dok ne ispunis prvi uvjet!
 }
 
//***********************************************************
/*Sama rekurzija se izvršava od :
     10!
     10=9!
     9 =8!...i tako do
     1
     a povrat(rekurzija)
     ako je jedan vrati
     ako je dva vrati u funkciju i pmnoži s slijedećim
     sad se poveća za jedan i opet vrati u funkciju
     i tako do 10.
     To je zbog petlje koja kreće od jedan tj od nule.
     znači ako je nula tad je jedan
     ako je jedan = jedan;
     sad taj jedan return i
     2*1 = 1*2 = 2;
     sad taj dva return;
     3= 3*2 = 6
     sad taj 6 return;
     4*6 = 24
     sad taj 24 return;
     5 * 24 = 120
     i tako do deset kako piše u petlji.
 Rkurzivne funkcije su funkcije koje uvijek imaju neki uvjet .
 Sad sve ponovite dio po dio i nadam se da je bar malo jasnije što se tiče
 rekurzije.*/
    

#include <iostream>
#include<iomanip>                //zbog setw()
using namespace std;
unsigned long factorial(unsigned long);
int main()
{
    //faktorial od 0 do 10
    for(int y =0;y<=10;y++)
    cout<<setw(2)<<y <<" : "<<factorial(y)<<endl;    
    system("PAUSE");
    return 0;
}
unsigned long factorial(unsigned long  x)
{
        unsigned long rezultat=1;
        for(unsigned long a= x;a>=1;a--)   //do se ne dođe do jedan a ovdje ne poziva samu sebe
        rezultat = rezultat * a;          //vec je u petlji koja se vrti do jedan
        return rezultat;
        }
        
  //Znači općenita formula faktorijala je:
    //    n * (n-1) * (n-2)....1
      //  tj.
        //faktorijal od 5=5*(5-1)*(5-2)*(5-3)....i tako do kraja =120 je rezultat za faktorijal od 5!      

....ako zapneš bilo gdje pošalji problem(postaj) i pokušat ću odgovoriti...naravno kad imam vremena....
...nadam se da nečeš odustati.

Rekurzija se izvršava duplo više puta nego programska petlja. Razlog je u tome što svaki put kad se rekurzija izvrši međustanja tog poziva se stavljaju na Stog, a zatim kad dođe kraj izvršavanja onda se ta međustanja počinju skidati sa Stog-a. Kolega je to prethodno dobro demonstrirao primjerom.

U pravilu, rekurzijom se dobije kraći programski kod, ali optimizacija algoritma je u najčešćem slučaju loša, a pogotovo zbog njegove asimptotske složenosti. Isto tako, svaka rekurzija se može pretvoriti u ne-rekurziju i obrnuto, a za to treba slijediti čak 13 striktnih pravila ;)

Dosad svaka čast svima koji su se pridružili  u pisanju ovih tutorijala jer  vrijeme je dragocjeno i svaki napisani tut je veliki trud i znanje od svakoga za sve one koji počinju učiti c++.
Ja jednostavno mogu samo reći hvala jer dobra volja i želja za pomoći je u svima koji ste se pridružili.
Što se tiče tuta još ima par postova koje bi želio staviti.
Uporedo s njima kad budem imao vremena pisati ću i C++/CLI .Net okruženju ali uglavnom početke ....
Ovi tutorijali po mom mišljenju pružaju dobar uvid u C++ ili bar pružaju uvid u njega da bi mogli shvatiti sintaksu, i dalje možete
sami jer ako ste ih dobro prošli tad ste počeli razumijevati c++.
Što se tiče  C++/CLI je proširenje ISO/ANSI C++ jezika i uključuje .Net okruženje i stoga da bi učili u tom obliku
morate koristiti VS 2005 Express Edition minimalno koji je besplatan.Još jednom hvala savim autorima!

friend class

Evo kao što je i u naslovu  dotaknut ću se friend class deklaracije...što znači da čitavu klasu
možemo proglasiti kao prijatelja klase i na taj način joj omogućavamo pristup podacima koji se nalaze u klasi
koja nam je prijatelj.Lakše ćete kroz primjer naučiti a naravno s ovim postom ću početi i govoriti(pisati) o samom
pojmu polimorfizma u C++-u koji obuhvaća virtulane funkcije i abstraktne klase.naravno da bi posve razumjeli
ono o čemu ću pisati molim ponovite sve dosad što sam napisao o klasama i OOP u C++-u na ovim stranicama.

Ali prvo friend class kao jedna mala ali bitna digresija:

#include <iostream>
using namespace std;

class A
{
  int a, b;
  friend class B;       //ovdje  deklariramo prijatelj klasu
public:
  A() : a(5), b(10) { }//konstruktor

};

class B           //naravno a ovdje je definicija te prijatelj klase
{
public:
  void ispisi(A& x) {
      cout << "a je :" << x.a << endl;            //pristupamo clanovima klase A jer smo prijatelji
    cout << "b je : " << x.b << endl;
  }

};

int main()
{
  A xobj;
  B friend_obj;
  friend_obj.ispisi(xobj);
  return 0;
}
//Mozete deklarirati cijelu klasu kao prijatelja.
//Ovdje smo nacinili da je klasa B prijatelj klase A.
//To znaci da svaki clan funkcije i staticka varijabla definicije u B klasi
//ima pristup podacima u A klasi.
//
//U ovom primjeru to su  svi clanovi B klase,
// friend class B ima clanicu funkciju ispisi koja pristupa privatnim clanovima a i b
//od class A

//znaci da ide prvo deklaracija nase prijatelj klase i onda definicija

Primjetite da nisam naveo private:   dio u klasi A jer ako ne navedete ništa po defaultu je private.
To svakako napominjem i to upamtite jer kad se radi o naslijeđivanju među klasama ,vrlo je bitno
što će klasa naslijediti,kao public ili private dio od osnovne klase ali o tome kasnije.
Sad malo proučavajte ovaj primjer pa ćemo na slijedeći i naravno zaključak o friend class.
Eto to će biti u ovom postu.
Da nastavimo,vidim i zahvaljujem kolegi Tracer-u jer nije sve ograničeno na klase nego i na funkcije
kao prijatelje ,posvetiti ću i tome par redaka na kraju.
Sad u ovom primjeru koji možete nadovezati na ovaj primjer prije a i na primjer niže od kolege :

#include <iostream>
using namespace std;

class A;        //obvezatno deklaracije klasa prije definicije

class B {       //također samo deklaracija
public:
  void ispis(A& x);
};
// i sad slijede definicije u kojima sve kombiniramo
class A {
  int a, b;
  friend void B::ispis(A& x);    //a ovdje smo znači samo funkciju proglasili prijateljem i naravno naveli iz koje klase
public:
  A() : a(5), b(10) { }
};

void B::ispis(A& x) {
    cout << "a je : " << x.a << endl;   //ovdje je definicija funkcije ispis, i naravno :: te dvotočke nam govore kojoj klasi
    cout << "b is : "<< x.b << endl;     //funkcija pripada  !!!!!!!!! :: dvotočke su mjesto razriješenja ovlasti (pripadnosti)!
}

int main() {
  A x_obj;
  B b_obj;
  b_obj.ispis(x_obj);
}

Vidite da je definicija funkcije van svih klasa i njihovih definicija ali je funkcija pripadnik
klase B i tu smo funkciju prograsili kao prijatelj klase A i omogućili pristup članovima klase A
Znači samo funkcija  koja pripada klasi B ima pristup članovima klase A.
Nisam navodio private: jer sam prije rekao razlog i naravno nisam napisao system("pause") jer radim u VS-u.
Vi to dodajte ako radite u Dev-u.
Prijateljstvo se ne naslijeđuje!Ako je neka funkcija prijatelj klase A ,a klasa C je izvedena iz klase A
tad ta funkcija(nekog imena) nije prijatelj te klase C osim ako vi unutar klase C ne upotrijebite friend deklaraciju.

Ako je klasa B prijatelj klasi A,a klasa C  prijatelj klasi B,tad klasa C nije automatski prijatelj klasi A.
Vi opet to morate navesti unutar klase deklaracijom friend ako to želite,ovo znači da se prijateljsto automatski ne prenosi
na klasu a nema veze s naslijeđivanjem.
Ako se radi i o naslijeđivanju opet vrijedi da se prijateljstvo ne naslijeđuje!!!!
Same funkcije koje su prijatelji neke klase mogu biti i globalne a ne pripadnice neke klase!
Sad malo proučavajte.

___________________________________________________________________________

virtual function

Virtualne Funkcije

Evo kako i sam naslov govori počinjem s virtualnim funkcijama ali prvo ćemo
napraviti jedan program koji sadrzi klasu iz koje smo napravili drugu klasu koja je naslijedila prvu klasu.
Prva klasa je tkz "Base class" a druga klasa je  "Derived class".....znači bazna klasa i ona koja je izvedena iz nje.
Koristiti će funkciju iz bazne klase.......to ćemo pokazati u ovom primjeru koji slijedi.
Sad ,kad vi želite da klasa ima funkciju iz bazne klase imenom PokaziVolumen a zelite da
derived class ima istu funkciju s istim imenom a različitom funkcijom kad je pozovete što znači
da pozivate kao da pozivate PokaziVolumen iz prve klase (Base) a ona se izvršava na novi način tj.
na način koji ste joj odredili u Derived class tad morate primjeniti klučnu riječ virtual .
Takav način pisanja funkcije tj. taj mali fenomen se zove polimorfizam  naravno to je
dio OOP c++-a!
Ovo sve ćete bolje razumjeti kroz programe koji slijede i naravno još objašnjenja.To sam samo dodirnuo
ukratko i kad budete čitali i kombinirali s programima i uporno vježbali vidjeti ćete da je lagano.

Ja sam radio u VS-u i princip je isti kao i kod Dev-a.Stvarate heder file-ove i cpp-filove i na kraju glavni(main) file
u kojem izvršavate program.Ako budete izrazili želju da vam detaljno sve prikazem slikama korsk po korak
to mi recite tj. pošaljite odgovor o toj želji:

Sad prvo Kutija.h:

#pragma once

class CKutija
{
public:
    CKutija(double,double,double);
    ~CKutija(void);
    void PokaziVolumen(void)const;
    double Volumen(void)const;
protected:
    double Duzina;
    double Visina;
    double Sirina;
};

Zatim Kutija.cpp

#include <iostream>
using namespace std;
CKutija::CKutija(double v=1.0,double d=1.0,double s=1.0):
 Duzina(d)
, Visina(v)
, Sirina(s)
{
}

CKutija::~CKutija()
{
}

void CKutija::PokaziVolumen() const
{
    cout<<"Volumen od Kutije je :"<<Volumen()<<endl;
}

double CKutija::Volumen()const
{
    return Duzina*Visina*Sirina;
}

Sad druga klasa.
KartonKutija.h:

#pragma once
#include "Kutija.h"
class CKartonKutija:public CKutija   //ovdje vidite naslijedjivanje
{
public:
    CKartonKutija(double,double,double);
    ~CKartonKutija();
    double Volumen(void)const;
protected:
    double Visina;
    double Duzina;
    double Sirina;
};
....sad KartonKutija.cpp:

#include "KartonKutija.h"

CKartonKutija::CKartonKutija(double v=1.0,double s=1.0,double d=1.0):
 CKutija(v,s,d)
{
}

CKartonKutija::~CKartonKutija()
{
}

double CKartonKutija::Volumen() const
{
    return 0.50*Duzina*Visina*Sirina;    //nasa posebna funkcija
}

...i sad glavni program:
glavni.cpp:

#include <iostream>
#include "KartonKutija.h"
using namespace std;
int main()
{
    CKutija m_Kutija(3.9,4.7,4.0);
    CKartonKutija m_KartonKutija(3.9,4.7,4.0);
    m_Kutija.PokaziVolumen();
    m_KartonKutija.PokaziVolumen();
    cout<<endl;
    return 0;
}

...evo koda i kad ga izvršite vidjet ćete da dolazi do korištenja funkcije iz Base class jer
nismo sad upotrijebili virtual ali u ispravci (ima još jedna greška u kodu koju ću slijedeći put objasniti ,a pokušajte je i vi naći)
hoćemo i sad već lakše razumijete zašto virtual...zato da program
zna koju funkciju hoćemo pozivajući je kao da pozivamo funkciju iz Base class a u biti se radi o Derived class funkciji.
Nastavljamo kad budem mogao.Imate dosta zasad.
Evo sad ću ovaj kod samo malo izmjeniti a vi svakako to proučite i obratite pažnju gdje i kako sam
primjenio ključnu riječ virtual:  

Kutija.h :

#pragma once

class CKutija
{
public:
    CKutija(double,double,double);
    ~CKutija(void);
    void PokaziVolumen(void)const;
    virtual double Volumen()const;  //takodjer i ovdje moramo dati do znanja
    //da postoje dvije funkcije i kljucna rijec nam je virtual
protected:
    double Duzina;
    double Visina;
    double Sirina;
};

Kutija.cpp

#include "Kutija.h"
#include <iostream>
using namespace std;
CKutija::CKutija(double v=1.0,double d=1.0,double s=1.0):
 Duzina(d)
, Visina(v)
, Sirina(s)
{
}

CKutija::~CKutija()
{
}

void CKutija::PokaziVolumen() const
{
    cout<<"Volumen od Kutije je :"<<Volumen()<<endl;
}

double CKutija::Volumen() virtual const
{
    return Duzina*Visina*Sirina;
}

KutijaKarton.h:

#pragma once
#include "Kutija.h"
class CKartonKutija:public CKutija //naslijedila je cijelu CKutija klasu
{//probjate staviti private ili protected umjesto public i pogledajte
    //sto ce se dogoditi?

public:
    CKartonKutija(double,double,double);
    ~CKartonKutija();
    virtual double Volumen()const;  //vlastita funkcija
    //ovo nam ne treba jer ova klasa naslijedjuje sve od Base class CKutija
//protected:
//    double Visina;
//    double Duzina;
//    double Sirina;
};
//#pragma once vam je umjesto #ifndef i #define i na kraju #endif
//mislim da sam to vec negdje na ovim stranicama objasnjavao pa ponovite

KutijaKarton.cpp:

#include "KartonKutija.h"

CKartonKutija::CKartonKutija(double v=1.0,double s=1.0,double d=1.0):
 CKutija(v,s,d)
{
}

CKartonKutija::~CKartonKutija()
{
}

  double CKartonKutija::Volumen()virtual const
{
    return 2*Duzina*Visina*Sirina;   //ovdje sam samo sve pomnozio s dva
}                                    //i eto vam vlastite funkcije za CKartonKutija klasu

glavni.cpp:

#include <iostream>
#include "KartonKutija.h"
using namespace std;
int main()
{
    CKutija m_Kutija(2.0,3.0,4.0);
    CKartonKutija m_KartonKutija(2.0,3.0,4.0);
    m_Kutija.PokaziVolumen();      //u programu pozivamo kao prvu funkciju
    m_KartonKutija.PokaziVolumen(); //ima isto ime eto nam poziva virtualne funk.
    cout<<endl;
    return 0;
}
//to je primjer polimofirzma u OOP-u
Vi s deklaracijom virtualne funkcije u Base klasi dajete do znanja prevodiocu da postoji neka druga funkcija
koju mora primjeniti a ne svoju originalnu,a ta druga se nalazi u izvedenoj(klasi koja naslijedjuje) klasi naravno
s ključnom riječi virtual.A način na koji ste pozvali i dali do znanja da se radi o virtualnoj funkciji je naravno
stavranje objekta (instance) koji vodi do naše Derived klase.
Takovo povezivanje (linkanje) funkcije pri prevodjenju s virtualnim funkcijama je tkz. dynamic linkage za razliku od
prvog primjera koda bez virtual mehanizma koji onda nosi naziv static linkage   .
Znači,da bi se sama funkcija ponašala kao virtalna moramo znači imati isto ime,parametre,i return tip i ako je const
mora biti i u Derived klasi const.....znaci sve mora biti isto!!!!    
Isto ime a različito ponašanje...kao jedan film u kojem netko ima ulogu dvostruke ličnosti-polimorfizam.

Dolje niže ću vam samo malo slika dati kako to izgleda u VS-u
a slično mora izgledati i u Dev-u.
U VS-u : file -new project(pod general) ->empty (i date ime)....zatim na ...header i desni klik i dodajete(add) header file(narvno jezik je c++ pri odabiru)
Na isti način vi dodajete i na source file ali ovaj put cpp file i nakraju naravno glavni.cpp.
Visual studio generira više od pola koda za vas a vi samo dodajete to treba.U Dev-u sve morate malo sami....ponovite
kako sam to radio na ovim stranicama (potražite) ...razdvajanje deklaracije i definicije.....jedno ide u cpp file a drugo u header file.

U ovom postu sam se eto dotakao pojma polimorfizam koji sam realizirao kroz virtalni mehanizam.
Napominjem "dotakao",samo vam približio te pojmove da ih malo bolje razumjeteu vašem daljnjem učenju!
U ovom postu još ću se dotaknuti ostvarivanja virtualnog mehanizma preko pokazivača i  i uporaba  referenci
sa virtualnim mehanizmom jer se radi o jednom te istom programu i zato je lakše za sve ,samo dodajemo kod!
A poseban post će biti o apstraktnoj klasi i čistoj virtulanoj funkciji...samo najava.

Sad samo naslov pa kad stignem.

...Pokazivači i Virtualne funkcije

Evo koda gdje su jasno pokazane izmjene koje sam načinio i proučite ih ,izmjene su samo u glavni.cpp

i mislim da ćete lako shvatiti o čemu se radi ,objašnjenje naravno slijedi :

#include <iostream>
#include "KartonKutija.h"
using namespace std;
int main()
{

    CKutija m_Kutija(2.0,3.0,4.0);
    CKartonKutija m_KartonKutija(2.0,3.0,4.0);
    //m_Kutija.PokaziVolumen();      //u programu pozivamo kao prvu funkciju
    //m_KartonKutija.PokaziVolumen(); //ima isto ime eto nam poziva virtualne funk.
    //cout<<endl;
    CKutija* pKutija =0;  //formiramo pokazivac tipa CKutija na objrkte klase CKutija
    pKutija =&m_Kutija;    //pokazivac na adresu objekta(instance) CKutija
    pKutija->PokaziVolumen(); //ovdje pozivamo funkciju base klase
    pKutija = &m_KartonKutija;//sad na drugi objekt od derived klase(dinamicko vezivanje)
    pKutija->PokaziVolumen(); //ovdje pozivamo funkciju derived klase
    cout<<endl;

    return 0;
}
//to je primjer polimofirzma u OOP-u
//sad preko pokazivaca smo napravili pozivanje funkcije
//takodjer primjetite da i preko pokazivaca mozemo realizirati virtualni mehanizam

_____________________________________________________________________________________________

@Tracer
Kolega nema tu ispravljanja vi samo dodajte što ja ne objasnim ili ne napišem jer smo tu svi zajedno da kompletiramo
koliko je to moguće ovaj tutorijal i stoga svaki post koji postate u svrhu boljeg objašnjenja ili ispravka je dobro došao!

__________________________________________________________________________________________

Virtualne funkcije se mogu dakle pozivati i oreko pokazivača i da ponovimo:
Polimorfizam je način na koji objekt izvršava operaciju koja pripada izvedenoj klasi iako se tom objektu
pristupa kao primjerku "base" klase.

Uporaba reference u virtualnom mehanizmu

Ako definiramo funkciju s referencama a Base klasu kao parametar u toj funkciji
tad možemo prenijeti kao argument te funkcije objekt Derived klase.Sve to nam omogućava pravilno pozivanje
virtualne funkcije.
Naravno ,da morate ponoviti prijenos po vrijednosti i referenci ranije na ovim tutovima.
Sad opet malo prepravimo kod u glavni.cpp :

#include <iostream>
#include "KartonKutija.h"
using namespace std;
void izlaz_novi(const CKutija &aKutija);//parametar funkcije je objekt(adresa)CKutija base klase
int main()
{

    CKutija m_Kutija(2.0,3.0,4.0);
    CKartonKutija m_KartonKutija(2.0,3.0,4.0);
    //m_Kutija.PokaziVolumen();      //u programu pozivamo kao prvu funkciju
    //m_KartonKutija.PokaziVolumen(); //ima isto ime eto nam poziva virtualne funk.
    //cout<<endl;
    //sad idemo na pokazivac u virtalnim funkcijama
    //__________________________________________________________________________________
    //CKutija* pKutija =0;  //formiramo pokazivac tipa CKutija na objrkte klase CKutija
    //pKutija =&m_Kutija;    //pokazivac na adresu objekta(instance) CKutija
    //pKutija->PokaziVolumen(); //ovdje pozivamo funkciju base klase
    //pKutija = &m_KartonKutija;//sad na drugi objekt od derived klase(dinamicko vezivanje)
    //pKutija->PokaziVolumen(); //ovdje pozivamo funkciju derived klase
    //______________________________________________________________________________
    //ovdje zapocinjemo program kojim upotreblavamo reference
    izlaz_novi(m_Kutija);
    izlaz_novi(m_KartonKutija);
    cout<<endl;

    return 0;
}
//to je primjer polimofirzma u OOP-u
//sad preko pokazivaca smo napravili pozivanje funkcije
//takodjer primjetite da i preko pokazivaca mozemo realizirati virtualni mehanizam
//sad ovdje funkcija i definicija
 void izlaz_novi(const CKutija &aKutija)
{
    aKutija.PokaziVolumen();   //pozivamo funkciju preko objekta
}

....i sad primjetite da funkcija izlaz_novi prenosi objekat kao argument iz Derived klase i naravno
izvršava se pravilna virtualna funkcija.

Sad ćemo prijeći na čiste virtualne funkcije i abstraktne klase i razlog zašto ih trebamo iako me kolega
Tracer malo pretekao ali što više primejra i objašnjenja doprinosi bogatstvu ovog tutorijala.
_________________________________________________________________________

PS:kad uhvatim vremena.

Kolega, ne želim ispasti babaroga koja je tu da bi vas ispravljala, nadopunjavala ili sl., no trebalo bi spomenuti i da su virtualne funkcije nužne u nekim situacijama čak i kad nemaju eksplicitnu svrhu u deriviranim klasama. Primjerice, kada se radi dynamic_cast pretvorba. Također, možda ste trebali staviti i primjer za abstraktnu klasu tj. čiste virtualne funkcije. Npr.:

class Zivotinja
{
    public:
        virtual void Vrsta(){}
};
class Pas : public Zivotinja
{
    public:
        void Vrsta(){
            cout << "Pas\n";
        }
};
class Macka : public Zivotinja
{
    public:
        void Vrsta(){
            cout << "Macka\n";
        }
};
int main()
{
    Pas Rex;
    Macka Mac;
    Zivotinja *Ziv;

    Ziv = &Rex;
    Ziv->Vrsta(); // Pas
    Ziv = &Mac;
    Ziv->Vrsta(); // Macka
    return 0;
}
Ovdje je riječ o još jednom primjeru upotrebe virtualnih funkcija gdje je funkcija Vrsta ona koja za svaku derivaciju treba imati različito tijelo. No abstraktna klasa bi bila ovakva:

class Zivotinja
{
    public:
        virtual void Vrsta() = 0;  // čista virtualna funkcija
};
Važnost abstraktne klase je u tome što ne postoji tijelo virtualne funkcije, pa zato ne može postojati niti jedna instanca takve klase. Npr.:

Zivotinja Jelen; // greška! klasa je abstraktna
Zivotinja* pJelen; // ok!

Znači, dopušta se adresiranje na derivacije abstraktne klase preko pokazivača, no ne i direktna postojanost instance bazne klase.

...ČISTA VIRTUALNA FUNKCIJA I ABSTRAKTNE KLASE(KLASA)

Ovako...nekad će nam zatrebati virtualna funkcija unutar Base klase koju ćemo
morati redefinirati (funkciju)u Derived klasi da odgovara objektu te klase.Sad da bi to ostvarili
moramo napraviti klasu koja će izvedenim klasama pružiti mogućnost da te
izvedene klase same definiraju sebi virtualnu funkciju a u Base klasi ćemo samo
izvršiti njenu deklaraciju i ništa više,sama klasa Base klas neće imati nikakve
varijable,samo čista deklaracija virtualne funkcije bez sadržaja i postaviti ćemo je
jednako nuli....to se zove čista virtualna funkcija  "pure virtual function".Derived
klase znači imaju sad mogućnost(moraju dati tijelo ako je žele koristiti) da
definiraju ili redefiniraju virtualnu funkciju kako njima "paše".U našem primjeru
imamo još jednu definiciju funkcije kao virtual i ona je dio Base klase ali koja se
može redefinirati jer je virtual.Vi naravno upamtite čistu virtual funkciju koja nam
koristi pri dinamičkom vezanju u toku prevođenja programskog koda....znači nema
statičke virtualne funkcije da se tako izrazim slikovito(nema ranog vezanja nego
kasnog iliti dinamičkog).

Znači ,klasa koja sadrži čistu virtualnu funkciju je abstraktna klasa.Zovemo je

abstraktna jer ne možemo stvarati objekte kao njezine instance(što je kolega

tracer lijepo prikazao u primjeru) i ona postoji samo zato da se definira u izvedenoj

klasi koja je dinamički koristi,mislim na čistu virtualnu funkciju.Ako sama izvedena

klasa opet u sebi sadrži čistu virtalnu klasu tad je i ta Derived klasa Abstraktna

klasa!
Sad ćemo na sam primjer i onda kad stigem sve ponovimo i naravno objasnim

malo i sam primjer :

....sami  kod sam rasporedio tako da su sve klase u header file-u a imamo samo
jedan glavni.cpp u kojem sve izvršavamo...kasnije u toku izlaganja i objašnjavanja koda
i u slikama vam to malo prikažem:

Abstraktna.h :

#pragma once
#include<iostream>
using namespace std;

class CAbstraktna
{
public:
    virtual double Volumen() const =0;  //virtualna funkcija cista!!
    virtual void PokaziVolumen()const
    {
        cout<<"Volumen je ove druge : "<<Volumen()<<endl;
    }
};
Kutija.h:

#pragma once
#include "Abstraktna.h"
#include<iostream>
using namespace std;

class CKutija:public CAbstraktna
{
public:
    virtual void PokaziVolumen() const
    {
        cout<<"Kutija ima volumen : "<<Volumen()<<endl;   //ovdje imamo vlastititu virtualnu PokaziVolumen funkciju
    }
virtual double Volumen() const   //virtulana funkcija
{
    return Duzina*Visina*Sirina;
}
//konsruktor
CKutija(double v= 1.0,double s = 1.0,double d=1.0):
Duzina(d),Visina(v),Sirina(s){}
protected:
    double Visina;
    double Duzina;
    double Sirina;
};
KutijaKutijica.h :

#pragma once
#include "Abstraktna.h"//takodjer koristimo abstraktnu klasu
#include <iostream>
extern const double PI;    //pi je definirano negdje drugdje a s extern ključnom riječju "ubacujemo "u header link za definiciju PI-a
using namespace std;

    //primjetite da nema PokaziVolumen funkcije i tad se koristi virtualna funk. iz base klase

class CKutijaKutijica:public CAbstraktna
{
public:
    virtual double Volumen()const
    {
        return 0.25*PI*Promjer*Promjer*Visina;
    }
    //konstruktor
    CKutijaKutijica(double v= 4.0,double p=2.0):
    Visina(v),Promjer(p){}
protected:
    double Promjer;
    double Visina;
};

glavni.cpp

#include <iostream>
#include "Kutija.h"
#include "KutijaKutijica.h"
using namespace std;
const double PI = 3.14159265;   //ovdje je definicija pi na globalnoj razini
int main()
{
    CAbstraktna* pokC1 = new CKutija(5.0,7.0,4.0);   //probajte stvoriti objekte CAbstarktne i vidjeti ćete grešku
    
    CAbstraktna* pokC2 = new CKutijaKutijica(5.5,3.0);
    pokC1->PokaziVolumen();
    pokC2->PokaziVolumen();
    delete pokC1;
    delete pokC2;

    
return 0;
}

Naravno,ponovite dinamičku alokaciju memorije s operatorima new i delete!

Znači mi smo u glavnom programu deklarirali dva pokazivača tipa naše Base klase
jer na taj način dopiremo do naše Base klase,jer ne možemo stvarati objekte kao
njezine instance jer je to Abstraktna klasa!

Sad možemo spremiti adresu u taj pokazivač,adresu objekta Derived klase!
Mi smo dodijelili "free store" pomoću new naredbe jer dinamički upravljamo
memorijom i na kraju je oslobađamo s delete naredbom(obvezatno).

Naravno ,objekti u izvedenim klasama se dinamički povezuju i stoga smo i mi upotrijebili
dinamičko upravljanje memorijom!
Pokazivač Base klase može sadržavati objekte(kojih može biti puno) svake izvedene klase iz naše Base
klase!

Sad ćemo sve ponoviti........
Klase koje nemaju instance(objekte),već nam služe samo da iz njih iizvedemo druge klase zovemo-Abstraktne klase.

U C++ jeziku svaka abstraktna klasa sadrži barem jednu čistu virtualnu funkciju.

To znači da je ta funkcija u Abstraktnoj klasi samo deklarirana a definiciju te čiste virtualne funkcije dati će izvedene klase!

Sama njena deklaracija u osnovnoj klasi završava s =0;(tkz.specifikator)

virtual double Volumen() const =0;

Klasa je apstraktna ako sadrži čistu virtualnu funkciju...znači ne mogu se stavrati objekti.
Ako mi u izvedenoj klasi iz te osnovne klase ne deklariramo virtalnu funkciju čistu tad i ta izvedena klasa postaje abstraktna!
Apstraktna klasa može imati podatke(varijable)..nevirtualne funkcijske članice i obične funkcije virtualne.

Recimo da bi to bilo to zasad.

Samo bih nadodao još nešto glede virtualnih funkcija... Naime, destruktor klase također može biti virtualan, dok to konstruktor ne može biti. Razlog je tome što virtualna tablica nije dostupna u vrijeme kreiranja objekta, ali zato prilikom njegova uništenja virtualni destuktor može itekako koristiti. Npr.:

class Bazna
{
    public:
    virtual ~Bazna(){
        cout << "Destruktor bazne klase...\n";
    }
};
class Derivacija : public Bazna
{
    public:
    ~Derivacija(){
        cout << "Destruktor derivacije...\n";
    }
};

Kada se uništava objekt derivacije u pravilu se prvo poziva destruktor derivacije klase a zatim destruktor bazne klase. No, ako imamo ovu situaciju:

Bazna* X = new Derivacija;
delete X;

U ovom slučaju po definiciji (deklaraciji) X je pokazivač koji pokazuje na objekt bazne klase, no zapravo pokazuje na objekt derivacije. Međutim, zbog deklaracije prilikom oslobađanja memorije poziva se samo destruktor bazne klase. No, ako je destruktor bazne klase virtualan prevoditelj će shvatiti da je X zapravo derivacija i prvo će pokrenuti destruktor derivirane klase, a tek onda destruktor bazne klase. Ovo često zna spasiti od mnogih memory leakova...

NESTED CLASSES

Eto naslova pa krenimo.
Ništa pretjerano neću oko ove teme i naslova jer se taj pojam prožima i kroz
pojam petlji ,if-else uvjeta i namespace pojma,također i lokalno i globalno pojma.
Sve sam to dosad nekoliko puta spomenuo u ovim tutorijalima a za razumijevanje
ovog naslova to je potrebno i ponoviti!

Klasa može biti deklarirana unutar deklaracije druge klase i to je ugniježđena klasa.
Ime klase koja damo toj klasi lokalno je za klasu koja je okružuje.Imenu te klase
izvan okružujuće klase može se pristupiti operatorom razriješenja :: duplom dvotočkom.

Primjer je samo za razumijevanje ,kasnije ide program :

class Vanjsaka
{
   public:
     class Unutrašnja
     {
         //evo ovdje sve od unutrašnje
     };   //zatvaramo unutrašnju
  };  //zatvaramo vanjsku

int main() 
   {
       Vanjska a ;             //objekt vanjske
      Unutrašnja b;           //objekt unutrašnje ali tako ne možemo jer nije dostupna
                             //pokrivena je vanjskom
      Vanjska::Unutrašnja b ;  //ovako može ,sad imamo pristup preko operatora razriješenja.

}

Sama dubina dokle možemo ići s Nested klasom ovisi o programu i programeru,
C1::C2::C3........C::N....

int x,y  ;                      //deklaracija na globalnoj razini.
class Vanjska
  {
      public:
        int x ;                //lokalna za vanjsku klasu
          class Unutrašnja
            {
                 void funk(int a, Vanjsaka *pok)  //funkcija
                        {
                                  x= a;   //ovako ne može jer pristup x-u nije korektan!
                                 ::x=a;   //ovako može-pristup globalnom x
                                  y=a  //i ovako može pristup globalnom jer nema zabune!!!
                                  pok->x=a;  //i ovako može jer koristimo pokazivač!!!!!
                         }
            };
    };

Mislim da sam negdje pri početku govorio o oblastima važenja na globalnoj i
lokalnoj razini i o namespace pojmu,također i o petljama u petlji...ako ste
to dobro naučili tad vam i ugniježđene klase neće biti problem za razumijevanje.
Molim to ponoviti.
"Nested" class se može deklarirati u public ili private dijelu vanjske klase.
Vanjska klasa ima pristup public dijelu dok private dijelu  nema.
Same pristupe ćemo kad budemo napisali program da bi još bolje razumjeli ovo što je napisano  ,na kojem sve
što sam spomenuo ili bar dio ,će biti.
Opet da bismo olakšali učenje samo ćemo prijašnje programe malo "preraditi"
i dodati jednu ugniježđenu klasu.
To je ono što vas čeka kad uhvatim opet vremena.A sad ću samo dodati slike tog izmjenjenog programa
i cmd .exe kad ga izvršim.Primjetite da sam dodao još jednu klasu a u toj klasi je još jedna klasa(struktura).
To je samo uvid da sam završio ali želim to detaljno objasniti ali malo se odmaram.
Naravno da bi sve ovo razumjeli morate sve o klasama dosad proći i naravno ovaj program koji nas prati cijelo vrijeme!
To je ono što se iz slike vidi..
Sad program:

Abstraktna.h :
ona nam treba.

#pragma once
#include<iostream>
using namespace std;

class CAbstraktna
{
public:
    ~CAbstraktna()
    {
        cout<<"Pozivamo destruktor od Abstraktne klase!"<<endl;
    }
    virtual double Volumen() const =0;  //virtualna funkcija cista!!
    virtual void PokaziVolumen()const
    {
        cout<<"Volumen je ove druge : "<<Volumen()<<endl;
    }
};

Kutija.h (također nam treba):

class CKutija:public CAbstraktna
{
public:
~CKutija()
    {
        cout<<"Pozivamo destruktor od CKutija klase!"<<endl;
    }
    virtual void PokaziVolumen() const
    {
        cout<<"Kutija ima volumen : "<<Volumen()<<endl;
    }
virtual double Volumen() const   //virtulana funkcija
{
    return Duzina*Visina*Sirina;
}
//konsruktor
CKutija(double v= 1.0,double s = 1.0,double d=1.0):
Duzina(d),Visina(v),Sirina(s){}
protected:
    double Visina;
    double Duzina;
    double Sirina;
};

KutijaKutijca.h nam ne treba ali je u projektu.

#include <iostream>
extern const double PI;    //pi je definirano negdje drugdje
using namespace std;

    

class CKutijaKutijica:public CAbstraktna
{
public:
~CKutijaKutijica()
    {
        cout<<"Pozivamo destruktor od CKutijaKutijica klase!"<<endl;
    }
    virtual double Volumen()const
    {
        return 0.25*PI*Promjer*Promjer*Visina;
    }
    //konstruktor
    CKutijaKutijica(double v= 4.0,double p=2.0):
    Visina(v),Promjer(p){}
protected:
    double Promjer;
    double Visina;
};

IndirektKutija.h :

Ona nam treba.

#include <iostream>
#include "Kutija.h"
class CIndirektKutija : public CKutija
{
public:
~CIndirektKutija()
    {
        cout<<"Pozivamo destruktor od CIndirektKutija klase!"<<endl;
    }
    //sad ovdje definiramo virtualnu funkciju za ovu klasu
    virtual double Volumen() const
    {
        return 0.50*Duzina*Visina*Sirina;
    }
    //konstruktor
    CIndirektKutija(double v,double s,double d):CKutija(v,s,d)
    {}
};

Naša nova klasa koja sadrži "nested" strukturu .
neste.h

#pragma once
class CNested
{
private:
    struct CSpremiste
    {
        CKutija* pokKutija;       //pokazivaci na objekte
        CSpremiste* pokSlijedeci;    //pokazivaci na spremljene objekte ili na NULL
        //konstruktor
        CSpremiste(CKutija* pokK,CSpremiste* pokS):
        pokKutija(pokK),pokSlijedeci(pokS)
        {}
    };
    CSpremiste* pokVrh;
public:
    //sprema objekt u spremiste
    void Spremi(CKutija* pokKutija)//samo preko pokazivaca mozemo pristupiti
    {
        pokVrh = new CSpremiste(pokKutija,pokVrh);  //dinamicki na "heap"(free store)
    }
    CKutija* P()
    {
        if(pokVrh ==0)   //ako je spremiste prazno tad vrati NULL
            return 0;
        CKutija* pokKutija = pokVrh->pokKutija;  //dohvati kutiju iz spremista
        CSpremiste* pokCuvaj = pokVrh;     //spremi adresu na vrh "heap"
        pokVrh = pokVrh->pokSlijedeci;     //zatim na slijedeci
        delete pokCuvaj ;                  //stari zbrisi s "heap"
        return pokKutija;                  //opet na pocetak do kraja for petlje u glavnom.cpp
    }
};

///*vidite kako upravljamo memorijom*/

glavni.cpp:
I naravno glavni.cpp u kojem sam ostavio ono što ne koristimo da proučavate.

#include <iostream>
#include "Kutija.h"   //uklucujemo znaci klasu CKutija i njenu Base klasu
//#include "KutijaKutijica.h"
#include "IndirektKutija.h"    //ukljucujemo CIndirektKutija(a preko nje i CKutija i Base klasa)
#include "neste.h"
using namespace std;
//const double PI = 3.14159265;   //ovdje je definicija pi na globalnoj razini
int main()
{
    //CAbstraktna* pokc = new CKutija(3.0,4.0,5.0);
    //CKutijaKutijica moja_Kutija(2.3,4.5);
    //CIndirektKutija I_Kutija(4.5,2.3,4.0);
    //pokc->PokaziVolumen();
    //cout<<"Sad brisemo CKutija!"<<endl;//ovo smo takodjer dodali
    //delete pokc;    //moramo osloboditi mjesto(u free store) za smjestaj adrese
    ////_______________________________________
    ////ovaj dio smo dodali znaci opet dinamicko upravljanje memorije
    //pokc = new CIndirektKutija(4.0,6.0,8.0);
    //pokc->PokaziVolumen();
    //cout<<"Sad brisemo CIndirektKutija!"<<endl;
    //delete pokc;
    ////________________________________________
 //    pokc=&moja_Kutija;
    // pokc->PokaziVolumen();
 //    pokc = &I_Kutija;
    // pokc->PokaziVolumen();
    CKutija* pKutije[]=
    {
                          new CKutija(2.0,3.0,4.0),
                          new CIndirektKutija(2.0,3.0,4.0),
                          new CKutija(5.0,6.0,7.0),
                          new CIndirektKutija(5.0,6.0,7.0)
    };
    cout<<"Ovo polje kutija ima slijedece volumene : "<<endl<<endl;
    for (int x = 0; x<4; x++)
        pKutije[x]->PokaziVolumen();   //izracunava nase volumene
    cout<<endl<<endl;

    cout<<"Sad na spremiste : ";
    CNested* pokSpremi = new CNested;     //kreira spremiste
         for (int x = 0; x<4; x++)
             pokSpremi->Spremi(pKutije[x]);
        
         cout<<endl<<endl;
         cout<<"Obrnuti redoslijed : "<<endl<<endl;
       for (int x = 0; x<4; x++)
           pokSpremi->P()->PokaziVolumen();  //dohvaca objekte(adrese) i racuna volumen.


     cout<<endl;
return 0;
}
Mi smo znači stvorili novu klasu...CNested.
Koja je vanjska a unutrašnja je u biti struktura ali smo mogli staviti i class umjesto
strukture ,a struktura je stavljena jer je po defaultu public ,lakše je raditi sa
strukturom našoj vanjskoj klasi.
A u biti nam treba samo da spremamo podatke u našu ugniježđenu klasu(strukturu) ,i zato
nam odgovara struktura.U glavnom programu smo prvo kreirali polje pokazivača tipa (korisničkog-izvedenog).
Sad u njh možemo spremati adrese na kojima se nalaze naši objekti.
CKutija i CIndirektKutija po dva od svakog istih dimenzija.
Sve je dinamički kreirano jer mi želimo upravljati memorijom i biti sigurni da je sve
čisto nakon završetka programa.
Zatim ,izračunavamo volumen svake kutije preko funkcije PokaziVolumen() ,
jer smo preko pokazivača pozvali odgovarajuču funkciju za sve naše objekte.
Nakon toga mi opet (dinamički na "heap memoriji") stvaramo spremište za naše
objekte(adrese).I koristimo funkciju spremi()  samo za spremanje na novu lokaciju.
Naravno prvi u našem spremištu je zadnji koji je ušao!
Ponovite ono što sam rekao o spremanju na stog i uzimanju sa stoga!
Sad pomoću naše slijedeće funkcije dohvaćamo sve te adrese i objekte koji su na
tim adresama pomoću funkcije P()(opet dinamički upravljamo memoriojom) i
 odmah izračunavamo volumen opet!Ali sad zbog onog pravila spremanja na stog
....pokazuju se obrnutim redoslijedom.
Eto vidite kako sve klase međusobno surađuju u projektu i kako CNested pomoću
svojih funkcija prilazi ugniježđenoj strukturi ,a i razlog samog slobodnog
pristupa vanjske klase je zbog public strukture.
Sama struktura  je zaštićena od svih drugih korisničkih tipova ali mi pomoću
CNested klase i njezinih funkcijskih članica možemo manipulirati s vanjskim
podacima da bi ih kombinirali s ugniježđenim klasama koje su skrivene od "vanjskog svijeta".
Malo bolje sve proučite i vidjeti ćete kako sve lijepo surađuje u našem projektu.
Nemam vam što savjetovati nego da vježbate i sami počnete logički sve ovo povezati.
Na vama i vašem trudu je sve prepušteno.Do slijedećeg susreta.
____________________________________________________________________________

PS:
Ovdje imate link na YouToube video c++ tutorijale pa pogledajte:

Uživajte.
Slijedeći postovi će biti vezani uz C++/CLI tutorijale .NET
Zato ,downloadajte VS Express edition (2008 ili 2005)....i naravno SDK.
Imate upute koje vas vode.
________________________________________________________________________________

Poštovanje!

Evo ovako, trebao bi pomoć. Dal bi mi netko mogao riješiti sljedeća dva zadatka!

Zadatak 1.

U programskom jeziku C++ napišite program koji će:

1. Tražiti od korisnika da unese broj studenata n (maksimalan broj studenata je 5) te omogućiti unos n ocjena te n imena i prezimena studenata.

2. Ispisati informacije o studentima obrnutim redoslijedom od njihova unosa.

3. Ispisati informacije o studentu s najvećom ocjenom.

4. Ispisati prosjek (aritmetičku sredinu) ocjena svih studenata. Osim toga, potrebno je ispisati sve studente čija je ocjena veća od prosječne.

Program je potrebno realizirati pomoću izbornika.

Zadatak 2.

Napišite C++ program koji će učitavati prirodni broj N te dinamički alocirati polje tipa short duljine N. Treba učitati N brojeva, sortirati ih uzlazno, te ih ispisatu u decimalnom, oktalnom i heksadecimalnom obliku.

Program treba koristiti sljedeće funkcije:

Citaj - Funkcija tipa void kojom se učitava polje od N brojeva

Sortiraj - Funkcija kojom se sortira polje brojeva

Ispisi - Funkcija kojom se ispisuje polje od N brojeva i to u sva tri oblika.

Primjer:

Upisite N: 5

Upisite 1. broj: 35

Upisite 2. broj: 12

Upisite 3. broj: 44

Upisite 4. broj: 25

Upisite 5. broj: 62

Ispis:

Dec    Hex   Oct

12     0c      14

25     19      31

35     23      43

44     2c       54

62     3e      76

ZABRANJENO JE KORIŠTENJE GLOBALNIH VARIJABLI!

Eto, bio bih veoma zahvalan kad bi mi netko pomogao riješiti ova dva zadataka...