Třídy, metody, atributy

Třída se skládá z těchto hlavních částí:

• deklarace třídy – zde definujeme název třídy a její členy (atributy, metody)
• atributy – proměnné použité k uchování dat nebo stavu objektu
• metody – funkce, které definují chování objektu

Zdroj obrázku: https://takeuforward.org/c/c-classes-and-objects/

Definice a implementace třídy

V C++ je běžnou praxí rozdělit definici třídy a její implementaci mezi dva soubory: header soubor .h a source soubor .cpp.

Toto rozdělení má několik důvodů a přináší řadu výhod pro organizaci a správu kódu, zejména v rozsáhlých projektech.

Zdroj obrázku: https://takeuforward.org/c/c-classes-and-objects/

Header soubor (.h)

Header soubor obvykle obsahuje:

• deklaraci tříd – definice tříd včetně jejich atributů a metod
• prototyp funkcí – deklarace funkcí, které budou implementovány v source souboru
• definice konstant a globálních proměnných – týká se však pouze externích deklarací, pokud se vyžaduje, aby byly proměnné viditelné v různých souborech

Výhody použití header souborů:

• zapouzdření – umožňuje skrýt implementaci a poskytnou pouze nezbytné informace potřebné k použití třídy nebo funkce
• znovupoužitelnost – header soubory můžeme znovu použít ve více projektech nebo částech projektu prostřednictvím include
• přehlednost – udržuje kód čistší a přehlednější, když jsou definice odděleny od implementací

#ifndef OSOBA_H  // Zamezí opakovanému includování
#define OSOBA_H

#include <string>
#include <iostream>

using namespace std;

class Osoba {
private:
    string jmeno;
    int vek;

public:
    Osoba(string jmeno, int vek);
    void zobrazInfo() const;
};

#endif

Source soubor (.cpp)

Source soubor obsahuje:

• implementaci metod tříd – konkrétní kód metod deklarovaných v header souboru
• implementaci funkcí – kód pro funkce prototypované v header souboru

Název funkce (metody) musí být totožný s předpisem (prototypem)

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

Osoba::Osoba(string jmeno, int vek) : jmeno(jmeno), vek(vek) {}

void Osoba::zobrazInfo() const {
    cout << "Jméno: " << jmeno << ", Věk: " << vek << endl;
}

Použití v main

Stačí includovat název header souboru.

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

int main() {
    Osoba osoba1("Petr Novák", 30);
    osoba1.zobrazInfo();
    return 0;
}

Specifikace přístupu

Specifikace přístupu (access specifiers) jsou klíčově pro určení, kdo může přistupovat k atributům a metodám třídy. Existují tři hlavní typy specifikátorů přístupu: public, private a protected.

Každý z nich hraje důležitou roli v principu zapouzdření, který je základem OOP.

public

Členy třídy (atributy, metody), které jsou deklarovány jako public, jsou přístupné odkudkoliv mimo třídu, kde byly deklarovány. To znamená, že k těmto členům lze přistupovat jak z vnějšku třídy, tak z jejich potomků a z jiných tříd.

Tento specifikátor je obvykle používán pro metody, které tvoří „rozhraní“ třídy – jinými slovy, funkce, které jsou určeny k tomu, aby byly volány z jiných částí programu.

Také se používá pro konstruktory a destruktory, které musí být volány zvenčí třídy.

private

Členy třídy (atributy, metody), které jsou označené jako private, jsou přístupné pouze z metod stejné třídy. To znamená, že tyto členy nejsou dostupné z vnějšku třídy, ani z jejich potomků.

private je výchozí specifikátor přístupu pro členy třídy v C++.

private členy jsou ideální pro skrytí implementačních detailů třídy, které by neměly být přístupné uživateli třídy.

Tento specifikátor je často používán pro atributy, aby se zabránilo jejich přímé manipulaci a aby bylo zajištěno, že jakékoli změny těchto atributů probíhají kontrolovaně prostřednictvím metod.

protected

Členy označené jako protected, jsou dostupné z třídy, ve které jsou deklarovány a také z tříd, které z této třídy dědí. To znamená, že protected členy jsou neviditelné pro vnější svět, ale dostupné pro „rodinné“ třídy.

Tento specifikátor je často používán pro atributy nebo metody, které chceme sdílet s potomky tříd, ale nechceme je zpřístupnit ostatním částem programu., aby se zabránilo jejich přímé manipulaci a aby bylo zajištěno, že jakékoli změny těchto atributů probíhají kontrolovaně prostřednictvím metod.

Příklad užití různých specifikátorů

#include <iostream>
using namespace std;

class Osoba {
private:
    int tajneCislo;

protected:
    string rodneCislo;

public:
    string jmeno;
    int vek;

    Osoba(string jmeno, int vek, string rc, int tajne) : jmeno(jmeno), vek(vek), rodneCislo(rc), tajneCislo(tajne) {}

    void tisk() {
        cout << "Jmeno: " << jmeno << ", Vek: " << vek << endl;
    }

    // Metoda dostupná pouze v rámci třídy
    private:
    void zobrazTajneCislo() {
        cout << "Tajne cislo: " << tajneCislo << endl;
    }
};

class Zamestnanec : public Osoba {
public:
    Zamestnanec(string jmeno, int vek, string rc, int tajne) : Osoba(jmeno, vek, rc, tajne) {}

    void zobrazRodneCislo() {
        cout << "Rodne cislo: " << rodneCislo << endl;
    }
};

