Szerkesztő:LinguisticMystic/ru/программирование/22

01K

Készíts egy struktúrát, amely egy űrhajó adatait tárolja:

• Hajó hossza
• Legénység maximális mérete
• Maximális sebesség
• Képes-e a hajó hipertér-ugrásra

A struktúra és a lenti függvények (main-en kívül) legyenek egy urhajo nevű névtérben.

A struktúra ezen belül legyen egy adat, a függvények pedig egy muveletek nevű névtérben.

A megfelelő using deklarációkkal biztosítsd, hogy a main-ben megírt kód működjön.

Készíts egy függvényt, amely megkap paraméterben egy darabszámot, és helyet foglal ennyi űrhajónak.

Kérd be, hogy hány űrhajó adatait tárolja a program, és foglalj helyet nekik a függvény segítségével.

Olvasd be az űrhajók adatait.

Készíts egy függvényt, amely megkapja az űrhajók tömbjét, és kilistázza az összes űrhajót amely képes hipertér ugrásra.

A függvény meghívásával listázd ki a hajókat.

Készíts egy függvényt, amely megkapja az űrhajók tömbjét, és egy egész számot (létszám), és visszaadja azon hajók darabszámát, amelyek a megadott mennyiségű embert képesek elszállítani.

A létszámot ne legyen kötelező megadni, ha elhagyjuk akkor tekintsük 100-nak.

Jelenítsd meg a függvény meghívásával a 400 főt szállítani képes hajók számát.

Készíts egy függvényt, amely visszaad egy mutatót a leglassabb hajóra.

A függvénynek legyen egy második, logikai paramétere, mely alapértelmezetten hamis.

Ha ezt a paramétert is megadjuk, és igaz, akkor csak azon hajók között keressen a függvény, amelyen nem képesek hipertér-ugrásra.

A függvény meghívásával jelenítsd meg a leglassabb hajó adatait, majd a leglassabb, hipertér-ugrásra nem képes hajó adatait.

Szabadítsd fel a lefoglalt memóriát.

#include <limits>
#include <iostream>

namespace spaceship {
    namespace data {
        struct spaceship {
            int length;
            int max_crew;
            int max_speed;
            bool canJump;
        };
    }

    namespace functions {
        data::spaceship* reserveSpace(int &n) {
            std::cout << "How many spaceships?\n";
            std::cin >> n;

            if (n <= 0) {
                std::cout << "Invalid number of spaceships. Exiting...\n";
                return nullptr;
            }

            data::spaceship* ships = new(std::nothrow) data::spaceship[n];

            if (!ships) {
                std::cerr << "Memory allocation failed!\n";
            }

            return ships;
        }

        void freeSpace(data::spaceship* ship_to_delete) {
            if (ship_to_delete) {
                delete[] ship_to_delete;
            }
        }

        void inputData(data::spaceship* ships, int n) {
            for (int i = 0; i < n; i++) {
                std::cout << "Spaceship " << i + 1 << " length? ";
                while (!(std::cin >> ships[i].length) || ships[i].length <= 0) {
                    std::cout << "Invalid input! Enter a positive integer: ";
                    std::cin.clear();
                    std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
                }

                std::cout << "Spaceship " << i + 1 << " max crew? ";
                while (!(std::cin >> ships[i].max_crew) || ships[i].max_crew <= 0) {
                    std::cout << "Invalid input! Enter a positive integer: ";
                    std::cin.clear();
                    std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
                }

                std::cout << "Spaceship " << i + 1 << " max speed? ";
                while (!(std::cin >> ships[i].max_speed) || ships[i].max_speed <= 0) {
                    std::cout << "Invalid input! Enter a positive integer: ";
                    std::cin.clear();
                    std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
                }

                std::cout << "Spaceship " << i + 1 << " can jump? (yes=1, no=0) ";
                while (!(std::cin >> ships[i].canJump) || (ships[i].canJump != 0 && ships[i].canJump != 1)) {
                    std::cout << "Invalid input! Enter 1 for Yes or 0 for No: ";
                    std::cin.clear();
                    std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
                }
            }
        }

        void showData(const data::spaceship* ships, int n) {
            for (int i = 0; i < n; i++) {
                if (ships[i].canJump) {         
                    std::cout << "Spaceship " << i + 1 << " can jump!\n";
                }
            }    
        }

        void enoughCrew(const data::spaceship* ships, int n, int headcount = 100) {
            for (int i = 0; i < n; i++) {
                if (ships[i].max_crew >= headcount) {         
                    std::cout << "Spaceship " << i + 1 << " has enough crew!\n";
                }
            }
        }    

        data::spaceship* pointToSlowest(data::spaceship* ships, int n, bool onlyJumpable) {
            if (!ships || n <= 0) {
                std::cerr << "Error: Invalid ship data.\n";
                return nullptr;
            }

            data::spaceship* slowest = nullptr;
            int minSpeed = std::numeric_limits<int>::max();

            for (int i = 0; i < n; i++) {
                if (onlyJumpable && !ships[i].canJump) {
                    continue;
                }

                if (ships[i].max_speed < minSpeed) {
                    minSpeed = ships[i].max_speed;
                    slowest = &ships[i];
                }
            }

            if (!slowest) {
                std::cout << "No valid ships found for slowest search.\n";
            }

            return slowest;
        }
    }
}

using namespace spaceship;

int main() {
    int numShips;
    data::spaceship* myspaceship = functions::reserveSpace(numShips);

    if (!myspaceship) {
        return 0;
    }

    functions::inputData(myspaceship, numShips);
    functions::showData(myspaceship, numShips);
    functions::enoughCrew(myspaceship, numShips, 400);

    data::spaceship* slowest = functions::pointToSlowest(myspaceship, numShips, false);

    if (slowest) {
        std::cout << "Slowest spaceship:\n"
                  << "Speed: " << slowest->max_speed << "\n"
                  << "Length: " << slowest->length << "\n"
                  << "Max crew: " << slowest->max_crew << "\n";
    }

    functions::freeSpace(myspaceship);
    return 0;
}

vagy:

#include <iostream>
#include <limits>
#include <vector>

namespace spaceship {
    class Spaceship {
    public:
        int length;
        int max_crew;
        int max_speed;
        bool canJump;

        void inputData(int index) {
            std::cout << "Spaceship " << index + 1 << " length? ";
            length = getValidInput<int>("Invalid input! Enter a positive integer: ", 1);

            std::cout << "Spaceship " << index + 1 << " max crew? ";
            max_crew = getValidInput<int>("Invalid input! Enter a positive integer: ", 1);

            std::cout << "Spaceship " << index + 1 << " max speed? ";
            max_speed = getValidInput<int>("Invalid input! Enter a positive integer: ", 1);

            std::cout << "Spaceship " << index + 1 << " can jump? (yes=1, no=0) ";
            canJump = getValidInput<bool>("Invalid input! Enter 1 for Yes or 0 for No: ", 0, 1);
        }

        void displayJumpCapability(int index) const {
            if (canJump) {
                std::cout << "Spaceship " << index + 1 << " can jump!\n";
            }
        }

        bool hasEnoughCrew(int requiredCrew) const {
            return max_crew >= requiredCrew;
        }

        static Spaceship* findSlowest(std::vector<Spaceship>& ships, bool onlyJumpable) {
            if (ships.empty()) {
                std::cerr << "Error: No ships available.\n";
                return nullptr;
            }

            Spaceship* slowest = nullptr;
            int minSpeed = std::numeric_limits<int>::max();

            for (auto& ship : ships) {
                if (onlyJumpable && !ship.canJump) continue;

                if (ship.max_speed < minSpeed) {
                    minSpeed = ship.max_speed;
                    slowest = &ship;
                }
            }

            if (!slowest) {
                std::cout << "No valid ships found for slowest search.\n";
            }
            return slowest;
        }

    private:
        template <typename T>
        static T getValidInput(const std::string& errorMsg, T minValue, T maxValue = std::numeric_limits<T>::max()) {
            T value;
            while (!(std::cin >> value) || value < minValue || value > maxValue) {
                std::cout << errorMsg;
                std::cin.clear();
                std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
            }
            return value;
        }
    };

    namespace functions {
        std::vector<Spaceship> createFleet() {
            int n;
            std::cout << "How many spaceships?\n";
            n = Spaceship::getValidInput<int>("Invalid number of spaceships. Try again: ", 1);

            std::vector<Spaceship> fleet(n);
            for (int i = 0; i < n; i++) {
                fleet[i].inputData(i);
            }
            return fleet;
        }

        void displayJumpCapableShips(const std::vector<Spaceship>& ships) {
            for (size_t i = 0; i < ships.size(); i++) {
                ships[i].displayJumpCapability(i);
            }
        }

        void displayShipsWithEnoughCrew(const std::vector<Spaceship>& ships, int requiredCrew) {
            for (size_t i = 0; i < ships.size(); i++) {
                if (ships[i].hasEnoughCrew(requiredCrew)) {
                    std::cout << "Spaceship " << i + 1 << " has enough crew!\n";
                }
            }
        }
    }
}

using namespace spaceship;

int main() {
    std::vector<Spaceship> fleet = functions::createFleet();

    functions::displayJumpCapableShips(fleet);
    functions::displayShipsWithEnoughCrew(fleet, 400);

    Spaceship* slowest = Spaceship::findSlowest(fleet, false);
    if (slowest) {
        std::cout << "Slowest spaceship:\n"
                  << "Speed: " << slowest->max_speed << "\n"
                  << "Length: " << slowest->length << "\n"
                  << "Max crew: " << slowest->max_crew << "\n";
    }

    return 0;
}

01HF

Készíts egy struktúrát, amely egy focista adatait tárolja, és a következő adattagokkal rendelkezik:

• Mez sorszáma
• Életkor
• Testmagasság
• Összes gólok száma
• Összes lejátszott meccs száma
• Játszott-e már világbajnoki mérkőzést

Kérd be, hogy hány játékos adatait tárolja a program, és foglalj helyet ennyi játékosnak.

Olvasd be a játékosok adatait.

Készíts egy függvényt, amely megkapja a játékosok tömbjét, és megjeleníti az adatokat.

Jelenítsd meg az összes adatot a függvény segítségével.

Készíts egy függvényt, mely megkeresi a legidősebb játékost, és visszatér a memóriacímével.

A függvényt meghívva keresd meg a legidősebb játékos adatait, és jelenítsd meg.

Készíts egy függvényt, mely megkapja a játékosok tömbjét, és egy egész számot.

Utóbbit el lehet hagyni, ekkor az értékét a program vegye 10-nek.

A függvény írja ki hogy hány olyan játékos van, aki legalább ennyi meccset játszott.

Kérj be egy újabb számot, és az előbbi függvény segítségével írd ki, hogy hány olyan játékos van, aki legalább ennyi meccset játszott.

Kérj be egy újabb számot.

