Kodused ülesanded
Selle kodutöö jaoks vajalikud lipud: -std=c++20 -Wall -Werror -Wpedantic
Esitada on vaja järgmised failid:
arvutused.h arvutused.cpp punkt2.h punkt2.cpp joon2.h joon2.cpp
ring2.h ring2.cpp.
Nimede valideerimiseks kasuta järgmist main.cpp faili.
#include <concepts>
#include <string>
#include "arvutused.h"
#include "punkt2.h"
#include "joon2.h"
#include "ring2.h"
template <typename T, typename Float_T, typename Pointer_type>
concept KorrektnePunkt2 = requires(T &punkt, std::ostream &out) {
{ punkt.x };
{ punkt.y };
{ T{} };
{ T{Float_T{}, Float_T{}} };
{ punkt.kaugus(Pointer_type{}) } -> std::same_as<float>;
{ out << punkt } -> std::same_as<std::ostream &>;
};
static_assert(KorrektnePunkt2<Punkt2, float, Punkt2 *>, "Point2 klass on katki");
static_assert(std::is_default_constructible_v<Punkt2>,
"Punkt2 klassis peab olema vaikekonstruktor");
template <typename T, typename Point_T>
concept KorrektneJoon2 = requires(T &line2, std::ostream &out) {
{ line2.p1 };
{ line2.p2 };
{ T{Point_T{}, Point_T{}} };
{ line2.pikkus() } -> std::same_as<float>;
{ out << line2 } -> std::same_as<std::ostream &>;
};
static_assert(KorrektneJoon2<Joon2, Punkt2 *>, "Joon2 klass katki");
static_assert(std::is_default_constructible_v<Joon2> == false,
"Joon2 klassis ei tohi olla vaikekonstruktorit");
template <typename T, typename Float_T, typename Bool_T, typename Punkt2_T,
typename Joon2_T>
concept KorrektneRing2 = requires(T &circle2, std::ostream &out) {
{ circle2.p1 };
{ circle2.r };
{ T{Punkt2_T{}, Float_T{}} };
{ circle2.ymberm66t() } -> std::same_as<float>;
{ circle2.pindala() } -> std::same_as<float>;
{ circle2.onAlas(Punkt2_T{}) } -> std::same_as<bool>;
{ circle2.onAlas(Joon2_T{}) } -> std::same_as<bool>;
{ circle2.skaleeri(Float_T{}) };
{ out << circle2 } -> std::same_as<std::ostream &>;
};
static_assert(
KorrektneRing2<Ring2, float, bool, Punkt2 *, Joon2 *>,
"Ring2 klassi definitsioon on vigane. Vaata üle funktsiooninimed, "
"argumentide ja tagastusväärtuste tüüp");
static_assert(std::is_default_constructible_v<Ring2> == false,
"Ring2 klassis ei tohi olla vaikekonstruktorit");
template <typename T1>
concept suurim_funktsioonid =
requires(T1 *a_ptr, T1 *b_ptr, T1 *c_ptr, T1 *ret_ptr, T1 &a_ref, T1 &b_ref,
T1 &c_ref, T1 &ret_ref) {
{ suurim(a_ptr, b_ptr, c_ptr) } -> std::same_as<int>;
{ suurim(a_ref, b_ref, c_ref) } -> std::same_as<int>;
{ suurim(a_ref, b_ptr, c_ptr) } -> std::same_as<int>;
{ suurim(a_ptr, b_ptr, c_ptr, ret_ptr) } -> std::same_as<void>;
{ suurim(a_ref, b_ref, c_ref, ret_ref) } -> std::same_as<void>;
};
template <typename T1, typename T2>
concept suurim_mallifunktsioonid =
requires(T1 *a_ptr, T1 *b_ptr, T1 *c_ptr, T1 *ret_ptr, T1 &a_ref, T1 &b_ref,
T1 &c_ref, T1 &ret_ref, T2 *a_ptr2, T2 *b_ptr2, T2 *c_ptr2,
T2 *ret_ptr2, T2 &a_ref2, T2 &b_ref2, T2 &c_ref2, T2 &ret_ref2) {
{ tSuurimP(a_ptr, b_ptr, c_ptr) } -> std::same_as<T1>;
{ tSuurimR(a_ref, b_ref, c_ref) } -> std::same_as<T1>;
{ tSuurimP(a_ptr2, b_ptr2, c_ptr2) } -> std::same_as<T2>;
{ tSuurimR(a_ref2, b_ref2, c_ref2) } -> std::same_as<T2>;
};
static_assert(suurim_funktsioonid<int>, "suurim funktsioonid katki");
template <typename Vigane>
concept suurim_mallifunktsioonid_vigane =
requires(Vigane *a_ptr, Vigane *b_ptr, Vigane *c_ptr, Vigane *ret_ptr,
Vigane &a_ref, Vigane &b_ref, Vigane &c_ref, Vigane &ret_ref) {
{ tSuurimP(a_ptr, b_ptr, c_ptr) } -> std::same_as<Vigane>;
{ tSuurimR(a_ref, b_ref, c_ref) } -> std::same_as<Vigane>;
};
static_assert(suurim_mallifunktsioonid<int, float>,
"suurim funktsioonid katki");
static_assert(suurim_mallifunktsioonid_vigane<std::string> == false,
"Mallifunktsioonid võtavad argumentideks sõne. Vigane.");
int main(int argc, char *argv[]) { return 0; }
1. Üledefineeritud funktsioonid
Selle ülesande funktsioonide deklaratsioonid ja definitsioonid pane vastavalt failidesse faili arvutused.h ja arvutused.cpp.
Koosta funktsioonid kolmest täisarvust suurima leidmiseks järgmiste signatuuride jaoks:
int suurim(int*, int*, int*);
int suurim(int&, int&, int&);
int suurim(int&, int*, int*);
void suurim(int*, int*, int*, int*); //neljas parameeter on suurima jaoks
void suurim(int&, int&, int&, int&); //neljas parameeter on suurima jaoks
Võib kasutada päist <cmath>. Katseta kõiki funktsioone main funktsioonis.
Näiteks, koodijupi
int a{2}, b{8}, c{5};
cout << "suurim = " << suurim(&a, &b, &c) << '\n';
tulemusena kuvatakse ekraanile suurim = 8.
Koosta funktsioonimallid kahe esimese funktsiooni jaoks. Nimed vastavalt tSuurimP, tSuurimR), mis töötaksid arvulise tüübi korral (funktsiooni kõik parameetrid on sama tüüpi).
NB! Funktsioonimall peab tervenisti olema päisefaili sees!
2. Geomeetria
Selles ülesandes palun ära muuda klassi liikmete nimesid ja hoia nad avalikud.
2.1. Punkt
Failides punkt2.h ja punkt2.cpp on klassi Punkt2 definitsioon. Klass Punkt2 määrab kahemõõtmelises ruumis punkti, millel on kaks float tüüpi koordinaati x ja y.
| Meetod | Eesmärk |
|---|---|
Punkt2 () | algväärtustab koordinaadid nullidega |
Punkt2 (float nx, float ny) | parameetritega konstruktor – väärtustab koordinaadid |
float kaugus (Punkt2* p) | tagastab punkti kauguse etteantud punktist tasandil |
operator << | kuvab ekraanile punkti koordinaadid kujul (x, y) |
Kahe punkti vahelise kauguse valemit vt
https://opiobjektid.tptlive.ee/joonevorrandid/kahe_punkti_vaheline_kaugus.html.
2.2. Sirglõik
Failides joon2.h ja joon2.cpp on klassi Joon2 definitsioon. Klass Joon2 kirjeldab sirglõiku kahe otspunkti *p1 ja *p2 abil. Klassis Joon2 ei tohi olla vaikekonstruktorit.
| Meetod | Eesmärk |
|---|---|
Joon2 (Punkt2* np1, Punkt2* np2) | parameetritega konstruktor – väärtustab klassi elemendid |
float pikkus () | tagastab sirglõigu pikkuse (kasuta punkti meetodit kaugus) |
operator << | kuvab ekraanile sirglõigu andmed kujul (p1 - p2) |
2.3. Ring
Failides ring2.h ja ring2.cpp on klassi Ring2 definitsioon. Klass Ring2 esitab tasandil asuvat ringi keskpunktiga *p1 ja mittenegatiivse raadiusega r. Raadiuse mittenegatiivsust tuleb jälgida kõikides funktsioonides (konstruktor, skaleerimine). Kui kasutaja annab ette negatiivse raadiuse konstruktoris, siis asenda see nulliga. Kui kasutaja soovib skaleerida negatiivse väärtusega, siis ei tee midagi. Klassis Ring2 ei tohi olla vaikekonstruktorit.
| Meetod | Eesmärk |
|---|---|
Ring2 (Punkt2* np1, float nr) | parameetritega konstruktor – väärtustab klassi elemendid |
float ymberm66t() | tagastab ringi ümbermõõdu |
float pindala() | tagastab ringi pindala |
bool onAlas(Punkt2* p) | tagastab true, kui punkt on ringjoone peal või sees, vastasel juhul false (kasuta punkti meetodit kaugus) |
bool onAlas(Joon2* l) | tagastab true, kui lõik on ringjoone sees (sh tipud joone peal või ringi sees), vastasel juhul false (kasuta meetodit kaugus) |
void skaleeri (float factor) | korrutab ringi raadiuse antud väärtusega |
operator << | kuvab ekraanile ringi andmed kujul (p1, r) |