\documentclass[a4paper,12pt]{article}

% Klavdija Lunar  PRAKTIČNA MATEMATIKA 2. letnik

\usepackage[latin2]{inputenc}

\title{Vaje 18}
\author{Klavdija LUNAR}

\date{16.3.1998}

\begin{document}

\maketitle

Danes si bomo ogledali:
%
\begin{enumerate}
\item domačo nalogo
\item DEBUG
\item sklad z
%
  \begin{itemize}
  \item ,,brez`` max\_Sklad, pri katerem si bomo ogledali:
%
    \begin{itemize}
    \item malloc
    \item free
    \item new
    \item delete
    \end{itemize}

  \item sklad z realnimi števili
  \item sklad znakov
  \end{itemize}
\end{enumerate}
%
\emph{Static} pomeni, da pozna definirano stvar samo tisti modul, v
katerem se nahaja.

\section*{DEBUG}

Debug ali razhroščevanje. Zgodovina Debug-a:
%
\begin{quotation}
  Ta izraz se je rodil leta 1948. Takrat  so bili računalniki narejeni
  še  iz elektronk. Elektronke pa delajo  na 3 oz. 5-ih voltih, včasih
  pa so delali na 100-ih voltih. V tistem času so naredili program, ki
  je zmeraj delal narobe ( dajal je  napačne rezultate ). Nekdo je šel
  pogledat,  če je  kaj narobe z  računalnikom in  med žicami so našli
  majhnega hrošča. In zato se to imenuje debug oz. razhroščevalnik.
\end{quotation}
%
Namen debuggiranja je, da poiščemo napako v programu. S testiranjem
preverimo, če je program pravilen. Če ni takih napak, da se program
vsaj prevede, preizkusimo, če nam npr. pravilno odšteva. Če ugotovimo
napake v funkcijah, si pomagamo z delnimi rezultati tako, da jih
izpisujemo.

\textbf{PRIMER:} Kako najdemo napako pri programu ART.C?

To naredimo tako, da program najprej prevedemo v knjižnico. Potem
gremo pogledat še testen program TESTART.C. Naredimo projekt in
na\-pi\-šemo TESTART ter mu dodamo osnovni in objektni program. Potem
pa prevedemo v standard. Napisali smo:
%
{\tt
\begin{quote}
   V123
\\ V456
\\ S
\\ I
\end{quote}
}
%
računalnik izpiše: \texttt{579}.

Naredili smo še nekaj preizkusov. Radi pa bi ugotovili, kaj je narobe.

Npr. po scanf se želimo ustaviti. To naredimo tako, da gremo na
\textit{Debug}, potem izberemo \textit{Toggle breakpoint oz. Ctrl+F8}.

\textit{Watches} izpisuje vrednost in v programu so razne
spremenljivke, ki lahko opazuješ kako se spreminjajo.

\textit{Toggle breakpoint} ko izbereš vrstico, se vrstica rdeče obarva
in program bo tekel toliko časa, dokler ne pride do te vrstice. Potem
te bo vprašal, kaj hočeš.

\textit{breakpoints} posredujeje spisek vseh točk, kjer se bo Debug
ustavil.

\texttt{V 100} - program se ustavi, kjer smo prej zahtevali
(nastavili).

Radi bi pogledali, če je vrednost 100 v resnici vpisana.

Gremo na:
%
\begin{itemize}
\item \textit{Debug}
\item \textit{Toggle breakpoint}
\item \textit{Inspect}
\end{itemize}

\emph{Še drugi način:}
%
\textit{F8} pomeni, da izvajamo program korakoma -- vrstica za vrstico.
Pritisnemo F8 in se prestavimo, potem Debug, Inspect in napišemo
\texttt{stev1}, potem vnesemo še \texttt{stev2}. Potem spet pritisnemo
F8. Ševili seštejemo.

Potem gremo na Run, napišemo I, vendar se še ne bo izpisalo.
%
\begin{quote}
   V123 Ctrl+F9