Jelenítsd meg az adott mez számmal rendelkező játékos adatait, feltéve, ha van ilyen.

Rendezd a játékosokat testmagasságuk szerinti csökkenő sorrendbe.

Jelenítsd meg a rendezett tömböt.

Szabadítsd fel a lefoglalt memóriát.

---

#include <iostream>
#include <algorithm>

using namespace std;

// Define the structure correctly
struct soccerplayer {
    int jerseyNo;
    int age;
    int height;
    int totalGoals;
    int totalMatches;
    bool hasChampMatch;
};

// Function to read player data
void readPlayerData(soccerplayer* players, int n) {
    for (int i = 0; i < n; i++) {
        cout << "\nEnter data for player " << i + 1 << ":\n";
        cout << "Jersey Number: ";
        cin >> players[i].jerseyNo;
        cout << "Age: ";
        cin >> players[i].age;
        cout << "Height (cm): ";
        cin >> players[i].height;
        cout << "Total Goals: ";
        cin >> players[i].totalGoals;
        cout << "Total Matches: ";
        cin >> players[i].totalMatches;
        cout << "Has played championship match (1 for Yes, 0 for No): ";
        cin >> players[i].hasChampMatch;
    }
}

// Function to display all player data
void displayPlayerData(const soccerplayer* players, int n) {
    cout << "\n--- Player Data ---\n";
    for (int i = 0; i < n; i++) {
        cout << "\nData for player " << i + 1 << ":\n";
        cout << "Jersey Number: " << players[i].jerseyNo << "\n";
        cout << "Age: " << players[i].age << "\n";
        cout << "Height (cm): " << players[i].height << "\n";
        cout << "Total Goals: " << players[i].totalGoals << "\n";
        cout << "Total Matches: " << players[i].totalMatches << "\n";
        cout << "Has played championship match: " << (players[i].hasChampMatch ? "Yes" : "No") << "\n";
    }
}

// Function to find the oldest player
soccerplayer* findOldestPlayer(soccerplayer* players, int n) {
    if (n == 0) return nullptr;

    soccerplayer* oldest = &players[0];  // Initialize with first player
    for (int i = 1; i < n; i++) {  // Start from index 1
        if (players[i].age > oldest->age) {
            oldest = &players[i];
        }
    }
    return oldest;
}

// Function to count players who played at least 'minMatches' matches
int countPlayersMinMatches(soccerplayer* players, int n, int minMatches = 10) {	
    int count = 0;
    for (int i = 0; i < n; i++) {
        if (players[i].totalMatches >= minMatches) {
            count++;
        }
    }	
    return count;
}

// Function to search for a player by jersey number
soccerplayer* searchPlayerByJerseyNo(soccerplayer* players, int n, int jersey) {
    for (int i = 0; i < n; i++) {
        if (players[i].jerseyNo == jersey) {
            return &players[i];
        }
    }
    return nullptr;  // Added return nullptr if not found
}

// Function to sort players by height in descending order
void sortByHeightDesc(soccerplayer* players, int n) {
    sort(players, players + n, [](const soccerplayer &a, const soccerplayer &b) {
        return a.height > b.height; // Sorting in descending order
    });
}



int main() {
    int n; // Player count
    cout << "Player count? ";
    cin >> n;

    // Allocate memory correctly
    soccerplayer* myteam = new soccerplayer[n];

    // Read player data
    readPlayerData(myteam, n);
	
    // Show all players
    displayPlayerData(myteam, n);
	
    // Find and display the oldest player
    soccerplayer* oldest = findOldestPlayer(myteam, n);
    if (oldest) {
        cout << "\n--- Oldest Player ---\n";
        cout << "Jersey Number: " << oldest->jerseyNo << "\n";
        cout << "Age: " << oldest->age << "\n";
        cout << "Height: " << oldest->height << " cm\n";
    } else {
        cout << "\nNo players found.\n";
    }
	
    // Count players with at least 10 matches
    cout << "\nNumber of players with at least 10 matches: " 
         << countPlayersMinMatches(myteam, n) << "\n";

    // Ask for a custom match threshold and count players
    int minMatches;
    cout << "Enter a minimum number of matches: ";
    cin >> minMatches;
    cout << "Number of players with at least " << minMatches << " matches: "
         << countPlayersMinMatches(myteam, n, minMatches) << "\n";

    // Search for a player by jersey number
    int searchJersey;
    cout << "Enter a jersey number to search: ";
    cin >> searchJersey;
    soccerplayer* foundPlayer = searchPlayerByJerseyNo(myteam, n, searchJersey);
    if (foundPlayer) {
        cout << "\n--- Player Found ---\n";
        cout << "Jersey Number: " << foundPlayer->jerseyNo << "\n";
        cout << "Age: " << foundPlayer->age << "\n";
        cout << "Height: " << foundPlayer->height << " cm\n";
        cout << "Total Goals: " << foundPlayer->totalGoals << "\n";
        cout << "Total Matches: " << foundPlayer->totalMatches << "\n";
        cout << "Has played championship match: " << (foundPlayer->hasChampMatch ? "Yes" : "No") << "\n";
    } else {
        cout << "No player found with jersey number " << searchJersey << ".\n";
    }

    // Sort and display players by height
    sortByHeightDesc(myteam, n);
    cout << "\n--- Players Sorted by Height (Descending Order) ---\n";
    displayPlayerData(myteam, n);
	
    // Free allocated memory
    delete[] myteam;

    return 0;
}

02K

A feladat során ahol lehet, dolgozz referenciákkal, illetve konstansokkal.

Készíts egy struktúrát, amely egy téglatest alakú doboz adatait tárolja:

• Doboz neve: szöveg (szóköz nélküli)
• Szélesség, magasság, hosszúság: előjel nélküli egész értékek

A struktúra és a lenti függvények legyenek egy doboz nevű névtérben.

A megfelelő using deklerációkkal biztosítsd, hogy a main-ben lévő kódok működjenek.

Kérd be, hogy hány doboz adatait tárolja a program.

Foglalj helyet a megfelelő számú doboznak.

Olvasd be a dobozok adatait.

Készíts egy függvényt, amely megkapja a dobozok tömbjét, és megjeleníti a tartalmát.

Jelenítsd meg a dobozok adatait a függvény meghívásával.

Készíts egy függvényt, amely megkap egy dobozt, és kiírja a felszínét és a térfogatát.

Készíts egy függvényt, amely megkapja a dobozok tömbjét, illetve egy egész számot.

A függvény foglalja újra a tömböt úgy, hogy megnöveli a méretét a megadott számmal.

Kérj be egy számot, és növeld meg a tömb méretét a függvény segítségével.

Olvasd be a tömb új elemeinek értékeit, majd jelenítsd meg a teljes tömböt.

Készíts egy függvényt, amely megkap egy dobozt, és azt elforgatja.

A forgatás most fix módon történik: a szélesség, magasság, és hosszúság adatokat megcseréli.

(Egy 20x30x40 méretű dobozból 30x40x20 méretű doboz lesz.) Készíts egy függvényt, amely megkap két dobozt.

A függvény határozza meg, hogy bármelyik doboz belefér-e a másikba (a dobozokat nem forgatjuk el).

Ha nem, akkor térjen vissza 0-val.

Ha igen, akkor térjen vissza azzal, hogy a kisebb dobozból elforgatás nélkül hányat lehet a nagyobb dobozba belepakolni.

Az előbbi függvénynek legyen egy másik verziója, ami csak egy dobozt kap meg, valamint mellé egy-egy szélesség, magasság, és hosszúság értéket.

A függvény adja vissza, hogy a doboz hányszor fér bele elforgatás nélkül a három méret által definiált helybe.

Szabadítsd fel a lefoglalt memóriát.

#include <iostream>
#include <string>

namespace boxes {

struct Box {
    std::string name;
    unsigned int w, h, d;
};

void showBox(const Box* b, int t) {
    for (int i = 0; i < t; i++) {
        std::cout << "Box name: " << b[i].name << "\n";
        std::cout << "Box w: " << b[i].w << "\n";
        std::cout << "Box h: " << b[i].h << "\n";
        std::cout << "Box d: " << b[i].d << "\n";
    }
}

void VolumeSurface(const Box& b) {
    int vol = b.d * b.h * b.w;
    int s_area = 2 * (b.d * b.h + b.d * b.w + b.h * b.w);
    std::cout << "Volume: " << vol << "\n";
    std::cout << "Surface area: " << s_area << "\n";
}

Box* resizeBoxArray(Box* b, int oldSize, int expand) {
    Box* newBox = new Box[oldSize + expand];
    for (int i = 0; i < oldSize; i++) {
        newBox[i] = b[i];  // Copy old data
    }
    delete[] b;  // Free old memory
    return newBox;
}

Box rotateBox(Box b) {
    std::swap(b.w, b.h);
    std::swap(b.h, b.d);
    return b;
}

int TimesFitBox(const Box& a, const Box& b) {
    if (a.w <= b.w && a.h <= b.h && a.d <= b.d) {
        return (b.w / a.w) * (b.h / a.h) * (b.d / a.d);
    }
    return 0;
}

int TimesFitSize(const Box& a, int h, int w, int d) {
    if (a.w <= w && a.h <= h && a.d <= d) {
        return (w / a.w) * (h / a.h) * (d / a.d);
    }
    return 0;
}

} // namespace boxes

using namespace boxes;

int main() {
    int total;
    std::cout << "Total boxes? ";
    std::cin >> total;

    Box* mybox = new Box[total];

    for (int i = 0; i < total; i++) {
        std::cout << "Box " << i + 1 << " name? ";
        std::cin >> mybox[i].name;
        std::cout << "Box " << i + 1 << " width? ";
        std::cin >> mybox[i].w;
        std::cout << "Box " << i + 1 << " height? ";
        std::cin >> mybox[i].h;
        std::cout << "Box " << i + 1 << " depth? ";
        std::cin >> mybox[i].d;
    }

    showBox(mybox, total);
    VolumeSurface(mybox[0]);

    // Resize box array
    mybox = resizeBoxArray(mybox, total, 3);
    total += 3;

    for (int i = total - 3; i < total; i++) {
        std::cout << "Box " << i + 1 << " name? ";
        std::cin >> mybox[i].name;
        std::cout << "Box " << i + 1 << " width? ";
        std::cin >> mybox[i].w;
        std::cout << "Box " << i + 1 << " height? ";
        std::cin >> mybox[i].h;
        std::cout << "Box " << i + 1 << " depth? ";
        std::cin >> mybox[i].d;
    }

    Box rotated = rotateBox(mybox[2]);
    std::cout << "Rotated box: " << rotated.name << " " << rotated.w << " " << rotated.h << " " << rotated.d << std::endl;

    int fits = TimesFitBox(mybox[2], mybox[3]);
    std::cout << "Box 2 fits inside Box 3: " << fits << " times.\n";

    if (total > 5) {
        int fitsSize = TimesFitSize(mybox[5], 12, 34, 56);
        std::cout << "Box 5 fits inside given dimensions: " << fitsSize << " times.\n";
    } else {
        std::cout << "Not enough boxes to check fitting size.\n";
    }

    delete[] mybox;
    return 0;
}

