Szorgalmi feladatok

A feladatok megoldásai az admin portálon adhatók be. A szorgalmi feladatokkal egy pontversenyben is részt lehet venni. Alapbeállítás szerint anonim módon jelensz meg a táblázatban. Ha szeretnél névvel megjelenni vagy teljesen eltűnni, az admin portálon beállíthatod.

A verseny állásának megtekintéséhez is be kell jelentkezni.

Teljes tört osztály

Dolgozd ki az előadáson bemutatott kódot folytatva a teljes tört osztályt C++ nyelven!

Valósítsd meg a + (egyoperandusú), +=, - (egy- és kétoperandusú), -=, *, *=, /, /=, >>, (double) cast operátorokat! Figyelj a referenciák helyes használatra!

Mennyi a legkevesebb új tagfüggvény (szintaktikai értelemben), amennyivel ez megoldható? Oldd meg úgy a feladatot, hogy a lehető legkevesebb legyen!

Figyelj arra, mit jelentenek az „egyoperandusú” és „kétoperandusú” szavak! Ezek nem az operátorokat megvalósító függvények paraméterszámát adják meg. Például egyoperandusú mínusz az ellentett: -x, és kétoperandusú mínusz a kivonás: a-b. Egyoperandusú csillag a dereferálás: *p, kétoperandusú csillag a szorzás: a*b.

Elfogadott megoldások: 14 darab.
Szerezhető: 1 pont. Leadási határidő: 2025-09-14 23:59:00.

Oldd meg a "Morzekódot dekódoló tömb" feladatot a példatárból! https://cpp11.eet.bme.hu/f00/#1 A megoldásod tartalmazza

• a tömbbe rendezett fa kódját kiíró kódrészletet,
• magát a fát, amit a kódod legenerált,
• és a fa felhasználásával morze dekódolást végző főprogramot!

Ha tudod, a fát constexpr is létrehozhatod, az helyettesítheti az 1-2. pontot.

Elfogadott megoldások: 12 darab.
Szerezhető: 1 pont. Leadási határidő: 2025-09-22 04:00:00.

Függvény osztály

Az előadás kifejezésfáival kapcsolatos feladat.

Tervezz és implementálj egy általános függvény osztályt! Hova illik ez be az osztályhierarchiába? Implementálj egy szinusz és egy koszinusz osztályt! Ha ügyesen tervezted meg a függvény osztályt, akkor ezek az összeghez és a szorzathoz hasonlóan pár sorból fognak állni.

Ha kész vannak a függvény, szinusz és koszinusz osztályok, akkor most írd meg azok deriválását is! Figyelj arra, hogy az összetett függvény deriválási szabályát kell alkalmaznod: f(g(x))'=f'(g(x))·g'(x), mert a szinusz vagy a koszinusz objektum is egy kifejezést tartalmaz.

Használd a függvénysablon tervezési mintát! Próbáld meg a függvény osztályban megvalósítani, amit csak lehet, hogy a leszármazottak minél egyszerűbbek legyenek. Onnan tudod, hogy jó a megoldásod, hogy a függvény ősosztály deriváló metódusa a láncszabályt tartalmazva final minősítőt kaphat (és csak ilyen megoldásra jár majd pont). Ugyanez a helyzet a print metódussal.

Elfogadott megoldások: 13 darab.
Szerezhető: 1 pont. Leadási határidő: 2025-09-29 04:00:00.

Számrendszerek

Nézd meg az extrákban az I/O manipulátorokkal kapcsolatos írást! Ez az előadás mértékegységes példájának folytatása. Utána...

a) Írj bináris szám kiíró I/O manipulátort! A használata legyen az alábbi:

std::cout << bin << 0 << std::endl;         /* 0 */
std::cout << bin << 240 << std::endl;       /* 11110000 */

Vajon mi lehet itt a bin típusa?

b) Írj akárhányas számrendszerben kiíró I/O manipulátort!

std::cout << base(2) << 240 << std::endl;   /* 11110000 */
std::cout << base(7) << 240 << std::endl;   /* 462 */
std::cout << base(16) << 240 << std::endl;  /* F0 */

Melyik az első részkifejezés, amit ki kell értékelnie a fordítónak? Indulj ki ebből!

Ügyelj arra, hogy a megvalósításban ne legyen pow() (egész számokkal kell dolgozni, a pow() pedig lebegőpontos számokkal dolgozik, pontatlanság lehet). Ezen kívül, ne legyen std::to_string() se! Legalábbis egyetlen számjegy sztringgé alakítására semmiképp, mivel akkor minden számjegyhez külön std::string objektum jönne létre. Általában véve, mindenféle dinamikus memóriakezelést elkerülhető.

Elfogadott megoldások: 15 darab.
Szerezhető: 1 pont. Leadási határidő: 2025-10-13 04:00:00.

Ha megcsináltad a sztringes házihoz tartozó szorgalmit (csak az egyiket, vagy akár mind a kettőt), azt ide töltheted fel plusz pontért.

