\documentclass[a4paper,12pt]{article}
\usepackage[latin2]{inputenc}

\title{Vaje 13}
\author{Barbara Nežmah}
\date{5.1.1998}

\begin{document}
\maketitle

\section*{Predmetno orientirano ali usmerjeno programiranje}

Kaj je predmet?
%
Odgovor: miza, stol.... Imamo 24 stolov in ti stoli sodijo v razred
stolov.

Razred stolov:
%
\begin{enumerate}
\item noge,
\item naslonjalo za hrbet,
\item naslonjalo za pisanje...
\end{enumerate}
%
Vzamemo enega iz tega razreda. Če bi rekli, da smo vzeli rdeč stol,
potem ta stol ne sodi v ta razred, ker na začetku nismo predpostavili,
da so stoli rdeči.

\subsection*{Primeri}

Definirajmo razred geometrijskih likov z lastnostmi:
%
\begin{enumerate}
\item ploščina,
\item obseg.
\end{enumerate}
%
Razred mnogokotnikov, ki je podrazred geometrijskih likov ima še:
%
\begin{enumerate}
\item število ogljišč,
\item dolžina stranice.
\end{enumerate}

Kako je razred definiran?
%
Razred je definiran s skupkom lastnosti. Predmet ima skupek lastnosti,
ki jih mora zadovoljiti.

Kakšna je razlika med razredom skladov in enim skladom?
%
Odgovor: En sklad vedno obstaja. Predstavnik razreda skladov pa lahko
da ne.

Razred je opis kako stvar izgleda in kako se obnaša. Predmet je pa
eden izmed predstavnikov iz tega razreda. To nas spominja na tip. V
navadnem c-ju smo imeli, na primer tip \texttt{integer}. K temu tipu
smo nanizali razne spremenljivke, ki smo jih potrebovali. V c++ pa se
spremenljivka danega tipa imenuje predmet.

\textsc{Primer}:
%
Definirajmo razred vseh skladov:
%
Pod sklad 1 spada 1, 2, 3, 4     =4 številke.

Pod sklad 2 spada 1, 2           =2 številki.

V c-ju smo imeli:
%
{\tt
\begin{verbatim}
SKL_Ustvari
SKL_Uniči
SKL_Nalozi(sk, st);
SKL_Zlozi(sk)       -> st
SKL_Poln(sk)        -> T/F
SKL_Prazen(sk)      -> T/F
\end{verbatim}
}
%
kar prevedemo v razred celoštevilčnih skladov z naslednjimi lastnostmi:
%
\begin{enumerate}
\item lahko ga ustvarimo in lahko ga uničimo;
\item nanj lahko naložimo celo število;
\item z njega lahko zložimo celo število;
\item pogledamo, če je poln;
\item pogledamo, če je prazen.
\end{enumerate}
%
Torej, če imamo predmet sklad, lahko nanj nalagamo ali z njega zlagamo
cela števila; pogledamo, če je prazen ali poln nimamo nobenih
implementacij. To je \emph{razred celoštevilskih skladov}.

Na začetku imamo \emph{definicijski modul} nato izdelamo
\emph{izvedbeni modul} v \emph{obj} obliki. V c++ ima definicijski
modul obliko:
%
{\tt
\begin{verbatim}
class IntSklad \{
public:              // metode
  IntSklad();        // s tem stvar ustvarimo
  ~IntSklad();       // unici predmet tega razreda

  void Nalozi(const int stev);
  int Zlozi();
  bool Poln();
  bool Prazen();

\} // IntSklad
\end{verbatim}
}
%
Defincije razreda sestoji iz:
%
\begin{enumerate}
\item privatnega dela,
\item zaščitnega dela,
\item javnega dela.
\end{enumerate}

Predmet iz razreda celoštevilskih skladov je sedaj definiran kot:
%
{\tt
\begin{verbatim}
int main(void) \{
  int i;               // i je iz razreda celih stevil
                       // in int je razred
  IntSklad skl;        // s tem se ustvari predmet iz razreda
                       // IntSklad in predmet se imenuje skl --
                       // pozene se kreator IntSkl()
  .
  .
  .
\}
\end{verbatim}
}
%
Vsak definicijski modul ima podprograme za uničenje in ustvarjanje.
Prav tako tudi vsak razred:
%
{\tt
\begin{verbatim}
  i=10;                  // i-ju smo priredili neko vrednost
  printf("\%d",i);        // stvar se izpise
  .
  .
  skl.Nalozi(10);        // na sklad smo nalozili 10
  skl.Nalozi(20);        // na sklad smo nalozili 20
  skl.Nalozi(i);         // na sklad smo nalozili i
                         // predmetu skl, ki je iz razreda
                         // celostevilcnih skladov posljemo
                         // sporocilo, da naj na sebe nalozi
                         // stevilo i
  if sklad.Poln()
    printf("sklad je poln");
\end{verbatin}
}
%
Lahko imamo več predmetov iz razreda celoštevilčnih skladov:
{\tt
\begin{verbatim}
  int i;
  IntSklad skl,skl1;
  .
  .
  .
  if skl.Prazen()
    printf("sklad je prazen");
  if skl1.Prazen()
    printf("sklad je prazen");
\end{verbatim}
}
%
in funkciji \texttt{skl.Prazen()} ter \texttt{skl1.Prazen()} nimata
takorekoč nič skupnega.

C++ poskrbi, da za seboj vse avtomatično počisti. Tako, po koncu
izvajanja bloka, pokliče sistem destruktorja za vsakega od predmetov
ustvarjenih v bloku (npr.~{\tt{}\verb+~IntSklad()+}).

Prej smo omenili, da \texttt{int} v bitsvu definira razred celih
števil. Recimo, predmeti iz tega razreda imajo lastnost, da jim lahko
prištejemo drugo celo število:
%
{\tt
\begin{verbatim}
  int i;
  i= 3;                  // je isto kot i.=(3);
  i+= 10;                // je isto kot i.+=(10)
\end{verbatim}
}

\end{document}