\\ V222 Ctrl+F9
\\ O    Ctrl+F9
\\ I
\end{quote}
%
Izpiše nam pravilen rezultat \texttt{99}.

\emph{Radi bi pogledali, kako program dela:}
%
\begin{itemize}
\item \textit{Run}
\item \textit{Trace into}
\end{itemize}
%
ali F7 in smo v programu. Lahko pogledamo kakšni sta \texttt{num1} in
\texttt{num2}. To naredimo tako, da gremo na:
%
\begin{itemize}
\item \textit{Debug}
\item \textit{Inspect}.
\end{itemize}
%
V Inspect-u napišemo \texttt{num1} in Enter ter vidimo, da je
\texttt{num1} enako 212. Potem naredimo isto še za \texttt{num2} in
vidimo, da je \texttt{num2} enako 131. Potem gremo korak naprej z F8.

Predznak števila ugotovimo tako, da gremo na:
%
\begin{itemize}
\item \textit{Debug}
\item \textit{Inspect}
\item napišemo \texttt{num1.sign}
\end{itemize}
%
in isto naredimo za \texttt{num2}.

Radi bi videli, kako bi delala funkcija \texttt{ABSVecje}. Gremo na Run in
potem na Trace (oziroma F7). Pogledali smo vrednost po že znani poti,
\texttt{num1}, \texttt{num2}, stevec v funkciji \texttt{ABSVecje}.

Pri \texttt{for} (stevec) smo postavili \textit{Toggle breakpoint} --
ustavi se, kjer je bila prekinitvena točka.

Vsak program ima za razhroščevanje vsaj 3 ukaze:
%
\begin{description}
\item[Run]   -- izvajaj naprej
\item[Step]  -- izvedi eno vrstico
\item[Trace] -- izvedi naslednjo vrstico, ki je lahko v podprogramu
\end{description}
%
Poleg teh pa še ukaz Watch, ki je v povezavi z Inspect.

Ugotovili smo tudi, da ima naš program eno napako pri odštevanju. To
napako moramo poiskati.

\subsection*{Sklad ,,brez`` max\_Sklad}

