\documentclass[a4paper,12pt]{article}

\usepackage[latin2]{inputenc}

\title{Vaje 17}
\author{Simona Perčič}
\date{9.3.1998}

\begin{document}

\maketitle

\section*{Popravek: VRSTA1.h, VRSTA1.cpp}

Definicijski modul najdemo na področju
%
\[
\texttt{Z:}
  \backslash\texttt{Predavanja}
  \backslash\texttt{Polde}
  \backslash\texttt{code}
  \backslash\texttt{Vrsta}
  \backslash\texttt{Vrsta2.h}
\]
%
{\tt
\begin{verbatim}
#include "../../code/bool/bool.h"
#define max_vrsta 10              // najvecja mozna dolzina vrste

class Vrsta {
private:                          // ZASEBNO - NE GLEJ!

  int hodnik[max_vrsta];          // krozna vrsta s shranjenimi elementi
  int prvi,                       // polozaj prvega elementa
      zadnji;                     // v resnici polozaj prvega prostega mesta
                                  // v vrsti
  bool zakljucena;                // vsa mesta v vrsti so zapolnjena

public:                           // JAVNO

//--------------------------------------------------------------------//
//--------------------------USTVARJANJE IN UNICEVANJE-----------------//
//--------------------------------------------------------------------//

  Vrsta();
/* Desc:   Ustvari prazno vrsto.
        Parms:  /
        Result: vrsta
        Pre:    /
        Post:   Prazna()
*/

  ~Vrsta();
/* Desc:   Unici vrsto.
        Parms:  /
        Result: /
        Pre:    Vrsta je bila ustvarjena.
        Post:   Vrste ne moremo vec uporabiti.
*/
//-------------------------------------------------------------------//
//-------------------------SPREMINJANJA------------------------------//
//-------------------------------------------------------------------//

  void Dodaj(int element);
/* Desc:   Doda element v vrsto.
        Parms:  element - element, ki ga dodamo v vrsto ( po vrednosti )
        Result: /
        Pre:    not(Polna()) and [vrsta]
        Post:   vrsta'= [element|vrsta]
*/
  int Izloci();
/* Desc:   Izloci element iz vrste.
        Parms:  /
        Result: element iz vrste
        Pre:    not(Prazna()) and [ostalo|element]
        Post:   vrsta'= [ostalo]
*/

//--------------------------------------------------------------------//
//-------------------------POIZVEDOVANJA------------------------------//
//--------------------------------------------------------------------//

  bool Prazna();
/* Desc:   Preveri, ali je vrsta prazna.
        Parms:  /
        Result: vrsta = []
        Pre:    Vrsta ustvarjena.
        Post:   /
 */
  bool Polna();
/* Desc:   Preveri, ali je vrsta polna.
        Parms:  /
        Result: ce ne moremo vec dodati then TRUE else FALSE
        Pre:    Vrsta je bila ustvarjena.
        Post:   /
*/
};  /* Vrsta */
\end{verbatim}
}

Izvedbeni modul najdemo na področju
%
\[
\texttt{Z:}
  \backslash\texttt{Predavanja}
  \backslash\texttt{Polde}
  \backslash\texttt{code}
  \backslash\texttt{Vrsta}
  \backslash\texttt{Vrsta2.cpp}
\]
%
{\tt
\begin{verbatim}
#include "VRSTA2.H"

Vrsta::Vrsta(){
  prvi = 0;
  zadnji = 0;
  zakljucena = false;
} // Vrsta

Vrsta::~Vrsta(){};

//-------------------------------------------------------------------//
//-------------------------SPREMINJANJA------------------------------//
//-------------------------------------------------------------------//

void Vrsta::Dodaj(int element) {
  hodnik[zadnji] = element;
  zadnji = ((zadnji+1) % max_vrsta);
  zakljucena = (prvi == zadnji);
}   /* Dodaj */

int Vrsta::Izloci() {
  int zac_elt;                     // zacasni element
  zac_elt = hodnik[prvi];
  prvi = ((prvi+1) % max_vrsta);
  zakljucena = false;
  return zac_elt;
}  // Izloci

//--------------------------------------------------------------------//
//-------------------------POIZVEDOVANJA------------------------------//
//--------------------------------------------------------------------//

bool Vrsta::Polna() {

  return (zakljucena);
}  // Polna

bool Vrsta::Prazna() {

  return ((prvi == zadnji) && (!zakljucena));
} // Prazna
\end{verbatim}
}

Testni modul si lahko ogledati na področju
%
\[
\texttt{Z:}
  \backslash\texttt{Predavanja}
  \backslash\texttt{Polde}
  \backslash\texttt{test}
  \backslash\texttt{Vrsta}
  \backslash\texttt{Testkrog.cpp}
\]
%
{\tt
\begin{verbatim}
#include <stdio.h>
#include "../../code/vrsta/vrsta2.h"

int main () {
  Vrsta A;
  int element;
  char ukaz[256];

  scanf("%s", ukaz);
  while (ukaz[0] != 'K') {
         switch (ukaz[0]) {
         case 'V':
         case 'v':
                scanf("%d", &element);
                if (A.Polna()) printf("Ni vec prostora.\n");
                else A.Dodaj(element);
         break;
         case 'I':
         case 'i':
                if (A.Prazna()) printf("V vrsti ni vec elementov.\n");
                else printf("%d\n", A.Izloci());
         break;
         } // switch
         scanf("%s", ukaz);
  } //while

  return 0;

} // main
\end{verbatim}


\subsection*{Nauk današnjih vaj}

\begin {itemize}
\item Izogibaj se uporabljanju \textbf{npr: \texttt{a++}}, ampak raje
  piši\textbf{\texttt{a = a + 1}}
\item Vrednosti FALSE in TRUE v programih piši z \textbf{malimi
    črkami} npr: \texttt{false} oziroma \texttt{true}
\item Dogovor: \texttt{Vsak program v C-ju je funkcija (funkcija
    \texttt{main}, ki vrne celoštevilski rezultat.}

  Splošno: pomeni, da je to naša osebna odločitev

  Tihi dogovor: Če funkcija \texttt{main} (to je program) vrne
  celoštevilsko vrednost 0, pomeni, da je funkcija delo opravila brez
  napake. Npr.:
%
{\tt
\begin{verbatim}
int main()  {
       .
       .
       .
  return 0;
} //main
\end{verbatim}
}

\end{itemize}

\end{document}
