Ласло Краус	ИР2ОО1 Испит 11. 2. 2005.

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

Реализовати на језику C++ следећи систем класа (класе опремити оним конструкторима, деструктором и оператором за доделу вредности, који су потребни):

• (4 поена) Вектор у простору се задаје помоћу компонената v_x, v_y и v_z (подразумевано (1,0,0)). Могуће је дохватити компоненте вектора и уписивати вектор у датотеку (d<<v) у облику [v_x,v_y,v_z].
• (4 поена) Тачка у простору се задаје помоћу координата x, y и z (подразумевано (0,0,0)). Могуће је дохватити координате тачке, померити тачку за неки вектор помака (t+=v) и уписивати тачку у датотеку (d<<t) у облику (x,y,z).
• (7 поена) Апстрактни елемент се задаје помоћу референтне тачке у простору. Могуће је створити динамичку копију елемента, преместити га у нову тачку (e=t), померити га за неки вектор помака (e+=v), израчунати му запремину (!e) и уписивати га у датотеку (d<<e) у облику (x,y,z).
• (5 поена) Сфера је елемент за који се додатно задаје полупречник (V=4r³π/3). У датотеку се пише у облику S{(x,y,z),r}.
• (7 поена) Апстрактни оријентисани елемент је елемент за који се додатно задаје вектор оријентације. Могуће је променти вектор оријентације (oe=v). У датотеку се пише у облику (x,y,z)[v_x,v_y,v_z].
• (5 поена) Ваљак је оријентисани елемент за који се додатно задаје полупречник основице и висина (V=r²πh). У датотеку се пише у облику V{(x,y,z)[v_x,v_y,v_z],r,h}.
• (14 поена) Структура је оријентисани елемент који може да садржи задати број елемената. Координате и оријентација садржаних елемената су релативне у односу на структуру. Ствара се празна задатог капацитета (подразумевано 5), после чега могу да се додају елементи (s+=e). Структура се у датотеку пише у облику <(x,y,z)[v_x,v_y,v_z],e,e,…,e>, где су e резултати писања садржаних елемената.
• (16 поена) Робот има име и садржи једну структуру елемената. Све радње над структуром су могуће и над роботом. Може да се упише у датотеку (d<<r) у облику ime:s, где је ime име робота, а s резултат писања садржане структуре. Сви роботи морају да имају различита имена. Не сме да се ствара копија робота ни на који начин.

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

(8 поена) Написати на језику C++ главни програм који састави пример робота са фиксним параметрима (није потребно учитавање делова са главног улаза), испише на главни излаз састављеног робота, заједно са његовом запремином.

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

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

а) Да ли је могуће имати референцу (упућивач) на показивач и показивач на референцу? Зашто?

б) Објаснити зашто наведена конструкција није исправна:

      class A { int i; public: A(int ii){i=ii;} };
      class B: public A { int j; public: B(int jj){j=jj;} };

в) Да ли конструктор може бити виртуелна функција и зашто?

г) Да ли виртуелна метода може да промени throw() листу методе из базне класе и како?

д) Како се може спречити аутоматско генерисање функције из шаблона?

Поставка задатка 3 (25 поена – допуна уместо лабораторијских вежби) (⇒ почетак)

Пројектовати на језику C++ следећи систем класа (класе опремити оним конструкторима, деструктором и оператором за доделу вредности, који су потребни):