Sklad je definiran kot skladišče, ki ima 100 možnih elementov.
%
\[
\textrm{Software engineering} =
%
\left\{\begin{array}{rr}
   \texttt{sklad\_100}
\\ \texttt{sklad\_200}
\\ \texttt{sklad\_250}
\\ \vdots
\\ \textrm{poljubno mnogo}
 \end{array} \right.
\]
%
V našem skladišču moramo imeti prostor za naročene izdelke vseh
strank. Če najdemo v kodi, jo moramo popraviti. Naša želja je, da to
napako popravimo samo enkrat. Želimo imeti samo en modul.

Želimo narediti program, da bodo vse stranke imele svoje kode še
naprej.

Vse kar lahko spreminjamo je, da spremenimo private, ostalo mora biti
popolnoma enako.

\subsection*{\texttt{malloc} in \texttt{free}}

To sta takoimenovana c-jevska ukaza. Ko narediš en objekt, se ta
objekt naseli v pomnilnik. Nekje v pomnilniku se nahaja naš sklad.
Moti nas številka \texttt{max\_sklad}, ki je v naprej določena. Včasih
želimo, da je ta majhna, včasih pa velika.

Definirali bomo, da skladišče ne bo več skladišče, ampak kazalec
na skladišče.
%
{\tt
\begin{verbatim}
   int * ptrSkladisce;
\end{verbatim}
}
%
Zvezdica ,,\texttt{*}`` v glavi funkcije pomeni referenco na objekt;
tu pa to pomeni, da je kazalec na objekt tipa int.

Ko v stari izvedbi ustvarimo sklad, se nam prostor za skladišče sam od
sebe rezervira. Funkcija, ki jo bomo napisali, nam bo to naredila po
naših potrebah: \texttt{n} -- zlogov pomnilnika.
%
{\tt
\begin{verbatim}
Sklad::Sklad() {
  ptr_Skladisce= (int*)malloc (max_Sklad * sizeof(int));
} //Sklad
Sklad::~Sklad() {
 free(ptr_skladisce);   // s tem smo vrnili, kar smo dobili
} //~Sklad
\end{verbatim}
}
%
Pri \texttt{malloc} je int osnovni tip spremenljivke, ki bo ustvarjen.
Velikost tega tipa je \texttt{sizeof(int)} zlogov -- ena spremenljivka
zasede toliko zlogov pomnilnika. V našem primeru jih bomo dobili
\texttt{max\_Sklad} krat toliko.

Kako s tem delati? Napisali bomo novo funkcijo z našim no\-vim
skla\-diš\-čem.

{\tt
\begin{verbatim}
void Sklad::Nalozi(int element) {
  ptr_skladisce[zadnji]= element;
  zadnji ++;
 } //Nalozi
\end{verbatim}
}

Podrobno si lahko pogledate na:
\[
  \texttt{Z:}
     \backslash\texttt{PREDAVANJA}
     \backslash\texttt{POLDE}
     \backslash\texttt{CODE}
     \backslash\texttt{SKLAD}
     \backslash\texttt{SKLAD.CPP}
\]

V c-ju in c++ so polja čudna stvar -- ne obstajajo. Polje je
predstavljeno kot \emph{kazalec na prvi element polja}. Če hočeš priti
do zadnjega, prišteješ temu kazalcu velikost polja. Da bo pravilno
delal, mora biti spre\-men\-ljiv\-ka kazalec na prvi element polja.

\subsection*{\texttt{new} in \texttt{delete}}

Ko naredimo objekt, moramo vsakega od njih kreirati. Namesto
\texttt{malloc} bomo imeli \texttt{new}, namesto \texttt{free} pa
\texttt{delete}. Sedaj nam ni potrebno vec \emph{spreminjati tipa}
vrnjene spre\-men\-ljiv\-ke. Namesto:
%
\[
\texttt{ptr\_Skladisce= (int*)malloc (max\_Sklad * sizeof(int))}
\]
%
napišemo
%
\[
\texttt{ptr\_Skladisce= new int [max\_Sklad]}
\]
%


\subsection*{Spremenljiva velikost skladišča}

Kako bi rešili problem?

\emph{Ideja:}
%
\begin{quotation}
  Imamo mladoporočenca, ki trenutno živita v garsonjeri.  Ko bosta
  dobila svojega prvega otroka, se bosta z vso svojo kramo iz
  garsonjere in z otrokom, preselila v enosobno stanovanje. Ko bosta
  dobila drugega otroka, se bodo, vsi skupaj in z vso kramo, preselili
  v dvosobno stanovanje...

  Potem pa otroci zrastejo in odidejo od doma, zato se moz in zena
  preselita, z vso svojo kramo, postopoma nazaj v garsonjero.
\end{quotation}
%
To je opis kako bomo uporabljali ukaza \texttt{new} in
\texttt{delete}.

Funkcija \texttt{Poln} vrne true natanko takrat, ko je polna. V
popravljeni inačici pa funkcija, ko ugotovi, da je skladišče polno,
poskuša dobiti nov prostor s pomočjo ukaza \texttt{malloc}
(\texttt{new}). Če ni dovolj velikega pomnilnika, vrneta obe funkciji
nič (\texttt{NULL}). V tem primeru bomo sporočili, da je sklad poln.

{\tt
\begin{verbatim}
bool Sklad::Poln() {
  if(zadnji < Vel_Skladisce) return false;
      // dobi novo skladisce, ki je veliko 2* Vel_Skladisce.
      // ce nismo dobiliskladisca, return true.
      // sicer preselimo skladisce, sprostimo staro skladisce.
      // Vel_Skladisce= 2* Vel_Skladisce, return false.
} // Poln
\end{verbatim}
}

Podrobno si lahko pogledate na:
%
\[
  \texttt{Z:}
     \backslash\texttt{PREDAVANJA}
     \backslash\texttt{POLDE}
     \backslash\texttt{CODE}
     \backslash\texttt{SKLAD}
     \backslash\texttt{NOVISKLAD.CPP}
\]

\end{document}