Elfogadott megoldások: 1 darab.
Szerezhető: 2 pont. Leadási határidő: 2025-11-02 23:59:00.

Hanoi tornyai

Adott az alábbi forráskód, amely a Hanoi tornyai feladványt oldja meg:

#include <iostream>

void hanoi(int n, char honnan, char seged, char hova) {
    if (n == 0)
        return;
    hanoi(n-1, honnan, hova, seged);
    std::cout << "rakj 1-et: " << honnan << "->" << hova << std::endl;
    hanoi(n-1, seged, honnan, hova);
}

int main() {
    hanoi(4, 'A', 'B', 'C');

    return 0;
}

Hogy lehet megoldani azt, hogy minden lépés mellé ki legyen írva annak sorszáma? Pl. 3 korongra így:

1. lepes: rakj 1-et: A->C
2. lepes: rakj 1-et: A->B
3. lepes: rakj 1-et: C->B
4. lepes: rakj 1-et: A->C
5. lepes: rakj 1-et: B->A
6. lepes: rakj 1-et: B->C
7. lepes: rakj 1-et: A->C

Mutass minél többféle, egymástól eltérő elvű (nem csak szintaktikailag különböző) megoldást! A rekurzió maradjon meg. Mi a megoldásokban a közös?

Figyelj arra, hogy az elkészített függvények használatának módja – lényegében a fejléce – ugyanaz legyen, mint az eredeti függvényé (korongok száma, oszlop1, oszlop2, oszlop3)! Ez persze nem jelenti azt, hogy nem írhatsz segédfüggvényeket ettől eltérő paraméterezéssel. Ne csinálj tárolót, nincs rá szükség: a függvény olyan sorrendben állítja elő a lépéseket, ahogy a kimenetre is azoknak kerülniük kell.

Van két olyan „triviális” módszer, ami nélkül a beküldött kód nem lesz elfogadott. Sajnos ezek nem specifikálhatóak, mert ha a feladatkiírásban szerepelnének, akkor az a megoldást is elárulná egyből. Egyszerűségük miatt sejteni fogod, amikor megtaláltad őket, hogy ezekről van szó. Ha nem, számíts „találj ki még más elvű megoldást” értékelésre. Lásd az előadást is!

Elfogadott megoldások: 9 darab.
Szerezhető: 1 pont. Leadási határidő: 2025-10-20 04:00:00.

std::optional

Néha szükségünk van egy olyan objektumra, amelyik egy jól meghatározott típusú értéket tárol – vagy éppenséggel üres. Például egy függvénynél, amelyik visszaad egy értéket, vagy nem ad vissza semmit. Ha sikerül beolvasnia egy számot, akkor visszaadja azt, ha nem, akkor pedig csak egy üres objektumot.

Ezt meg tudjuk oldani dinamikus memóriakezeléssel is. De ebben az esetben az kényelmetlen és lassú: egyetlen egy int-et kellene dinamikusan foglalni, indirekten visszaadni stb. Ehelyett inkább egy olyan objektumra lenne szükségünk, amelyik ezt érték szerint tartalmazza, és tudja azt is, hogy üres-e vagy nem. A használatát így képzelhetjük el:

Optional<std::string> get_string_from_stdin();

int main() {
    Optional<std::string> opt = get_string_from_stdin();
    if (opt) {
        std::cout << "Ezt a sztringet kaptam: " << *opt << std::endl;
    } else {
        std::cout << "Nem kaptam sztringet" << std::endl;
    }
}

A tárolt érték típusa std::string, de a sablonparaméter miatt lehetne bármi más.

Készíts egy ilyen osztályt! Ügyelj az alábbiakra:

• Nem használhatsz dinamikus memóriakezelést, mert akkor elveszik a feladat értelme.
• Helyette egy sizeof(T) méretű tömböt kell az Optional objektumba tenni, és neked kell tudnod, hogy ott épp létre van hozva objektum vagy nincs.
• Ügyelni kell arra is, hogy a tömb megfelelő módon helyezkedjen el a memóriában. Előfordulhat, hogy a T típusra vonatkoznak ilyen megkötések (pl. int típus 4-gyel osztható memóriacímen). A memóriabeli igazítás az alignas kulcsszóval oldható meg.
• Az Optional objektum megszűntekor a tartalmazott T destruktorát is meg kell hívni, már amennyiben volt tartalmazott T.

Tesztesetek nincsenek megadva, azokat neked kell kitalálnod. Vajon mi várható el egy ilyen osztálytól? Gondolj arra, hogy egy Optional 0 vagy 1 darab objektumot tartalmaz érték szerint, és azt az objektumot helyettesíti. Érdemes a kódodat GCC/Clang -fno-elide-constructors fordítási paraméter mellett tesztelni, hogy kikapcsold a hibákat elfedő optimalizációkat!

A C++17 óta egyébként van ilyen osztály, std::optional néven. Ez a Boost optional osztály mintájára készült.

Elfogadott megoldások: 0 darab.
Szerezhető: 1 pont. Leadási határidő: 2025-10-27 04:00:00.