NEPTUN kód: NÉV: Aláírás: Programozás 2. NZH, 2017. május 11. BME-TTK, fizika BSc Arcképes igazolvány hiányában nem kezdheted meg a ZH-t. A feladatok megoldására összesen 90 perc áll rendelkezésre. A feladatlapot névvel ellátva akkor is be kell adni, ha semmilyen megoldást sem készítettél. Minden feladatmegoldást külön lapra írj! Minden lapra írd fel a neved és a neptun kódod, valamint a feladat sorszámát! Ezek hiányában a feladatot nem értékeljük. Szabványos C++98/11 megoldásokat értékelünk csak. feladat pont min elért 1. 10 2. 10 3. 10 4. 10 40 14..13 elégtelen, 14..20 elégséges, 21..27 közepes, 28..34 jó, 35.. jeles A feladatokban szükség lesz az alábbi két osztályra: Az alább felsorolt, kívülről is elérhető tagfüggvényekkel rendelkező Alkalmazott osztály. Kívülről el nem érhető (a leszármazott számára sem) módon, megfelelő típusú tagváltozókban tárolja a nevet, és az alapfizetést. Alkalmazott(std::string nev, int alapfizetes); std::string getnev()const; int getfizetes()const; virtual ~Alkalmazott(); Az alább felsorolt, kívülről is elérhető tagfüggvényekkel rendelkező Rac osztály. Az osztály egy racionális számot reprezentál. Kívülről el nem érhető módon, int típusban tárolja a sz és n komponenst. Nem egyszerűsített alakot tárol. Rac(int sz, int n); int getsz()const; int getn()const; Rac sqr()const; //szam negyzete 1. feladat: Öröklés, sablonok (2 5 p) a) Származtass Vezeto osztályt az Alkalmazott osztályból! A vezető többlettulajdonsága az alkalmazotthoz képest a megnövelt fizetés, ami egy valós szorzót jelent az alapfizetéshez. Készíts konstruktort, mely beállítja az összes tagváltozót, valamint getfizetes függvényt, amely a szorzo alapf izetes értéket adja vissza. Lehessen változtatni is a nem publikus szorzót. Az Alkalmazott osztályt nem módosíthatod. Írd meg a tesztelő kétsoros kódrészletét, melyben létrehozol egy vezetőt, és kiírod a nevét, fizetését. class Vezeto : public Alkalmazott double szorzo; Vezeto(std::string nev, int alap, double szorzo) :Alkalmazott(nev,alap), szorzo(szorzo) int getfizetes() const return szorzo * Alkalmazott::getfizetes(); void setszorzo(double sz) szorzo = sz; ; Vezeto c(234.3, 5, 2); std::cout<<c.getnev()<<c.getfizetes(); b) Készítsd el a megadott Rac osztály sablon változatát, ahol a sablonparaméter a tagváltozók típusát adja! (A tagfüggvények implementációját is írd meg.) Hibás adatra nem kell figyelned. Egysoros példával (long-okkal reprezentált racionális szám változó) mutasd meg a sablon használatát. template <class T> class Rac
T sz, n; Rac(T sz=t(), T n=t(1)) :sz(sz), n(n) T getsz()const return sz; T getn()const return n; Rac sqr()const return Rac(sz * sz,n * n); ; Rac<long> r1; 2. feladat: Operátorok Egészítsd ki a fent megadott Rac osztályt a következő operátorokkal. Amit lehetséges, tagfüggvényként valósítsd meg, ami lehet, legyen konstans. Mindegyik operátor a racionális számoktól, valamint az adott operátortól megszokott/elvárható módon viselkedjen. Figyelj oda, hogy nincs sem default ctor, sem egyszerűsítő függvény. Tipp: Az ekvivalencia operátornál pl. "keresztbe szorozva" hasonlíthatsz. Rac + Rac, Rac * = Rac, - Rac, Rac == Rac, int / Rac, std::istream-ről olvasó >> (két egész számot olvasson, melyek szóközzel vannak elválasztva) és (double) Rac (típuskonverzió operátor valósra). A Rac osztálynak a feladatok felett felsorolt tagfüggvényeit nem kell megírnod, elegendő kipontoznod deklarációjuk helyét az osztályban. (...) Készíts rövid main függvényt, melyben bemutatod valamennyi operátor használatát! class Rac... Rac operator+(const Rac& rhs)constreturn Rac(sz * rhs.n+n * rhs.sz,n * rhs.n); const Rac& operator * =(const Rac& rhs)sz * =rhs.sz;n * =rhs.n;return * this; Rac operator-()constreturn Rac(-sz,n); bool operator==(const Rac& rhs)constreturn sz * rhs.n==n * rhs.sz; operator double()constreturn (double)sz/n; ; Rac operator/ (int k, const Rac& rhs) return Rac(k * rhs.getn(),rhs.getsz()); std::istream& operator>>(std::istream& is, Rac& rhs) int sz,n; is>>sz>>n; rhs=rac(sz,n); return is; Rac r1=rac(3,2), r2(2,4); r1=r1+r2; r2 * =r1;
r1=-r1; std::cin>>r2; if(r1==r2) r2=5/r2; std::cout<<(double)(r1)<<std::endl; 3. feladat: Tároló Készíts egész (int) értékeket tárolni képes várakozási sor osztályt! A várakozási sor egy First-In-First-Out tároló, mely tetszőlegesen sok értéket tud tárolni. A sorhoz új elemet hozzáadni csak az elejére a berak, elemet kivenni csak a végéről a kivesz tagfüggvénnyel lehet. Az ures_e függvény logikai igaz értékkel jelzi, ha nincs elem a sorban. Az elkészített osztály a következőket kell tudja: dinamikus tömbben tárolja az egész értékeket (nem használhatsz STL tárolót). Írd meg a paraméter nélküli alapértelmezett konstruktort, destruktort, másoló konstruktort és az értékadó operátort! Írd meg a berak és az ures_e függvényt is. A kivesz függvényt nem kell elkészítened, de feltételezheted, hogy létezik, és ha kell, használhatod. Írj két kódrészletet, melyben bemutatod a várakozási sor használatát: 1. készíts egy üres tárolót, majd rakj bele pár elemet. 2. Másold le a tárolót egy új objektumba, majd ürítsd ki a másolatot, közben írd ki az értékeket a szabványos kimenetre. A tárolt elemek száma nem ismert, mert közben más programrész módosíthatta! #include <iostream> #include <stdexcept> class Fifo int elemszam; int * adat; Fifo():elemSzam(0),adat(NULL) Fifo(const Fifo &m) adat=null; * this=m; const Fifo& operator=(const Fifo &m) if(this!=&m) elemszam=m.elemszam; adat=new int[elemszam]; for(int i=0;i!=elemszam;++i) adat[i]=m.adat[i]; return * this; ~Fifo() bool ures_e()const return elemszam==0; void berak(int elem) int * t=new int[elemszam+1];
for(int i=0;i!=elemszam;++i) t[i+1]=adat[i]; t[0]=elem; adat=t; ++elemszam; return t; int kivesz() // ez nem kellett if(elemszam==0) throw std::underflow_error("hiba: ures Fifo"); int * t=new int[elemszam-1],v=adat[elemszam-1]; for(int i=0;i!=elemszam-1;++i) t[i]=adat[i]; adat=t; --elemszam; return t; ; try Fifo h,g; h.berak(3); h.berak(2);... g=h; while(! g.ures_e()) std::cout<<g.kivesz(); catch(std::exception &e) std::cerr<<e.what(); 4. feladat: STL Egy kísérlet során egy motort vizsgálunk. A motor közvetlenül hajt egy kerekeken gördülő testet, a mozgáspálya egyenes, a test álló helyzetből indul, gördülési ellenállással nem kell foglalkoznunk. A mérőberendezés tizedmásodpercenként a programunk szabványos bemenetére küldi az általa mért pozíció értékeket cm-ben mérve. Előre nem tudjuk, hogy hány érték fog érkezni. A mérés végét negatív érték jelzi, ez nem valódi mérési eredmény, tehát ne tároljuk el a többivel! Készíts programot, amely egy std::vector-ban tárolja a mért pozíció értékeket. a) Olvasd be, és tárold el a mért értékeket (x). b) Hozz létre egy újabb vector-t a pillanatnyi sebességek számára! Számítsd ki és tárold el a vectorban a sebességeket (v = dx/dt, a kiadódó dm/s egységben)! c) Hasonló módon számítsd ki a gyorsulás értékeit is (a = dv/dt, m/s 2 ). Ha a deriváláshoz STL algoritmust használsz, és ezt helyesen teszed, +1 bónuszpontot kapsz. d) Határozd meg, és írd ki, hogy milyen sebesség mellett fejtette ki a legnagyobb gyorsító erőt a motor. Ha STL algoritmust használsz, és ezt helyesen teszed, +1 bónuszpontot kapsz. e) Határozd meg, és írd ki a pillanatnyi gyorsulás értékek (egyszerű) átlagát. Ha STL algoritmust használsz, és ezt helyesen teszed, +1 bónuszpontot kapsz.
#include <iostream> #include <vector> #include <algorithm> #include <numeric> double xx; std::vector<double> x; std::cin>>xx; while(xx>=0) x.push_back(xx); std::cin>>xx; std::vector<double> v(x.size()); std::adjacent_difference(&x[0],&x[x.size()],&v[0]); // +1p vagy std::adjacent_difference(x.begin(),x.end(),v.begin()); // +1p vagy v[0]=x[0]; for(unsigned j=1u;j<x.size();++j) v[j]=x[j]-x[j-1]; std::vector<double> a(v.size()); std::adjacent_difference(v.begin(),v.end(),a.begin()); double * p=std::max_element(&a[0],&a[a.size()]); // +1p vagy std::cout<<v[p-&a[0]]<< \n ; std::vector<double>::iterator i=std::max_element(a.begin(),a.end()); // +1p vagy std::cout<<v[i-a.begin()]<< \n ; unsigned maxpos=0; for(unsigned i=1u;i!=a.size();++i) if(a[maxpos]<a[i])maxpos=i; std::cout<<v[maxpos]<< \n ; std::cout<<std::accumulate(a.begin(), a.end(), 0.0)/a.size(); // +1p vagy (ez trivi)