02HF

A feladat során ahol lehet, dolgozz referenciákkal, illetve konstansokkal.

Készíts egy struktúrát, amely tantárgy eredményeit tárolja:

• Tárgy kódja: szöveg (szóköz nélküli)
• Jegyek száma: előjel nélküli egész
• Jegyek: előjel nélküli egészek tömbje A program tárolja fixen 3 tárgy eredményeit.

Olvasd be a tárgyak adatait.

Minden tárgyhoz külön be kell kérni a jegyek számát, és helyet foglalni a jegyek tömbjének, majd bekérni a jegyeket is.

Készíts egy függvényt, amely megkap egy tantárgyat, és megjeleníti az adatait.

Jelenítsd meg a tantárgyak adatait a függvény segítségével.

Készíts egy függvényt, amely megkap egy tantárgyat, és visszaadja a jegyek átlagát.

Az előző függvény segítségével keresd meg azt a tantárgyat, ahol az átlag a legmagasabb, és jelenítsd meg az adatait.

Készíts egy függvényt, amely megkap egy tantárgyat és egy előjel nélküli egészet.

A függvény foglalja újra a tantárgyhoz tartozó jegyek tömbjét a megadott méretűre.

Ha a méret csökken, akkor az utolsó pár jegy, amik nem férnek el, eltűnnek.

Ha nő a méret, akkor összes új jegy legyen 5-ös.

Minden tantárgyhoz kérj be egy számot, és az előbbi függvény segítségével méretezd át a jegyek tömbjét.

Az előző függvénynek legyen egy olyan verziója, amely vár plusz két paramétert.

Ha a tömb mérete nő, akkor az új jegyek ezen két paraméter legyenek, váltakozva.

(Pl.: Ha a két paraméter 2 és 4, és a növelés miatt 5 új érték keletkezik, akkor az új értékek 2,4,2,4,2 lesznek.) Készíts egy függvényt, amely megkap egy tárgyat, és felszabadítja a hozzá tartozó tömböt.

Szabadítsd fel az összes lefoglalt memóriát a függvény meghívásával.

 
#include <iostream>
#include <string>
#include <vector>
#include <limits>

using namespace std;

struct Tantargy {
    string kod;
    unsigned int jegyek_szama;
    vector<unsigned int> jegyek;
};

void beolvas(Tantargy& tantargy) {
    cout << "Add meg a tantárgy kódját: ";
    cin >> tantargy.kod;
    cout << "Add meg a jegyek számát: ";
    cin >> tantargy.jegyek_szama;
    
    tantargy.jegyek.resize(tantargy.jegyek_szama);
    
    cout << "Add meg a jegyeket: ";
    for (unsigned int& jegy : tantargy.jegyek) {
        cin >> jegy;
    }
}

void megjelenit(const Tantargy& tantargy) {
    cout << "Tantárgy kódja: " << tantargy.kod << "\n";
    cout << "Jegyek: ";
    for (const unsigned int& jegy : tantargy.jegyek) {
        cout << jegy << " ";
    }
    cout << "\n";
}

double atlag(const Tantargy& tantargy) {
    if (tantargy.jegyek.empty()) return 0.0;
    double osszeg = 0;
    for (const unsigned int& jegy : tantargy.jegyek) {
        osszeg += jegy;
    }
    return osszeg / tantargy.jegyek.size();
}

void ujrameretez(Tantargy& tantargy, unsigned int uj_meret) {
    tantargy.jegyek.resize(uj_meret, 5);
    tantargy.jegyek_szama = uj_meret;
}

void ujrameretez(Tantargy& tantargy, unsigned int uj_meret, unsigned int ertek1, unsigned int ertek2) {
    size_t jelenlegi_meret = tantargy.jegyek.size();
    tantargy.jegyek.resize(uj_meret);
    for (size_t i = jelenlegi_meret; i < uj_meret; ++i) {
        tantargy.jegyek[i] = (i % 2 == 0) ? ertek1 : ertek2;
    }
    tantargy.jegyek_szama = uj_meret;
}

int main() {
    const int TANTARGY_SZAM = 3;
    Tantargy tantargyak[TANTARGY_SZAM];
    
    for (int i = 0; i < TANTARGY_SZAM; ++i) {
        beolvas(tantargyak[i]);
    }
    
    for (const Tantargy& tantargy : tantargyak) {
        megjelenit(tantargy);
    }
    
    int max_index = 0;
    double max_atlag = atlag(tantargyak[0]);
    for (int i = 1; i < TANTARGY_SZAM; ++i) {
        double jelenlegi_atlag = atlag(tantargyak[i]);
        if (jelenlegi_atlag > max_atlag) {
            max_atlag = jelenlegi_atlag;
            max_index = i;
        }
    }
    
    cout << "Legjobb átlaggal rendelkező tantárgy:\n";
    megjelenit(tantargyak[max_index]);
    cout << "Átlag: " << max_atlag << "\n";
    
    for (int i = 0; i < TANTARGY_SZAM; ++i) {
        unsigned int uj_meret;
        cout << "Add meg a(z) " << tantargyak[i].kod << " új méretét: ";
        cin >> uj_meret;
        ujrameretez(tantargyak[i], uj_meret);
    }
    
    for (const Tantargy& tantargy : tantargyak) {
        megjelenit(tantargy);
    }
    
    return 0;
}

03K

Készíts egy Szamok osztályt, amely lebegőpontos számok tömbjét tárolja.

Az osztály legyen a Tarolo névtérben.

A tárolt tömb méretét nem tudjuk előre, viszont az osztály konstruktor kapja meg ezt az értéket, és foglaljon helyet a tömbnek.

A konstruktornak legyen egy második paramétere, mely alapértelmezetten 0.

Létrehozáskor a tömb minden eleme ezt az értéket vegye fel.

A Szamok osztály destruktora szabadítsa fel az előző feladatban lefoglalt memóriát.

Az osztályban egy darabLeker függvény segítségével lehessen lekérdezni az eltárolt értékek számát.

Legyen az osztálynak egy ertekBeallit függvénye, amely megkapja a tömbnek egy (nem feltétlenül érvényes) indexét, valamint egy számot.

A tömb adott helyén lévő számot átállítja a paraméterben kapottra.

Érvénytelen index esetén a függvény ne csináljon semmit.

Legyen az osztálynak egy ertekLeker függvénye, amely megkapja a tömbnek egy (nem feltétlenül érvényes) indexét.

A függvény térjen vissza a tömb adott helyén lévő számmal.

Érvénytelen index esetén a függvény -10^8 értékkel térjen vissza.

A main.cpp-ben lévő kódokat úgy írd meg, hogy a using namespace utasítást NEM használod a Tarolo névtérre.

Készíts a main.cpp-be egy kiir függvényt, amely paraméterben megkap egy Szamok objektumot, és megjeleníti a tárolt értékeket egy sorban, vesszővel elválasztva.

A main függvényben hozz létre két Szamok objektumot, és töltsd fel értékekkel, majd jelenítsd is meg.

 
//szamok.h:

#ifndef SZAMOK_H
#define SZAMOK_H

#include <iostream>

namespace Tarolo{
	class Szamok{
	private:	
		double* Tomb(];
		int meret;
	
	public:
		Szamok(int a, double b = 0.0){
			meret = a;
			Tomb = new double[a];
			for(int i = 0; i < a; i++)
				Tomb[i] = b;
			}
		}
		~Szamok() {
			delete[] Tomb;
		}
		
		int darabLeker() const{
			return meret;
		}
				
		void ertekBeallit(int i, double d){
			if (i >= 0 && i < meret){
				Tomb[i] = d;
			}
		}
		
		double ertekLeker(double){
			if (i >= 0 && i < meret){
				return Tomb(i];
			}
			return		-1e8;		
		}
		
		void kiir() const{
			for (int i = 0; i < meret; i++) {
                std::cout << Tomb[i];
                if (i < meret - 1) std::cout << ", ";
            }
			std::cout << std::endl;
		}
	
		
	};
}
#endif // SZAMOK_H

// main.cpp:

#include <iostream>
#include "szamok.h"

void kiir(const Tarolo::Szamok& sz) {
    sz.kiir();
}

int main() {
    Tarolo::Szamok sz1(5, 1.0);
    Tarolo::Szamok sz2(4, 2.0);

    sz1.ertekBeallit(2, 3.5);
    sz2.ertekBeallit(1, 4.7);

    std::cout << "Sz1 értékek: ";
    kiir(sz1);

    std::cout << "Sz2 értékek: ";
    kiir(sz2);

    std::cout << "Sz1 2. index értéke: " << sz1.ertekLeker(2) << std::endl;
    std::cout << "Sz2 5. index értéke (érvénytelen): " << sz2.ertekLeker(5) << std::endl;

    return 0;
}

03HF

Készíts egy Tarolo osztályt, amely egész számokat tárol, előre meg nem határozott mennyiségben.

• Az osztály legyen egy EpicToolbox névtérben.
• Az osztálynak két konstruktora legyen.

Az egyik várjon egy számot, hozza létre a belső tömböt ekkora mérettel, és töltse fel 1,2,3,...

értékekkel.

A másik ne várjon paramétert, hanem olvassa be a tömb méretét, hozza létre a tömböt, majd olvassa be az elemeit is.

Az osztály destruktora szabadítsa fel a tömböt.

Legyen az osztálynak egy kiir függvénye, amely megjeleníti az eltárolt számokat.

Készíts az osztályba egy hozzaad függvény is, amely megkap egy számot.

A belső tömb méretét megnöveli eggyel, hogy az új érték elférjen benne, és a végére hozzá is teszi ezt az értéket.

Készíts egy atlag függvényt az osztályba, amely visszaadja a tárolt számok átlagát.

A main függvényben hozz létre egy-egy Tarolo típusú objektumot mindkét konstruktort használva.

Mindkettőt töltsd fel értékekkel, majd jelenítsd is meg.

A main.cpp-ben legyen egy kisebbTarolo függvény, ami megkap két Tarolo típusú objektumot.

A függvény visszatér 1-gyel, ha az másodiknak van kevesebb eleme, -1-gyel, ha az elsőnek, és 0val, ha ugyanannyi elemük van.

A függvényhez szükség lesz a Tarolo osztály megfelelő kiegészítésére.

• A main függvényben hívd meg ezt a függvényt a kettő létrehozott tárolóra, és jelenítsd meg az eredményt.

tarolo.h

#ifndef TAROLO_H
#define TAROLO_H

#include <iostream>