• Апстрактном предмету може да се одреди величина (унарни +, реалан број) и да се подаци о предмету уписују у датотеку (<<).
• Збирка може да садржи одређени број предмета и може да се иницијализује задатим капацитетом, да јој се дода нови предмет (+=; ако нема места у збирци, пријавити изузетак), да се упише њен садржај у датотеку (<<, сваки предмет у новом реду), да се израчуна збир величина предмета у збирци (унарни +) и да се уништи.
• Ставка рачуна је предмет који садржи назив артикла, јединичну цену и количину, може да се иницијализује наведеним подацима и да се уништи, а (величину предмета” представља вредност робе у ставци.
• Рачун је збирка ставки рачуна допуњена именом купца и датумом куповине, може да се иницијализује наведеним подацима као празан рачун задатог капацитета, да се уништава, а испис садржи име купца, датум куповине, списак ставки и укупну вредност робе.

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

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

class Vektor {
  double vx, vy, vz;
public:
  Vektor (double vvx=1, double vvy=0, double vvz=0) { vx = vvx; vy = vvy, vz = vvz; }
  double dohvatiVx () const { return vx; }
  double dohvatiVy () const { return vy; }
  double dohvatiVz () const { return vz; }
  friend ostream& operator<< (ostream& d, const Vektor& v)
    { return d << '[' << v.vx << ',' << v.vy << ',' << v.vz << ']'; }
};

class Tacka {
  double x, y, z;
public:
  Tacka (double xx=0, double yy=0, double zz=0) { x = xx; y = yy, z = zz; }
  double dohvatiX () const { return x; }
  double dohvatiY () const { return y; }
  double dohvatiZ () const { return z; }
  Tacka& operator+= (const Vektor& v) {
    x += v.dohvatiVx(); y += v.dohvatiVy(); z += v.dohvatiVz();
    return *this;
  }
  friend ostream& operator<< (ostream& d, const Tacka& t)
    { return d << '(' << t.x << ',' << t.y << ',' << t.z << ')'; }
};

class Element {
  Tacka t;
public:
  Element (const Tacka& tt): t (tt) {}
  virtual ~Element () {}
  virtual Element* kopija () const =0;
  virtual Element& operator=  (const Tacka&  tt) { t = tt;  return *this; }
  virtual Element& operator+= (const Vektor& vv) { t += vv; return *this; }
  virtual double operator! () const =0;
protected:
  virtual void pisi (ostream& d) const { d << t; }
  friend ostream& operator<< (ostream& d, const Element& e) { e.pisi (d); return d; }
};

class Sfera: public Element {
  double r;
  void pisi (ostream& d) const { d << "S{"; Element::pisi (d); d << ',' << r  << '}'; }
public:
  Sfera (const Tacka& tt, double rr): Element (tt) { r = rr; }
  Sfera& operator= (const Tacka& t) { Element::operator= (t); return *this; }
  Sfera* kopija () const { return new Sfera (*this); }
  double operator! () const { return 4 * r*r*r * 3.14159 / 3; }
};

class OElement: public Element {
  Vektor v;
public:
  OElement (const Tacka& tt, const Vektor& vv): Element (tt), v (vv) {}
  OElement& operator= (const Tacka& t) { Element::operator= (t); return *this; }
  virtual OElement& operator= (const Vektor& vv) { v = vv; return *this; }
protected:
  void pisi (ostream& d) const { Element::pisi (d); d << v; }
};

class Valjak: public OElement {
  double r, h;
  void pisi (ostream& d) const
    { d << "V{"; OElement::pisi (d); d << ',' << r << ',' << h << '}'; }
public:
  Valjak (const Tacka& tt, const Vektor& vv, double rr, double hh): OElement (tt, vv)
    { r = rr; h = hh; }
  Valjak& operator= (const Tacka& t) { OElement::operator= (t); return *this; }
  Valjak& operator= (const Vektor& v) { OElement::operator= (v); return *this; }
  Valjak* kopija () const { return new Valjak (*this); }
  double operator! () const { return r*r * 3.14159 * h; }
};

class GStrPuna {};

inline ostream& operator<< (ostream& d, const GStrPuna&)
  { return d << "*** Struktura je puna!\n"; }

class Struktura: public OElement {
  Element** niz;
  int kap, duz;
  void kopiraj (const Struktura&);
  void brisi ();
  void pisi (ostream&) const;
public:
  Struktura (const Tacka& t, const Vektor& v, int k=5): OElement (t, v)
    { niz = new Element* [kap = k]; duz = 0; }
  Struktura (const Struktura& s): OElement (s) { kopiraj (s); }
  ~Struktura () { brisi (); }
  Struktura& operator= (const Struktura& s) {
    if (this != &s) { brisi (); OElement::operator= (s); kopiraj (s); }
    return *this;
  }
  Struktura& operator= (const Tacka& t)  { OElement::operator= (t); return *this; }
  Struktura& operator+=(const Vektor& v) { OElement::operator+=(v); return *this; }
  Struktura& operator= (const Vektor& v) { OElement::operator= (v); return *this; }
  Struktura* kopija () const { return new Struktura (*this); }
  Struktura& operator+= (const Element& e) {
    if (duz == kap) throw GStrPuna ();
    niz[duz++] = e.kopija ();
    return *this;
  }
  double operator! () const;
};

void Struktura::kopiraj (const Struktura& s) {
  niz = new Element* [kap = s.kap]; duz = s.duz;
  for (int i=0; i<duz; i++) niz[i] = s.niz[i]->kopija ();
}

void Struktura::brisi () {
  for (int i=0; i<duz; delete niz[i++]); delete [] niz;
}

void Struktura::pisi (ostream& d) const {
  d << '<'; OElement::pisi (d);
  for (int i=0; i<duz; i++)  d << ',' << *niz[i];
  d << '>';
}

double Struktura::operator! () const {
  double v = 0;
  for (int i=0; i<duz; v+=!*niz[i++]);
  return v;
}

class GImePostoji {};

inline ostream& operator<< (ostream& d, const GImePostoji&)
  { return d << "*** Vec postoji ime robota!\n"; }

class Robot {
  Struktura s;
  struct Elem {
    Robot* rbt; Elem* sled;
    Elem (Robot* r, Elem* s) { rbt = r; sled = s; }
  };
  static Elem* prvi;
  char* ime;
  Robot (const Robot&): s(Tacka(), Vektor()) {}
  void operator= (const Robot&) {}
public:
  Robot (char* i, const Tacka& t, const Vektor& v,int kap=5);
  ~Robot ();
  Robot& operator=  (const Tacka& t)   { s = t; return *this;  }
  Robot& operator+= (const Vektor& v)  { s += v; return *this; }
  Robot& operator=  (const Vektor& v)  { s = v; return *this;  }
  Robot& operator+= (const Element& e) { s += e; return *this; }
  double operator! () const { return !s; }
  friend ostream& operator<< (ostream& d, const Robot& r)
   { return d << r.ime << ':' << r.s; }
};

Robot::Elem* Robot::prvi = 0;

Robot::Robot (char* i, const Tacka& t, const Vektor& v,int kap): s (t, v, kap) {
  Elem* tek = prvi;
  while (tek && strcmp(tek->rbt->ime,i)!=0) tek = tek->sled;
  if (tek) throw GImePostoji ();
  ime = new char [strlen(i)+1]; strcpy (ime, i);
  prvi = new Elem (this, prvi);
}

Robot::~Robot () {
  Elem *tek = prvi, *pret = 0;
  while (strcmp(tek->rbt->ime,ime)!=0) { pret = tek; tek = tek->sled; }
  (!pret ? prvi : pret->sled) = tek->sled;
  delete tek; delete [] ime;
}

int main () {
  try {
    Robot r ("Robot", Tacka(1,2,3), Vektor(), 10);
    r += Sfera (Tacka(1,1), 3);
    r += Valjak (Tacka(2,0,3), Vektor(-2,0,5), 1, 3);
    Struktura s (Tacka(-1,-2,-3), Vektor(-1), 5);
    s += Sfera (Tacka(5), 1);
    s += Valjak (Tacka(), Vektor(0,-2), 3, 2);
    r += s;
    cout << r << " V=" << !r << endl;
  } catch (GStrPuna g) {
    cout << g << endl;
  } catch (GImePostoji g) {
    cout << g << endl;
  }
}

Copyright © 2010, Laslo Kraus
Последња ревизија: 30.8.2010.