int main() {
    Zamestnanec emp("Petr Novak", 30, "010101/0101", 123456);
    emp.tisk();
    emp.zobrazRodneCislo();
    // emp.zobrazTajneCislo(); // Toto by způsobilo chybu při kompilaci, metoda je privátní
    return 0;
}

Atributy

Atributy, často nazývané také jako datové členy, jsou proměnné svázané s konkrétní třídou nebo objektem.

Tyto proměnné uchovávají data, která jsou relevantní pro objekty třídy a jsou klíčové pro stav objektu.

V C++ je důležité správně určit typ a rozsah viditelnosti těchto atributů, aby odpovídaly zamýšlenému použití a principům zapouzdření.

Zdroj obrázku: https://takeuforward.org/c/c-classes-and-objects/

Typy atributů

Atribut instance:

• tyto atributy jsou specifické pro každý objekt třídy
• každý objekt má svou vlastní kopii těchto atributů
• typicky jsou to běžné proměnné definované v třídě

Příklad: každá osoba má své vlastní jméno a věk.

Statický atribut:

• tyto atributy patří třídě jako celku, nikoliv jednotlivým objektům
• existuje jen jedna kopie pro celou třídu, bez ohledu na to, kolik objektů třídy existuje
• přístup k nim je možný přímo přes název třídy, i když neexistuje žádná instance

Příklad: počítadlo objektů třídy nebo konstanta sdílená všemi instancemi.

class Osoba {
private:
    string jmeno;  // Atribut instance
    int vek;       // Atribut instance

public:
    static int pocetOsob;  // Statický atribut

    Osoba(string jmeno, int vek) : jmeno(jmeno), vek(vek) {
        pocetOsob++;  // Každá nová instance zvýší počet osob
    }

    ~Osoba() {
        pocetOsob--;  // Destruktor snižuje počet osob
    }

    void tisk() const {
        cout << "Jméno: " << jmeno << ", Věk: " << vek << endl;
    }
};

int Osoba::pocetOsob = 0;  // Inicializace statického atributu

Metody

Metody jsou funkce, které definují chování objektů třídy.

Metody umožňují objektům provádět operace na svých datech, komunikovat s jinými objekty nebo provádět jakékoliv další akce, které jsou součástí logiky programu.

Metody jsou klíčovým aspektem objektově orientovaného programování, protože propojují data (atributy) s funkcemi, které s těmito daty manipulují.

Typy metod

Metody instance:

• operují na konkrétních instancích třídy
• mají přístup k instančním atributům a metodám

Statické metody

• ppatří celé třídě, nikoli jednotlivým instancím
• můžou být volány bez vytvoření instance třídy
• nemají přístup k instančním atributům nebo metodám, mohou však manipulovat se statickými členy třídy

Metody instance:

• speciální metody volané při vytváření nového objektu
• slouží k inicializaci objektu
• nemají návratový typ a název je stejný jako název třídy

Metody instance:

• speciální metody volané při zničení objektu
• slouží k uvolnění zdrojů a k čištění
• nemají návratový typ a jsou označeny tildou (~) před názvem třídy

// Osoba.h - Header soubor
class Osoba {
public:
    Osoba(std::string jmeno, int vek);  // Konstruktor
    void tisk() const;  // Metoda instance
    static int pocetOsob();  // Statická metoda
};

// Osoba.cpp - Source soubor
#include "Osoba.h"
#include <iostream>
int Osoba::pocetInstanci = 0;  // Inicializace statické proměnné

Osoba::Osoba(string jmeno, int vek) {
    // implementace konstruktoru
}

void Osoba::tisk() const {
    // implementace metody
}

int Osoba::pocetOsob() {
    return pocetInstanci;
}

Zdroj obrázku: https://takeuforward.org/c/c-classes-and-objects/

Speciální typy metod

• Gettery a Settery – metody používané pro čtení (get) a nastavení (set) hodnot instančních atributů, které jsou typicky deklarovány jako private, pro zachování zapouzdření
• Přetížené metody – metody stejného jména, ale s různými parametry, což umožňuje různé použití v závislosti na kontextu volání
• Virtuální metody – metody, které lze v odvozených třídách přepsat, umožňují polymorfismus

Vytváření instancí

Když definujeme třídu, vytvoříme pouze „návrh“ nebo „šablonu“ pro objekty, které pak můžeme vytvářet.

Samotná instance třídy (objekt) je vytvořena pomocí konstruktoru třídy.

class Osoba {
public:
    string jmeno;
    int vek;

    // Konstruktor
    Osoba(string jmeno, int vek) : jmeno(jmeno), vek(vek) {}
};

int main() {
    // Vytvoření instance 'osoba1'
    Osoba osoba1("Petr Novák", 30);

    // Vytvoření instance 'osoba2' pomocí nového operátoru
    Osoba *osoba2 = new Osoba("Anna Svobodová", 25);

    // Použití objektů
    cout << osoba1.jmeno << " je " << osoba1.vek << " let starý." << endl;
    cout << osoba2->jmeno << " je " << osoba2->vek << " let stará." << endl;

    // Uvolnění paměti
    delete osoba2;
}

Metody vytváření instancí:

• automatické (stack) alokace – instance jsou vytvářeny na zásobníku a jsou automaticky uvolněny po opuštění bloku kódu, ve kterém byly deklarovány.
• dynamické (heap) alokace – instance jsou vytvářeny na haldě pomocí operátoru new. Tyto objekty zůstávají existovat, dokud nejsou explicitně zničeny operátorem delete.

Zdroje