namespace EpicToolbox {

class Tarolo {
private:
    int meret;
    int* tomb;

public:
    // Alapértelmezett konstruktor (üres tömb inicializálás)
    Tarolo() : meret(0), tomb(nullptr) {}

    // Konstruktor mérettel
    Tarolo(int sz) : meret(sz) {
        tomb = new int[meret];
        for (int i = 0; i < meret; i++) {
            tomb[i] = i + 1;
        }
    }

    // Másoló konstruktor (mély másolatot készít)
    Tarolo(const Tarolo& other) : meret(other.meret) {
        tomb = new int[meret];
        for (int i = 0; i < meret; i++) {
            tomb[i] = other.tomb[i];
        }
    }

    // Értékadás operátor felüldefiniálása
    Tarolo& operator=(const Tarolo& other) {
        if (this != &other) {
            delete[] tomb;
            meret = other.meret;
            tomb = new int[meret];
            for (int i = 0; i < meret; i++) {
                tomb[i] = other.tomb[i];
            }
        }
        return *this;
    }

    // Felhasználói bemenettel inicializáló konstruktor
    void beolvas() {
        std::cout << "Adja meg a méretet: ";
        while (!(std::cin >> meret) || meret < 0) {
            std::cout << "Hibás bemenet! Adj meg egy pozitív számot: ";
            std::cin.clear();
            std::cin.ignore(10000, '\n');
        }
        tomb = new int[meret];
        std::cout << "Adja meg az elemeket: ";
        for (int i = 0; i < meret; i++) {
            while (!(std::cin >> tomb[i])) {
                std::cout << "Hibás bemenet! Adj meg egy számot: ";
                std::cin.clear();
                std::cin.ignore(10000, '\n');
            }
        }
    }

    // Destruktor
    ~Tarolo() {
        delete[] tomb;
    }

    // Elemszám lekérdezése
    int getMeret() const {
        return meret;
    }

    // Kiírás függvény
    void kiir() const {
        for (int i = 0; i < meret; i++) {
            std::cout << tomb[i] << " ";
        }
        std::cout << std::endl;
    }

    // Új érték hozzáadása a tömbhöz
    void hozzaad(int n) {
        int* ujTomb = new int[meret + 1];
        for (int i = 0; i < meret; i++) {
            ujTomb[i] = tomb[i];
        }
        ujTomb[meret] = n;
        delete[] tomb;
        tomb = ujTomb;
        meret++;
    }

    // Átlag számítása
    double atlag() const {
        if (meret == 0) return 0;
        int sum = 0;
        for (int i = 0; i < meret; i++) {
            sum += tomb[i];
        }
        return static_cast<double>(sum) / meret;
    }
};

// Kisebb Tarolo meghatározása
int kisebbTarolo(const Tarolo& c1, const Tarolo& c2) {
    if (c2.getMeret() < c1.getMeret()) return 1;
    if (c2.getMeret() > c1.getMeret()) return -1;
    return 0;
}

}  // namespace EpicToolbox

#endif // TAROLO_H

---

main.cpp

#include <iostream>
#include "tarolo.h"

using namespace EpicToolbox;

int main() {
    // Objektumok létrehozása
    Tarolo t1(5);  // 5 elemű tároló
    Tarolo t2;
    t2.beolvas();   // Felhasználói bemenetből olvasás

    // Kiírás tesztelése
    std::cout << "t1 tartalma: ";
    t1.kiir();
    std::cout << "t2 tartalma: ";
    t2.kiir();

    // Új érték hozzáadása
    t1.hozzaad(99);
    std::cout << "t1 tartalma hozzaad(99) után: ";
    t1.kiir();

    // Átlag számítása
    std::cout << "t1 átlaga: " << t1.atlag() << std::endl;
    std::cout << "t2 átlaga: " << t2.atlag() << std::endl;

    // Kisebb Tarolo meghatározása
    int eredmeny = kisebbTarolo(t1, t2);
    if (eredmeny == 1)
        std::cout << "t2-nek kevesebb eleme van.\n";
    else if (eredmeny == -1)
        std::cout << "t1-nek kevesebb eleme van.\n";
    else
        std::cout << "Mindkettőnek ugyanannyi eleme van.\n";

    return 0;
}

04K

A feladat elkezdéséhez a mellékelt projekt tartalmaz kódokat (main függvény és Datum osztály).

A megoldás során ezekhez a kódokhoz nem kell nyúlni (kivéve ha a feladat kéri), de a teszteléshez a main függvényben a nem használt kódokat ki lehet kommentezni.

Ügyelj arra, hogy minden lefoglalt memória kerüljön megfelelően felszabadításra.

Készíts egy Hatarido osztályt, ami tárolja egy szoftver nevét (egy szöveg, ami akár szóközöket is tartalmazhat), és a különböző verzióihoz tartozó kitűzött határidőket.

Három verzióhoz tárolunk határidőt (Datum típus): alpha, beta, és végleges, de nem biztos hogy mindegyik határidőt meghatároztuk (tipp: dinamikusan foglalva kezeljük az időpontokat, három mutatót tárolva).

A konstruktor csak a szoftver nevét várja.

Legyen a névhez és az időpontokhoz lekérdező és beállító függvény (getNev, setNev, getAlphaDatum, setAlphaDatum, getBetaDatum, setBetaDatum, getVegsoDatum, setVegsoDatum).

A bejegyzett határidőket lehessen törölni is egy hataridoTorol metódus segítségével, amely megkapja paraméterben hogy melyik határidőt törölje.

Készíts másoló konstruktort a Hatarido osztályhoz.

Írd át a main.cpp-ben a beolvasásokat és kiírásokat úgy, hogy a parancssor helyett minden bekérés az input fájlból történjen, és minden kiírás az output fájlba történjen.

• A main.cpp-ben lévő datumKiir és hataridotKiir függvényeket is módosítani kell, hogy paraméterben megkapját a kimeneti fájl folyamot (csak sima referenciás átadással megy, vagy esetleg mutatóval).
• Ilyenkor hasznos lehet még a felhasználói interaciókat jelző kiírásokat („Kérek egy dátumot:”) kommentezni, mert nincs rájuk szükség.

#include <iostream>
#include <fstream>
#include <string>

using namespace std;

class Date {
private:
    int year, month, day;

public:
    // Default Constructor
    Date() : year(0), month(0), day(0) {}

    // Parameterized Constructor
    Date(int y, int m, int d) : year(y), month(m), day(d) {}

    // Getters (Marked as `const`)
    int getY() const { return year; }
    int getM() const { return month; }
    int getD() const { return day; }

    // Setters
    void setDate(int y, int m, int d) {
        year = y;
        month = m;
        day = d;
    }

    // Print Date to File (Const)
    void showDate(ofstream& out) const {
        if (year == 0) {
            out << "No Date\n";
        } else {
            out << year << "-" << month << "-" << day << "\n";
        }
    }

    // Overload `<<` to support `cout << Date`
    friend ostream& operator<<(ostream& os, const Date& d) {
        if (d.year == 0) {
            os << "No Date";
        } else {
            os << d.year << "-" << d.month << "-" << d.day;
        }
        return os;
    }
};

class Deadline {
private:
    string name;
    Date* alphaD;
    Date* betaD;
    Date* finalD;

public:
    // Default Constructor
    Deadline() : alphaD(nullptr), betaD(nullptr), finalD(nullptr) {}

    // Constructor with Software Name
    Deadline(const string& n) : name(n), alphaD(nullptr), betaD(nullptr), finalD(nullptr) {}

    // Constructor with Dates (Using Initialization List)
    Deadline(Date* a, Date* b, Date* f) 
        : alphaD(a ? new Date(*a) : nullptr), 
          betaD(b ? new Date(*b) : nullptr), 
          finalD(f ? new Date(*f) : nullptr) {}

    // Deep Copy Constructor
    Deadline(const Deadline& other) : name(other.name) {
        alphaD = other.alphaD ? new Date(*other.alphaD) : nullptr;
        betaD  = other.betaD ? new Date(*other.betaD) : nullptr;
        finalD = other.finalD ? new Date(*other.finalD) : nullptr;
    }

    // Destructor
    ~Deadline() {
        delete alphaD;
        delete betaD;
        delete finalD;
    }

    // Setters
    void setName(const string& n) { name = n; }

    void setAlphaDate(int y, int m, int d) {
        delete alphaD;
        alphaD = new Date(y, m, d);
    }

    void setBetaDate(int y, int m, int d) {
        delete betaD;
        betaD = new Date(y, m, d);
    }

    void setFinalDate(int y, int m, int d) {
        delete finalD;
        finalD = new Date(y, m, d);
    }

    // Getters (Marked as `const`)
    string getName() const { return name; }
    Date* getAlphaDate() const { return alphaD; }
    Date* getBetaDate() const { return betaD; }
    Date* getFinalDate() const { return finalD; }

    // Remove a Specific Date
    void removeDate(const string& type) {
        if (type == "alpha" && alphaD) {
            delete alphaD;
            alphaD = nullptr;
        } else if (type == "beta" && betaD) {
            delete betaD;
            betaD = nullptr;
        } else if (type == "final" && finalD) {
            delete finalD;
            finalD = nullptr;
        }
    }

    // Display Deadlines
    void showDeadline(ofstream& out) const {
        out << "Software Name: " << name << "\n";

        out << "Alpha Deadline: ";
        if (alphaD) alphaD->showDate(out);
        else out << "Not Set\n";

        out << "Beta Deadline: ";
        if (betaD) betaD->showDate(out);
        else out << "Not Set\n";

        out << "Final Deadline: ";
        if (finalD) finalD->showDate(out);
        else out << "Not Set\n";
    }
};

int main() {
    ifstream input("input.txt");
    ofstream output("output.txt");

    if (!input || !output) {
        cerr << "Error opening file!\n";
        return 1;
    }

    string softwareName;
    getline(input, softwareName);
    Deadline project(softwareName);

    int y, m, d;
    if (input >> y >> m >> d) project.setAlphaDate(y, m, d);
    if (input >> y >> m >> d) project.setBetaDate(y, m, d);
    if (input >> y >> m >> d) project.setFinalDate(y, m, d);

    project.showDeadline(output);

    return 0;
}

04HF

A feladat elkezdéséhez a mellékelt projekt tartalmaz kódokat.

A megoldás bizonyos feladatoknál ezekhez a kódokhoz is hozzá kell nyúlni, és a teszteléshez a main függvényben a nem használt kódokat ki lehet kommentezni.

Ügyelj arra, hogy minden lefoglalt memória kerüljön megfelelően felszabadításra.

A meglévő Datum osztály, valamint a készítendő DatumLista osztály legyenek a Naptar névtérben.

Készíts egy DatumLista osztályt, amely dátumokat (Datum típus) tárol.

A tárolt dátumok mennyiségét a konstruktorban kapja meg az osztály, és foglaljon helyet ennyi dátumnak (a megadott Datum osztállyal ez alapból nem működik, azt ki kell kicsit egészíteni).

