Laslo Kraus - IR2OO1 (Drugi kolokvijum 11.2.2007)

← ↑ ⇑ ↓ →

Ласло Краус	ИР2ОО1 Други колоквијум 11. 2. 2007.

Аутори: Игор Тартаља и Ласло Краус

Задаци: 1 2 | Напоменe | Решења: 2

Поставка задатка 1 (30 поена) (⇒ почетак)

Одговорити концизно (по једна или две реченице) и прецизно на следећа питaња:

а) Да ли апстрактна класа може имати конструктор и зашто?

б) Да ли је исправно бацити као изузетак показивач на локалну променљиву текуће методе и зашто?

в) Да ли је механизам генерика статички или динамички и зашто?

Поставка задатка 2 (укупно 70 поена) (⇒ решење | почетак)

Коришћењем приложених готових класа за представљање вожње аутомобила задате низом етапа, написати на језику C++ следеће класе (класе опремити оним конструкторима, деструктором и оператором за доделу вредности, који су потребни за безбедно коришћење класа; грешке пријављивати изузецима типа класа које су оспособљене за исписивање текста поруке):

(25 поена) Апстрактно возило има задату сопствену тежину. Може да се дохвати назив врсте возила, да се одреди тежина возила и да се возило упише у излазни ток (it<<v). Пише се назив врсте возила и сопствена тежина возила.
Бицикл је возило.
Камион је возило задате сопствене тежине и носивости. Ствара се без товара после чега може да се дода товар задате тежине и да се скине товар задате тежине. Грешка је ако се камион претовари. Скидањем превише товара тежина товара постане једнака нули. У излазни ток се пише и тренутна тежина товара на камиону.
(25 поена) Генерички низ може да садржи елементе неког типа. Ствара се празан задатог капацитета (подразумевано 20) после чега елементи могу да се додају један по један. Грешка је ако се низ препуни. Може да се дохвати број елеменатa у низу, да се дохвати елемент задатог редног броја (niz[i]) и да се низ испразни. Грешка је ако се покуша дохватити непостојећи елемент.
(20 поена) Тркачки ауто је возило којe садржи генерисан низ вожњи. Ствара се с празним низом капацитета 10 вожњи. Може да се започне нова вожња капацитетa 100 етапа, да се последње започетој вожњи дода нова етапа, да се одреди вожња са највећом средњом брзином. У излазни ток се пише и дужина вожње са највећом средњом брзином.

Напоменe (⇒ почетак)

Колоквијум траје 120 минута.
Рад се предаје искључиво у вежбанци за испите. Није дозвољено имати поред себе друге листове папира.
Водити рачуна о уредности. Решења задатака навести по горњем редоследу. Препоручује се рад обичном графитном оловком.

Решење задатка 2 (⇒ поставка | почетак)

#include <iostream>
#include <cstdlib>
using namespace std;

/////////////////// NIJE DEO RESENJA KOLOKVIJUMA ////////////////////
class Etapa {                                                      //
  float duz, brz;                                                  //
public:                                                            //
  Etapa () { duz = brz = 0; }                                      //
  Etapa(float d, float b) { duz = d, brz = b; }                    //
  float duzina() const { return duz; }                             //
  float brzina() const { return brz; }                             //
  float vreme () const { return duz / brz; }                       //
};                                                                 //
                                                                   //
class Voznja {                                                     //
  Etapa* niz;                                                      //
  int kap, duz;                                                    //
  void kopiraj(const Voznja& v);                                   //
  void brisi() { delete [] niz; }                                  //
public:                                                            //
  explicit Voznja(int k=10) {                                      //
    niz = new Etapa [kap = k];                                     //
    duz = 0;                                                       //
 }                                                                 //
  Voznja(const Voznja& v) { kopiraj(v); }                          //
  ~Voznja() { brisi(); }                                           //
  Voznja& operator= (const Voznja& v) {                            //
    if (this != &v) { brisi(), kopiraj(v); }                       //
    return *this;                                                  //
  }                                                                //
  Voznja& dodaj(const Etapa& e){                                   //
    if (duz == kap) exit(1);                                       //
    niz[duz++] = e;                                                //
    return *this;                                                  //
  }                                                                //
  float duzina() const;                                            //
  float trajanje() const;                                          //
  float srBrzina() const { return duzina() / trajanje();}          //
};                                                                 //
                                                                   //
void Voznja::kopiraj(const Voznja& v) {                            //
  niz = new Etapa [kap=v.kap];                                     //
  duz = v.duz;                                                     //
  for (int i=0; i<duz; i++) niz[i] = v.niz[i];                     //
}                                                                  //
                                                                   //
float Voznja::duzina() const {                                     //
  float d = 0;                                                     //
  for (int i=0; i<duz; d+=niz[i++].duzina());                      //
  return d;                                                        //
}                                                                  //
                                                                   //
float Voznja::trajanje() const{                                    //
  float t = 0;                                                     //
  for (int i=0; i<duz; t+=niz[i++].vreme());                       //
  return t;                                                        //
}                                                                  //
/////////////////// NIJE DEO RESENJA KOLOKVIJUMA ////////////////////