Az osztály tároljon még egy megjegyzést (egy szöveg, ami akár szóközöket is tartalmazhat).

Ezt is kapja meg a konstruktor paraméterben.

Legyen az osztálynak beállító és lekérő függvénye mind a megjegyzéshez, mind az egyes dátumokhoz (setMegjegyzes, getMegjegyzes, setDatum, getDatum), valamint lekérő függvény a dátumok darabszámához is (getDarab).

Egy dátum lekérésénél most nem kell ellenőrizni az indexet, de a beállításnál igen.

Készíts az osztályhoz másoló konstruktort.

Készíts az osztályhoz egy hozzaad függvényt, amely megkap egy dátumot és hozzáadja az osztályhoz, megnövelve a tároló méretét.

Készíts az osztályban egy legkorabbi függvényt, amely visszaadja a dátumok közül a legkorábbit (feltételezhetjük, hogy van dátum az osztályban).

Az osztálynak legyen egy feltolt függvénye, amely paraméterben megkap egy bemeneti fájl folyamot (referenciával működik), és onnan beolvassa a dátumokat (annyit amennyi a tömbbe fér).

Feltételezhetjük hogy a fájlban van kellő mennyiségű dátum megfelelő formában megadva.

Az osztálynak legyen egy logbaIras függvénye, amely paraméterül egy szöveget kap, ami egy fájlnevet jelöl.

A függvény nyissa meg a fájl hozzáadásos (append) módban (létrehozáskor vagy megnyitáskor kell a fájlnév után egy második paraméter is, ami az ios_base::app), írja bele a tárolt megjegyzést, majd az összes tárolt dátumot, majd zárja be a fájlt.

05K

A feladat elkezdéséhez a mellékelt projekt tartalmaz kódokat.

A megoldás bizonyos feladatoknál ezekhez a kódokhoz is hozzá kell nyúlni, és a teszteléshez a main függvényben a nem használt kódokat ki lehet kommentezni.

A megadott osztály a Szemely osztály, mely tárolja egy személy vezeték és keresztnevét, valamint életkorát, pár alapvető függvénnyel.

Ügyelj arra, hogy minden lefoglalt memória kerüljön megfelelően felszabadításra.

Származtass egy Hallgato osztályt a Szemely-ből.

Az osztály tárolja még a hallgató Neptunkódját és befejezett féléveinek számát.

Ezeket is kapja meg a konstruktor, de a félévek száma legyen elhagyható, ekkor az értéke legyen 1.

Getter függvény minden adathoz legyen, setter csak a félévek számához.

A Szemely osztályban van egy kiir függvény, amely kiírja az adatait.

Írd felül ezt a függvényt a Hallgato-ba, amely kiír minden adatot az ősosztály kiir függvényét felhasználva.

Készíts a Hallgato osztályba egy furcsa függvényt.

A függvény igazzal térjen vissza, ha a hallgató fiatalabb, mint ahogy a féléveinek száma sugallja, egyébként hamissal.

(Egy hallgató általában legalább 18 éves, amikor az első félévét elkezdi.) Készíts a Szemely osztályba egy fiatalabb függvényt, ami paraméterben egy másik személyt vár.

A függvény térjen vissza igaz értékkel, ha az adott személy fiatalabb, mint a paraméterben átadott.

Egyébként térjen vissza hamissal.

05HF

A feladat elkezdéséhez a mellékelt projekt tartalmaz kódokat.

A megoldás bizonyos feladatoknál ezekhez a kódokhoz is hozzá kell nyúlni, és a teszteléshez a main függvényben a nem használt kódokat ki lehet kommentezni.

A megadott osztály a Szamsor osztály, amely egy dinamikusan foglalt tömböt tárol egész számokból, pár alapvető függvénnyel.

A tömb méretét a konstruktora adja meg.

Szintén adott a közös feladatban is használt Szemely osztály.

Ügyelj arra, hogy minden lefoglalt memória kerüljön megfelelően felszabadításra.

Származtass egy Rendezveny osztályt a Szamsor osztályból, ami egy egy hetes rendezvény adatait tárolja.

Ebben az ősosztály által létrehozott dinamikus tömb mindenképpen 7 méretű lesz (egy-egy szám a hét minden napjához, ami az adott napi létszám).

Ezen felül tároljon egy Szemely mutatót, ami a rendezvény kiemelt vendégének nevét tárolja (feltéve ha van, ezért mutató).

A kiemelt vendéget lehessen beállítani és lekérdezni.

Készíts a Rendezveny osztályba egy kiir függvényt, amely kiírja az összes adatot.

Készíts másoló konstruktort a Rendezveny osztályhoz.

Készíts a Rendezveny-be egy legjobbNap függvényt, amely kiírja, hogy a rendezvény hanyadik napján volt a legnagyobb a létszám.

Készíts a main.cpp-be egy kisebbAtlag függvényt, amely paraméterben megkap két Szamsor-t.

A függvény írja ki, hogy az első vagy a második paraméterben eltárolt számoknak nagyobb-e az átlaga, vagy esetleg azonos.

06K

A feladat elkezdéséhez a mellékelt projekt tartalmaz kódokat.

A megoldás bizonyos feladatoknál ezekhez a kódokhoz is hozzá kell nyúlni, és a teszteléshez a main függvényben a nem használt kódokat ki lehet kommentezni.

Ügyelj arra, hogy minden lefoglalt memória kerüljön megfelelően felszabadításra.

A megadott osztály a Jatek osztály, mely tárolja egy játék nevét a megjelenési évvel együtt, pár alapvető függvénnyel.

Egészítsd ki a Jatek osztályt egy statikus változóval, aminek segítségével az osztálytól a futás során bármikor lekérdezhető hogy mennyi Jatek típusú objektum létezik a programban.

Az osztály konstruktoraiba és destruktorába bíztosítsd hogy a számolás a megfelelő módon működjön.

Készíts a statikus változóhoz lekérdező függvényt, amellyel az értéke lekérdezhető.

Készíts az osztályba egy másik adattagot, amely azt számolja, hogy a program során összesen mennyi Jatek típusú objektum létezett.

Ez a számláló csak nőhet.

Gondoskodj a változó értékének helyességéről, illetve készíts hozzá lekérő függvényt.

06HF

A feladat elkezdéséhez a mellékelt projekt tartalmaz kódokat.

A megoldás bizonyos feladatoknál ezekhez a kódokhoz is hozzá kell nyúlni, és a teszteléshez a main függvényben a nem használt kódokat ki lehet kommentezni.

Ügyelj arra, hogy minden lefoglalt memória kerüljön megfelelően felszabadításra.

A megadott osztály az Aru osztály, mely tárolja egy termék nevét és nettó árát, pár alapvető függvénnyel.

Legyen az osztálynak egy lebegőpontos, statikus adattagja, amely az ÁFA értékét tárolja, kezdetben legyen 27,5%.

Készíts az osztályba egy bruttoAr függvényt, amely visszaadja a termék bruttó, azaz ÁFÁval növelt árát.

A függvény nyugodtan visszatérhet egész számmal, ami a kerekített érték.

Készíts az ÁFA adattaghoz beállító és lekérdező függvényeket.

Bizonyos termékekre a hivatalostól eltérő, egyedi ÁFA vonatkozhat.

Egészítsd ki az Aru osztályt két új adattaggal: egy lebegőpontos adattag, ami az egyedi ÁFA értékét tárolja, illetve egy logikai értéket, ami igaz, ha a termék esetén az egyedi ÁFÁt kell figyelembe venni, egyébként hamis.

Alapból minden termékre a hivatalos ÁFA vonatkozik.

Készíts egy sajatAfa függvényt, amelyet egy lebegőpontos paraméterrel meghívva beállítja az egyedi ÁFA értékét.

Ezzel együtt a függvény azt is beállítja, hogy a termék innentől kezdve az egyedi ÁFÁt használja.

A sajatAFA függvény legyen meghívható paraméter nélkül is.

Ekkor az egyedi ÁFA értékét ne módosítsa, de a logikai változót állítsa be úgy, hogy a termék a hivatalos ÁFÁt használja.

Az osztályhoz legyen egy valodiAfa függvény, ami visszadja azt az ÁFA értéket, amit az objektum használ (az egyedi ÁFA, amennyiben azt kell kezelni, egyébként az általános).

A bruttoAr függvényt módosítsd úgy, hogy a megfelelő ÁFA értékkel számoljon.

07K

A feladat elkezdéséhez a mellékelt projekt tartalmaz kódokat.

A megoldás bizonyos feladatoknál ezekhez a kódokhoz is hozzá kell nyúlni, és a teszteléshez a main függvényben a nem használt kódokat ki lehet kommentezni.

A megadott osztály a Jarmu osztály, mely tárolja egy jármű sebességét és tömegét.

A konstruktor mindkét értéket várja.

Adott még egy Tarolo osztály, amely legfeljebb 5 járművet tárol, mutatókkal.

Ügyelj arra, hogy minden lefoglalt memória kerüljön megfelelően felszabadításra.

Származtass a Jarmu osztályból két másik osztályt: a Repulo osztály tároljon még egy utas létszámot, a Hajo osztály pedig tároljon még egy teherbírás értéket.

Mindkét osztály a konstruktorban várja az új értékeket is.

A Jarmu osztályban van egy kiir függvényt, amely megjeleníti az adatokat.

Ez a függvényt fejtsd ki a gyerekosztályokban is.

A Jarmu osztály kiir függvényét tedd virtuálissá.

Figyeld meg, milyen hatással van ez a példakód kimenetére.

Tedd a Jarmu osztály destruktorát virtuálissá.

A Jarmu osztályt tedd absztrakt osztállyá azáltal, hogy a kiir függvényt tisztán virtuálissá teszed.

(A main függvényben ekkor a Jarmu osztályhoz tartozó részeket kommentbe kell tenni, hogy a kód forduljon.) Készíts másoló konstruktort a Tarolo osztályba.

07HF

A feladat elkezdéséhez a mellékelt projekt tartalmaz kódokat.

A megoldás bizonyos feladatoknál ezekhez a kódokhoz is hozzá kell nyúlni, és a teszteléshez a main függvényben a nem használt kódokat ki lehet kommentezni.

A megadott osztály a Figura osztály, mely egy sakkfigura adatait tárolja: az oszlop és a sor, ahol a figura van (egy darab szöveg, két karakterrel, pl „A5” vagy „G2”).

A pozíciót a konstruktorban várja.

Ügyelj arra, hogy minden lefoglalt memória kerüljön megfelelően felszabadításra.

Készíts a Figura osztályba egy statikus ervenyes függvényt, amely megkap egy pozíciót, szintén szövegként, és visszaadja hogy a pozíció érvényes-e.

A pozíció érvényes, ha két karakterből áll, melyből az első nagybetű (A-H), a második számjegy (1-8).

A Figura osztályba készíts egy tisztán virtuális lephet függvényt, amely megkap egy pozíciót, szintén szövegként, és visszaadja, hogy a figura léphet-e arra a mezőre.

A függvény feltételezi, hogy a pozíció érvényes, nem kell ellenőriznie.

Származtass a Figura osztályból egy Bastya és egy Kiraly osztályt, majd fejtsd ki ezekben a lephet függvényt.

A sakkban a bástya víszintesen vagy függőlegesen bármennyit léphet (a saját sorában vagy oszlopában bármennyit, de helyben nem maradhat), a király pedig csak a 8 szomszédos mezőre léphet (vízszintesen, függőlegesen, vagy átlósan egyet, ő sem maradhat helyben, ha lép).

Készíts a Figura osztályba egy függvényt odalep néven, amely megkap egy pozíciót, szintén szövegként, és amennyiben a pozíció érvényes, és a figura az adott pozícióra is léphet, akkor a figura pozícióját átállítja ide.

A függvény térjen vissza egy logikai értékkel, amely azt jelzi, hogy a lépés végrehajtható volt-e vagy nem.

Készíts a Figura osztályba egy tisztán virtuális jeloles függvényt, amely egy karaktert ad vissza.

Ezt a gyerekosztályokban fejtsd ki úgy, hogy adja vissza a figurához tartozó egy karakteres jelölést (bástya: ’B’, király: ’K’).

Készítsd el a Futo, Vezer, illetve Huszar osztályokat is.

A main függvény végén lévő kód ezeket is ellenőrzi.

A gyaloggal nem kell foglalkozni, mert az több egyéb dologtól is függ.

08.óra

A feladat elkezdéséhez a mellékelt projekt tartalmaz kódokat.

A megoldás bizonyos feladatoknál ezekhez a kódokhoz is hozzá kell nyúlni, és a teszteléshez a main függvényben a nem használt kódokat ki lehet kommentezni.

A megadott osztály a Szin osztály, amely nem tárol adattagot, viszont egy absztrakt ősosztály lesz, aminek a gyerekosztályai színeket tárolnak különböző módokon.

A színkomponensek kezeléséhez segítséget nyújtó táblázatok a feladat leírás után találhatóak.

Ügyelj arra, hogy minden lefoglalt memória kerüljön megfelelően felszabadításra.

Készíts a Szin osztályba három tisztán virtuális függvényt R, G, illetve B néven, ami majd a szín három komponensét adják vissza unsigned char típusként.

Ezen értékek 0 és 255 között változnak.

Származtass a Szin osztályból egy RGBSzin osztályt, amely három unsigned char típusként tárolja a szín három (r, g, b) komponensét.

A három adatot a konstruktor várja, és állítsa be.

Legyen az osztályba egy paraméter nélküli konstruktor is, amely a fekete színt állítja be.

Fejtsd ki az R, G, és B függvényeket az RGBSzin osztályban úgy, hogy visszaadják a tárolt értékeket.

Származtass egy FeketeFeher osztályt a Szin osztályból, ami egy logikai értéket tárol.

Az érték igaz, ha a szín fekete, illetve hamis, hogyha fehér.

Az osztály konstruktora is ezt az értéket várja.

Fejtsd ki az R, G, és B függvényeket az osztályban.

b

Származtass egy Szurke osztályt a Szin osztályból, amely lebegőpontos értéket tárol, 0 és 1 között.

Ez azt mondja meg, hogy a szürke szín mennyire világos (0-teljesen fekete, 1-teljesen fehér, közte egyenletesen változik).

Fejtsd ki az R, G, és B függvényeket az osztályban.

Készíts a Szin osztályba egy statikus szamotHexava függvényt, amely megkap egy egész értéket (0 és 15 között), és visszaadja az értéket hexa karakterré konvertálva (0-F).

A függvény feltételezheti, hogy az érték tényleg 0 és 15 közötti.

Készíts egy hasonló hexatSzamma függvényt is, amely a fordított átalakítást végzi el.

Készíts egy virtuális printCode függvényt a Szin osztályba.