class Vozilo {
  float sopTez;
public:
  Vozilo(float tez) { sopTez = tez; }
  virtual ~Vozilo() {}
  virtual const char* vrsta() const =0;
  virtual float tezina() const
    { return sopTez; }
protected:
  virtual void pisi (ostream& it) const { it << vrsta() << ' ' << sopTez; }
  friend ostream& operator<<(ostream& it, const Vozilo& v)
    { v.pisi(it); return it; }
};

class Bicikl: public Vozilo {
public:
  explicit Bicikl(float tez): Vozilo(tez) {}
  const char* vrsta() const { return "Bicikl"; }
};

class GPretovaren {};
inline ostream& operator<<(ostream& it, const GPretovaren&)
  { return it << "*** Kamion je pretovaren!"; }

class Kamion: public Vozilo {
  float nos, tov;
public:
  Kamion(float sTez, float ns): Vozilo(sTez)
    { nos = ns; tov = 0; }
  const char* vrsta() const { return "Kamion"; }
  float tezina() const { return Vozilo::tezina() + tov; }
  Kamion& operator+=(float tv){
    if (tov+tv > nos) throw GPretovaren();
    tov += tv;
    return *this;
  }
  Kamion& operator-=(float tv){
    tov -= tv;
    if (tov<0) tov = 0;
    return *this;
  }
private:
  void pisi(ostream& it) { Vozilo::pisi(it); it << ' ' << tov; }
};

class GNizPun {};
inline ostream& operator<<(ostream& it, const GNizPun&)
  { return it << "*** Niz je pun!"; }

class GIndeks {};
inline ostream& operator<<(ostream& it, const GIndeks&)
  { return it << "*** Nedozvoljen indeks!"; }

template <typename T>
class Niz {
  T* niz; int kap, duz;
  void kopiraj(const Niz& n);
  void brisi() { delete [] niz; }
public:
  explicit Niz(int k=20) {
    niz = new T [kap = k];
    duz = 0;
  }
  Niz(const Niz& n) { kopiraj(n); }
  ~Niz() { brisi(); }
  Niz& operator=(const Niz& n){
    if (this!=&n) { brisi(); kopiraj(n); }
    return *this;
  }
  int duzina() const { return duz; }
  Niz& operator+=(const T& e) {
    if (duz == kap) throw GNizPun();
    niz[duz++] = e;
    return *this;
  }
  T& operator[](int i) {
    if (i<0 || i>=duz) throw GIndeks();
    return niz[i];
  }
  const T& operator[](int i) const {
    if (i<0 || i>=duz) throw GIndeks();
    return niz[i];
  }
};

template <typename T>
void Niz<T>::kopiraj (const Niz& n) {
  niz = new T [kap = n.kap];
  duz = n.duz;
  for (int i=0; i<duz; i++) niz[i] = n.niz[i];
}

class TrkackiAuto: public Vozilo {
  Niz<Voznja> voznje;
public:
  TrkackiAuto(float sTez): Vozilo(sTez), voznje(10) {}
  const char* vrsta() const { return "Trkacki auto"; }
  TrkackiAuto& novaVoznja () {
    voznje += Voznja(100);
    return *this;
  }
  TrkackiAuto& dodajEtapu (const Etapa& e){
    voznje[voznje.duzina()-1].dodaj(e);
    return *this;
  }
  const Voznja& najbrza() const;
private:
  void pisi (ostream& it)const { Vozilo::pisi(it); it << ' ' << najbrza().duzina(); }
};

const Voznja& TrkackiAuto::najbrza()const{
  double max = voznje[0].srBrzina();
  int imax = 0;
  for (int i=1; i<voznje.duzina(); i++){
    double m = voznje[i].srBrzina();
    if (m > max) { max = m; imax = i; }
  }
  return voznje[imax];
}

/////////////////// NIJE DEO RESENJA KOLOKVIJUMA ////////////////////
void main () {                                                     //
  try {                                                            //
    TrkackiAuto t(500);                                            //
    t.novaVoznja()                                                 //
     .dodajEtapu(Etapa(100,50))                                    //
     .dodajEtapu(Etapa(200,80))                                    //
     .dodajEtapu(Etapa(150,70))                                    //
     .novaVoznja()                                                 //
     .dodajEtapu(Etapa(300,70))                                    //
     .dodajEtapu(Etapa(150,60))                                    //
     .dodajEtapu(Etapa(200,70))                                    //
    ;                                                              //
    cout << t << endl;                                             //
    const Voznja& v = t.najbrza();                                 //
    cout << v.duzina() << ' ' << v.trajanje() << ' '               //
         << v.srBrzina() << endl;                                  //
  } catch (GPretovaren g) { cout << g << endl;                     //
  } catch (GNizPun g) { cout << g << endl;                         //
  } catch (GIndeks g) { cout << g << endl;                         //
  }                                                                //
}                                                                  //
/////////////////// NIJE DEO RESENJA KOLOKVIJUMA ////////////////////

Trkacki auto 500 450
450 6.64286 67.7419

(⇒ почетак)

← ↑ ⇑ ↓ →

Аутор: Ласло Краус
Е-пошта: kraus@etf.rs