Ez a függvény adja vissza a színt szövegesen, hexadecimális formában (pl. „#E4CB27”).

Származtass egy SzovegesSzin osztályt az RGBSzin osztályból.

Ez tároljon még egy szöveget, ami a szín szöveges megnevezése („fekete”, „zold”, stb.).

A konstruktora csak ezt a szöveget várja, és állítsa be a szín komponenseit a megfelelő értékre.

Ha a megkapott szöveg nincs a lehetőségek között (lásd a táblázatot a feladat után) akkor a fekete színt tárolja el.

A SzovegesSzin osztály konstruktorát módosítsd úgy, hogy a hexadecimális kódban megadott színt is elfogadja (’#’ az első karaktere), és az alapján is be tudja állítani a komponenseket.

Írd felül a printCode függvényt a SzovegesSzin osztályban úgy, hogy a hexadecimális forma helyett a szín eltárolt megnevezését adja vissza.

Készíts egy megegyezik függvényt a Szin osztályba, amely megkap egy másik, tetszőleges színt (referenciaként), és igaz értékkel tér vissza, ha a két szín megegyezik (mindhárom komponens ugyanaz).

Ha nem, akkor térjen vissza hamissal.

Az RGBSzin osztálynak készíts egy konstruktort, amely paraméterben egy tetszőleges színt vár.

A komponensek értékeit úgy állítsa be, hogy a paraméterben kapott színével megegyezzenek.

Segítség a színek kezeléséhez: Az r, g, b értékek 0 és 255 között változnak (pont, mint az unsigned char).

Hexadecimális kód: mindig ’#’-vel kezdődik, és 16-os számrendszerben tárolja először az r, g, b értékeket ilyen sorrendben, minden komponensnek kettő karaktert hagyva.

Színek, amiket a SzovegesSzin osztály felismerhet:

Színek és RGB értékek

Név	Értékek (R,G,B)	Hexadecimális
fekete	(0,0,0)	#000000
fehér	(255,255,255)	#FFFFFF
kék	(0,0,255)	#0000FF
zöld	(0,255,0)	#00FF00
piros	(255,0,0)	#FF0000
cián	(0,255,255)	#00FFFF
magenta	(255,0,255)	#FF00FF
sárga	(255,255,0)	#FFFF00

sarga (255,255,0) #FFFF00

Egyéb hexadecimális példák: Értékek (R,G,B) (120,65,234) (6,54,15) (212,200,253) (128,96,177) Hexadecimális #7841EA #06360F #D4C8FD #8060B1

09.óra_plusz

A feladat elkezdéséhez a mellékelt projekt tartalmaz kódokat.

A megoldás bizonyos feladatoknál ezekhez a kódokhoz is hozzá kell nyúlni, és a teszteléshez a main függvényben a nem használt kódokat ki lehet kommentezni.

A megadott kód most nem tartalmaz osztályt, csak main függvényt.

Ügyelj arra, hogy minden lefoglalt memória kerüljön megfelelően felszabadításra.

Hozz létre egy Halmaz osztályt, amely double értékeket tárol egy átméreteződő tömbben, mely mindig pontosan akkora, amennyi számot tárol.

Az osztály számok halmazát kezeli majd.

Az osztály konstuktora nem vár paramétert.

Az operátoroknak különböző méretű halmazokra is működniük kell, így a megfelelő átméretezésre figyelni kell.

Készíts a Halmaz osztályba egy meret függvényt, amely visszaadja a halmaz méretét (eltárolt elemek számát).

A Hamaz osztályhoz definiálj egy << operátort, amellyel elemeket lehet hozzáadni.

Az operátor működése a következő:

• Halmaz h;
• h<<8.5<<5<<4<<12.33; // Minden elemet hozzáad a h halmazhoz, balról jobbra haladva.
• A halmazban minden elem csak egyszer szerepelhet.
• A hozzáadást úgy készítsd el, hogy a belső tömbben az elemek mindig növekvő sorrendben szerepeljenek.

Vagyis nem a tömb végére szúrja be az új elemet, hanem megkeresi a helyét a rendezett elemek között.

A Hamaz osztályhoz definiálj egy >> operátort, amivel a halmazból ki lehet venni elemeket.

Az operátor működése a következő:

• h>>6.123>>4>>12.33; // Minden elemet kiszed a h halmazból, balról jobbra haladva.
• A halmazban nem létező elemet nyilván figyelmen kívül kell hagyni.

A Hamaz osztályhoz definiálj egy << operátort, amivel a halmaz elemeit lehet kiírni bármilyen kimeneti folyamra.

Új sor ne legyen a kiírás végén.

Példa:

• Halmaz h;
• h<<8.5<<5<<4<<12.33; // Ez még a korábbi << operátor, amivel elemeket adunk hozzá.
• cout<<h<<endl; // Ez már az új, amivel kiiratunk.
• A kimenet ekkor: {4, 5, 8.5, 12.33} // Az elemeket rendezve tároljuk, ezért így is jelennek meg.

Készíts a Halmaz másoló konstruktort és destruktort.

A Hamaz osztályhoz definiáld az = operátort, amivel egy halmazt másolni lehet.

A Hamaz osztályhoz definiálj egy [] operátort, ami a paraméterben kapott számra visszaadja, hogy az a halmaznak eleme-e vagy nem.

A Hamaz osztályhoz definiálj egy & operátort, amely két halmazra elvégzi a metszet műveletet, és visszatér az eredménnyel.

A Hamaz osztályhoz definiálj egy | operátort, amely két halmazra elvégzi az unió műveletet, és visszatér az eredménnyel.

A Hamaz osztályhoz definiálj egy - operátort, amely két halmazra elvégzi a halmazkivonás (bal oldali halmazból kivonja a jobb oldali halmazt) műveletet, és visszatér az eredménnyel.

A Hamaz osztályhoz definiálj egy ^ operátort, amely két halmazra elvégzi a kölcsönös kizárás műveletet, és visszatér az eredménnyel.

Definiáld az előző operátorok azon verzióját, amelyek a bal oldali halmazt módosítják, és nem újat készítenek (&=, |=, -=, ^=).

A Hamaz osztályhoz definiálj egy + operátort, amelynek bal oldalán a halmaz van, jobb oldalán egy lebegőpontos szám.

Az operátor eredménye egy új halmaz, melyet úgy kap, hogy az eredeti halmazhoz hozzáadja a számot.

A Hamaz osztályhoz definiálj egy - operátort, amelynek bal oldalán a halmaz van, jobb oldalán egy lebegőpontos szám.

Az operátor eredménye egy új halmaz, melyet úgy kap, hogy az eredeti halmazból kivonja a számot.

A Hamaz osztályhoz definiálj egy < operátort, amely két halmazt hasonlít össze, és akkor tér vissza igaz értékkel, ha a bal oldali halmaz valódi részhalmaza a jobb oldalinak.

Definiáld a <= operátort is, amely megengedi az egyenlőséget is.

A Hamaz osztályhoz definiálj egy > operátort, amely két halmazt hasonlít össze, és akkor tér vissza igaz értékkel, ha a jobb oldali halmaz valódi részhalmaza a bal oldalinak.

Definiáld a >= operátort is, amely megengedi az egyenlőséget is.

A Hamaz osztályhoz definiáld az == operátort, amely két halmazt hasonlít össze, és akkor tér vissza igazzal, ha a két halmaz megegyezik.

Definiáld a != operátort is, ami pont az ellenkezőjét csinálja.

Készíts a Halmaz osztályba egy legnagyobb függvényt, amely visszaadja a halmazban tárolt legnagyobb elemet.

Készíts a Halmaz osztályba egy legkisebb függvényt, amely visszaadja a halmazban tárolt legkisebb elemet.

Készíts a Halmaz osztályba egy torol függvényt, amely kitöröl minden elemet a halmazból

09.óra_Sablonok1

1. rész A feladat teszteléséhez a mellékelt projekt tartalmaz egy main függvényt.

Készíts egy sablonos Tomb osztályt, amely egy statikus tömböt valósít meg objektum-orientált formában.

Az osztály a következő módon működik:

• 2 sablon-paramétere van. Az első egy típus, hogy milyen típusú adatokat tároljon a tömb. A második egy egész szám, hogy hány eleme legyen a tömbnek.
• Az osztály tároljon egy megfelelő típusú és méretű tömböt (statikus tömbként, nem kell dinamikus memóriafoglalás).
• Feltételezhetjük, hogy a tárolt típusnak van paraméter nélkül hívható konstruktora Készítsd el az osztályhoz az alábbi függvényeket: meret: visszaadja a tömb méretét beallit: megkap egy indexet és egy értéket, és beállítja a tömb adott indexű elemét a kapott értékre (érvénytelen indexre ne csináljon semmit) leker: megkap egy indexet, és visszaadja a tömb adott indexű elemét (pontosabban egy másolatot), az index helyességét nem kell ellenőrizni elem: megkap egy indexet, és visszaadja a tömb adott indexű elemét referenciaként (ezáltal a függvényen keresztül akár módosítható is lesz), az index helyességét nem kell ellenőrizni
• Az elem függvényhez készíts egy konstans verziót is, ami konstans referenciát ad vissza.
• Ha már mennek az operátorok, akkor elkészíthető a [] oprátor is két verzióban, ugyanezzel a funkcionalitással.

2. rész Az első részben elkészített kód folytatása.

Ebben a részben közös ősosztályt készítünk az azonos típusú tömböknek.

Készíts egy sablonos TombAlap osztályt, aminek az egyetlen sablon paramétere a tárolt adat típusa lesz.

Az osztálynak adattagja nem lesz, csak egy interfészként szolgál az azonos típusú tömbök kezelésére.

A meret, beallit, leker, és elem függvények mind legyenek tisztán virtuális függvények az osztályban.

• Ha van [] operátor, azt szintén meg lehet csinálni tisztán virtuálisnak.

De még jobb, ha nem virtuális, hanem meghívja a virtuális elem függvényt, ami ugyanazt csinálja.

A Tomb osztályt módosítsd úgy, hogy származzon abból a TombAlap osztályból, ami ugyanazzal a sablonparaméterrel rendelkezik (típus), függetlenül a tömb méretétől.

Készíts a main.cpp-be egy tombKiir függvényt, melynek sablon paramétere egy típus legyen, a függvény paramétere pedig egy mutató egy ilyen típusú elemeket tároló TombAlap-ra.

A függvény jelenítse meg a tömb elemeit.

A tombkiir függvényből készíts egy másik verziót, ami referenciaként kapja a paramétert, és nem mutatóként.

09.óra_Sablonok2

A feladatban asszociatív tárolót valósítunk meg.

Az asszociatív tároló egy olyan adaszerkezet, ami kulcs-érték párokat tárol.

Minden kulcs csak egyszer szerepelhet a tárolóban, és egyértelműen azonosítja a hozzá tartozó értéket (mint ahogy tömbök esetén is az index egyértelműen azonosítja az értéket).

Készíts egy sablonos KulcsErtekPar struktúrát (igen, struktúra, ennek publikusak lesznek az adattagjai), ami egy kulcs-érték párt tárol (két tetszőleges típusú adat).

A struktúra kettő sablon paramétere a kettő tárolt érték típusa legyen.

A KulcsErtekPar struktúrának legyen egy paraméter nélküli konstruktora, valamint egy olyan is, amely mind a két belső adatot várja.

Készíts egy Asszociativ osztályt, amely a tárolót valósítja meg.

Az osztály kettő sablon paramétert várjon, és ilyen értékeket tartalmazó KulcsErtekPar-ok dinamikus tömbjét tárolja.

A tömbnek a mérete nem fix, hanem folyamatosan újrafoglalódik a megfelelő méretre.

Legyen hozzá megfelelő destruktor is.

Készítsd el az Asszociativ osztályhoz a következő függvényeket:

• meret: Adja vissza a tárolt kulcs-érték párok számát (belső tömb mérete).
• keres: Ez nem kötelező, de egy ajánlott belső (privát) függvény, ami segíti majd a későbbi munkát.

A függvény megkap paraméternek egy kulcsot (annak megfelelő típusú adatot), és visszaadja hogy a belső tömbnek melyik indexén szerepel ez a kulcs.

Adjon vissza valami speciális értéket, ha nem találja (például a tömb mérete, vagy a -1).

• beallit: Paraméterül kap egy kulcsot és egy értéket.

Ha a kulcs már szerepel a tömbben, akkor a hozzá tartozó értéket állítsa át a paraméterben kapottra.

Ha még nem szerepel, akkor adjon hozzá a tárolóhoz egy új kulcs-érték párt a paraméterben kapott értékekkel.

• kulcsByIndex: paramétere egy egész szám (index), és visszaadja a tömb adott indexű elemén lévő kulcs-érték párból a kulcsot (nem kell ellenőrizni az index helyességét).
• ertekByIndex: paramétere egy egész szám (index), és visszaadja a tömb adott indexű elemén lévő kulcs-érték párból az értéket (nem kell ellenőrizni az index helyességét).
• vane: Paraméterül egy kulcsot kap, és visszaadja hogy szerepel-e ilyen kulcsú elem a tömbben.
• ertek: Paraméterül egy kulcsot kap, és visszaadja az adott kulcshoz tartozó értéket.

Ha nincs ilyen kulcs a tömbben, akkor adjon vissza egy dummy értéket (paraméter nélküli konsruktorral lérehozva).

• ertekVagyDefault: Az ertek függvényhez hasonló, de kettő paramétert vár: Az első a kulcs, a második egy alapértelmezett érték.

Amennyiben van ilyen kulcs a tömbben, egyszerűen visszaadja az ahhoz tartozó értéket.

Amennyi nincs, úgy a függvény második paraméterét adja vissza.

• torol: Paraméterül egy kulcsot kap, és kitörli az adott kulcshoz tartozó kulcs-érték párt a tömbből.

Ha nincs ilyen kulcs, nem csinál semmit.

• [] operátor: Paramétere egy kulcs, és visszaadja az adott kulcshoz tárolt értéket referenciaként.

Ha nincs ilyen kulcs, akkor adjon egy új kulcs-érték párt a tömbhöz (a kulcs a paraméterből jön, az érték egy dummy, paraméter nélküli kontruktorral létrehozott objektum), és adja vissza ebből az értéket.

09.óra

A feladat elkezdéséhez a mellékelt projekt tartalmaz kódokat.

A megoldás bizonyos feladatoknál ezekhez a kódokhoz is hozzá kell nyúlni, és a teszteléshez a main függvényben a nem használt kódokat ki lehet kommentezni.

A megadott osztály a Vektor osztály, amely egy matematikai vektort ábrázol.

Az osztály tárolja a vektor méretét, illetve a megfelelő mennyiségű lebegőpontos számot tároló tömböt.

Ezeket a konstruktor állítja be, ami a méretet várja paraméterül.

Ügyelj arra, hogy minden lefoglalt memória kerüljön megfelelően felszabadításra.

(a) Készíts a Vektor osztályhoz egy + operátort, amely a vektort összeadja egy másik vektorral.

A visszatérési érték az új vektor legyen.

(b) Készíts a Vektor osztályhoz egy += operátort, amely a vektorhoz hozzáad egy másik vektort.

A visszatérési érték maga a módosított vektor legyen.

(c) Készíts a Vektor osztályhoz egy + operátort, amely egy lebegőpontos számot és egy vektort ad össze úgy, hogy a szám van a bal oldalon.

A visszatérési érték egy új vektor, melynek értékei az eredeti vektor értékei összeadva a számmal.

Készíts a Vektor osztályhoz egy = operátort, ami paraméterként egy másik vektort vár, és jelen vektort átírja, hogy megegyezzen a paraméterben megkapottal.

Készíts a Vektor osztályhoz prefix, majd a postfix -- operátort, amik a vektor minden elemét csökkentik eggyel.

Készíts a Vektor osztályhoz << operátort, amely a megkapott kimeneti folyamra megjeleníti a vektor elemeit.

b

Készítsd el a Vektor osztályhoz a fentebbi (a), (b), (c)-vel jelölt feladatoknak megfelelően a többi számolós (-, /, *, -=, /=, *=) operátorokat.

A (c) esetében figyleni kell, hogy a kivonás és az osztás esetében nem mindegy a sorrend, és most a szám van a bal oldalon, és a vektor a jobb oldalon.

Készítsd el a Vektor osztályhoz azokat a +, -, /, * operátorokat, amelyek a (c)-vel jelölt feladatnak megfelelően működnek, de ezúttal a szám van a jobb oldalon.

Készítsd el a Vektor osztályhoz a prefix és postfix ++ operátorokat, amelyek a vektor minden elemét megnövelik eggyel.

Készítsd el a Vektor osztályhoz a [] operátort, amely egy egész számot vár paraméterül, és visszaadja az osztályon belüli tömb adott indexű elemét referenciaként (így az operátoron keresztül lehet módosítani).

Ez pont olyan, mintha egy tömböt indexelnénk.

Készítsd el az előbbi [] operátor konstans verzióját is, amely konstans referencát ad vissza.

Készíts a Vektor osztályhoz ^ operátort, ami két vektorral dolgozik, és a kettő skaláris szorzatát számolja ki és adja vissza.

Készíts a Vektor osztályhoz unáris * operátort, amely visszaadja a vektor hosszát.

Készíts a Vektor osztályhoz unáris ~ operátort, ami a vektort adja vissza normalizálva.

Készíts a Vektor osztályhoz == opertárort, amely megkap egy másik vektort, és igazzal tér vissza ha a két vektor megegyezik (ugyanannyi elemük van, és azok ugyanazok, ugyanabban a sorrendben), egyébként hamissal.

Készítsd el a Vektor osztályhoz != operátort is, amely pont az előző ellentéte.

Készíts a Vektor osztályhoz < opertátort, amely megkap egy másik vektort, és igazzal tér vissza ha a két vektornak ugyanannyi eleme van, és a bal oldali vektor elemei rendre kisebbek a jobb oldali vektor elemeinél.

Pl.: a (2,3,4) vektor kisebb a (4,7,6) vektornál, mert 2<4, 3<7, és 4<6, de nem kisebb a (3,3,5) vektornál, mert a középső helyen a 3<3 nem igaz.

09_sab

Készíts egy struktúrát, amely egy űrhajó adatait tárolja:

• Hajó hossza
• Legénység maximális mérete
• Maximális sebesség
• Képes-e a hajó hipertér-ugrásra A struktúra és a lenti függvények (main-en kívül) legyenek egy urhajo nevű névtérben.

A struktúra ezen belül legyen egy adat, a függvények pedig egy muveletek nevű névtérben.

A megfelelő using deklarációkkal biztosítsd, hogy a main-ben megírt kód működjön.

Készíts egy függvényt, amely megkap paraméterben egy darabszámot, és helyet foglal ennyi űrhajónak.

Kérd be, hogy hány űrhajó adatait tárolja a program, és foglalj helyet nekik a függvény segítségével.

Olvasd be az űrhajók adatait.

Készíts egy függvényt, amely megkapja az űrhajók tömbjét, és kilistázza az összes űrhajót amely képes hipertér ugrásra.

A függvény meghívásával listázd ki a hajókat.

Készíts egy függvényt, amely megkapja az űrhajók tömbjét, és egy egész számot (létszám), és visszaadja azon hajók darabszámát, amelyek a megadott mennyiségű embert képesek elszállítani.

A létszámot ne legyen kötelező megadni, ha elhagyjuk akkor tekintsük 100-nak.

Jelenítsd meg a függvény meghívásával a 400 főt szállítani képes hajók számát.

Készíts egy függvényt, amely visszaad egy mutatót a leglassabb hajóra.

A függvénynek legyen egy második, logikai paramétere, mely alapértelmezetten hamis.

Ha ezt a paramétert is megadjuk, és igaz, akkor csak azon hajók között keressen a függvény, amelyen nem képesek hipertér-ugrásra.

A függvény meghívásával jelenítsd meg a leglassabb hajó adatait, majd a leglassabb, hipertér-ugrásra nem képes hajó adatait.

Szabadítsd fel a lefoglalt memóriát.

10

A feladat elkezdéséhez a mellékelt projekt tartalmaz kódokat.

A megoldás bizonyos feladatoknál ezekhez a kódokhoz is hozzá kell nyúlni, és a teszteléshez a main függvényben a nem használt kódokat ki lehet kommentezni.

A megadott kód most nem tartalmaz osztályt, csak main függvényt.

Ügyelj arra, hogy minden lefoglalt memória kerüljön megfelelően felszabadításra.

A feladat során getter függvényeket szükség szerint készíthetsz.

Készíts egy Utvonal osztályt, ami egy barlangtúra adatait tárolja: megnevezés (szöveg), hossz, nehézség (egészek).

• Készíts az osztályhoz egy << operátort, amellyel ki lehet írni a tartalmát egy tetszőleges kimeneti folyamra.

Készíts egy absztrakt Szemely osztályt, amely egy személy adatait fogja tárolni: név (szöveg), életkor (egész szám).

• Legyen egy tisztán virtuális resztvehet függvénye, melynek paramétere egy Utvonal, visszatérése bool, és majd a gyerekosztályokban eldönti, hogy egy személy részt vehet-e egy adott túrán.
• Legyen egy virtuális kiir függvénye, amely kiírja a személy adatait a kimenetre.

Származtass Turazo osztályt a Szemely-ből.

Egy túrázóhoz tárolni kell még a maximális teherbírását (milyen hosszú túrára képes), és egy ügyességi szintet (egészek).

• A resztvehet függvény szerint a túrázó akkor vehet részt a túrán, ha a hossz-teherbírása eléri a túra hosszát és az ügyességi szintje is eléri a túra nehézségi szintjét.
• Írd felül a kiir függvényt, hogy kiírja a túrázó minden adatát.

Az ősosztály adatainak kiírásához használd a ősosztályban lévő függvényt.

Származtass Turavezeto osztályt a Szemely-ből.

Egy túravezetőhöz tárolni kell még egy értéket, ami a túravezetési szintjét tárolja, valamint azt, hogy hány éve vezet túrákat (egészek).

• A resztvehet függvény szerint a túravezető akkor vehet részt egy túrán, ha a túravezetési szintje eléri a túra nehézségét.

Azonban, ha már legalább 10 éve van a szakmában, akkor megengedjük hogy a szintjénél eggyel nehezebb túrák vezetését is.

• Írd felül a kiir függvényt, hogy kiírja a túrázó minden adatát.

Az ősosztály adatainak kiírásához használd a ősosztályban lévő függvényt.

Származtass Barlangfeltaro osztályt a Szemely-ből.

Egy barlangfeltáró személy esetében tároljuk hogy mennyi ideje csinálja ezt, illetve hogy hány barlag feltárásában vett részt (egészek).

• A resztvehet függvény szerint egy ilyen személy bármilyen barlangba bemehet, hiszen ez a dolga.
• Írd felül a kiir függvényt, hogy kiírja a túrázó minden adatát.

Az ősosztály adatainak kiírásához használd a ősosztályban lévő függvényt.

Készíts egy Csoport osztályt, ami személyeket tárol tetszőleges mennyiségben.

• Hozd létre a megfelelő adatszerkezetet tetszőleges mennyiségű és típusú személy tárolásához.
• A csoporthoz személyt a += operátorral lehessen hozzáadni (lásd main).

Készíts egy [] operátort, ami egy indexet vár, és visszatér az ennyiedik helyen lévő személy memóriacímével.

Érvénytelen index esetén nullpointerrel térjen vissza (lásd main).

Legyen egy alkalmas függvény, ami megvizsgálja, hogy a csoport alkalmas-e egy adott túrán való részvételre (a túrát paraméterben kapja).

Egy csoport akkor vehet részt egy túrán, ha egyrészt minden résztvevő bemehet a barlangba, illetve ha minden túravezetőhöz legfeljebb 5 túrázó tartozik.

Természetesen túravezetők és feltárók önmagukban bemehetnek.

Készíts egy kiir függvényt, ami kiírja a csoport összes tagját a képernyőre.

Készíts egy maximum függvényt, ami két adatot jelenít meg a képernyőn: mi a maximális hossz és nehézségi szint egy olyan túránál, amin a csoport még részt tud venni.

Itt eltekintünk az 5 túravezetőnként 5 túrázó feltételtől, csak elméleti határt nézünk.

Készíts = operátort az osztályhoz (lásd main).

11Gy1

A feladat elkezdéséhez a mellékelt projekt tartalmaz kódokat.

A megoldás bizonyos feladatoknál ezekhez a kódokhoz is hozzá kell nyúlni, és a teszteléshez a main függvényben a nem használt kódokat ki lehet kommentezni.

A megadott osztály a Szemely osztály, mely tárolja egy személy nevét, valamint életkorát, pár alapvető függvénnyel.

Ügyelj arra, hogy minden lefoglalt memória kerüljön megfelelően felszabadításra.

Készíts egy SzemelyTarolo osztályt, amely személyeket képes tárolni tetszőleges mennyiségben (átméreteződő dinamikus tömb).

A megoldásban a tömb mérete, és az eltárolt személyek mennyisége nem feltétlenül egyezik meg.

Legyen az osztálynak egy hozzaad függvénye, amely a paraméterben megkapott személyt hozzáadja a tárolóhoz.

A függvény úgy működjön, hogy a ne legyen kihasználatlan elem, vagyis a kapacitás mindig annyi legyen, mint a ahány elemet tárolunk.

Az osztályban legyen egy függvény, ami visszaadja, hogy az osztály éppen hány személyt tárol (getDarab).

Az osztályban legyen egy függvény, ami visszaadja, hogy az osztályon belüli tömbnek éppen mekkora a kapacitása (getKapacitas).

Legyen az osztályban egy elem függvény, amely megkap egy indexet és referenciát ad vissza a tömb adott elemére.

A függvényen keresztül lehet a tömb elemeit lekérdezni és módosítani.

Legyen az elem függvénynek egy olyan változata, amely meghívható konstans objektumra, és csak lekérdezésre használható.

11Gy2

A feladat elkezdéséhez a mellékelt projekt tartalmaz kódokat.

A megoldás bizonyos feladatoknál ezekhez a kódokhoz is hozzá kell nyúlni, és a teszteléshez a main függvényben a nem használt kódokat ki lehet kommentezni.

A megadott osztály a Szemely osztály, mely tárolja egy személy nevét, valamint életkorát, pár alapvető függvénnyel.

Szintén adott az előző gyakorló feladatban elkészített SzemelyTarolo osztály.

Ügyelj arra, hogy minden lefoglalt memória kerüljön megfelelően felszabadításra.

Készíts a SzemelyTarolo osztályba másoló konstruktort.

Származtass a SzemelyTarolo osztályból egy SzemelyTaroloFix osztályt.

Ezen osztály konstruktora várjon egy paramétert, amely a kezdeti kapacitását adja meg a tárolónak (de az eltárolt értékek száma továbbra is 0 az elején, csak lesznek a tömben nem használt elemek, tipp: protected konstruktor az ősosztályba, amelyik vár egy alap kapacitást).

Az osztály definiálja felül az ősosztály hozzaad függvényét úgy, hogy amíg van hely a tömbben az új elemnek, addig tegye bele, ha nincs, akkor foglalja újra nagyobb méretűre.

Újrafoglaláskor a tömb mérete az eredeti kapacitás értékével nőjön (a konstruktor paramétere).

Származtass a SzemelyTarolo osztályból egy SzemelyTaroloDuplaz osztályt.

Ebben a kezdeti kapacitás 1.

A hozzaad függvényt írd felül úgy, hogy valahányszor nincs több hely, az osztály duplázza meg a tömb jelenlegi kapacitását.

Származtass a SzemelyTaroloFix osztályból egy SzemelyTaroloDuplazFix osztályt, amely a konstruktorában szintén megkapja egy értéket, amennyivel növelni fogja majd a tömb kapacitását.

A kapacitás itt is a paraméterben megadott értékről indul.

Az osztályban legyen egy statikus adattag, amit lehet beállítani és lekérdezni is (kezdetben 64).

Ez egy maximális kapacitást tároljon.

Amíg a kapacitás ennél kisebb, addig a hozzaad függvény duplázza a kapacitást bővítéskor, utánna pedig a konstruktorban megkapott fix értékkel növeli.