Přístupové modifikátory hrají klíčovou roli při definování dostupnosti členů třídy. C++ poskytuje tři základní přístupové modifikátory: public (veřejný), private (soukromý) a protected (chráněný). Tyto modifikátory pomáhají implementovat zapouzdření a skrytí informací, což zajišťuje, že vnější svět má přístup pouze k nezbytným částem třídy.
Přehled přístupových modifikátorů
Veřejný přístupový modifikátor (public)
Členové třídy, kteří jsou deklarovaní jako public jsou přístupní odkudkoli v aplikaci. Lze je přímo volat pomocí objektu třídy.
#include <iostream>
class Pet {
public:
void speak() {
std::cout << "Pet is speaking" << std::endl;
}
};
int main() {
Pet dog;
dog.speak(); // Funguje bez problémů
}
Soukromý přístupový modifikátor (private)
Členové třídy deklarovaní jako private jsou přístupní pouze uvnitř samotné třídy nebo prostřednictvím přátelských funkcí/tříd. Není možné je přímo přistupovat z vnějšku třídy.
#include <iostream>
#include <string>
class Pet {
private:
std::string name;
public:
void setName(std::string petName) {
name = petName;
}
};
auto main() -> int {
Pet cat;
// cat.name = "Whiskers"; // ❌ Chyba kompilace: 'name' je soukromý
cat.setName("Whiskers"); // ✅ Funguje správně
}
Tím, že je name soukromý, zajistíme, že nemůže být libovolně měněn zvenčí.
Chráněný přístupový modifikátor (protected)
Členové protected se chovají podobně jako private, ale s jedním zásadním rozdílem: jsou přístupní v odvozených třídách (dědičnost). To je užitečné při tvorbě hierarchií tříd.
class Animal {
protected:
int age;
};
class Dog : public Animal {
public:
void setAge(int a) {
age = a; // ✅ Povolené: Přístupné v odvozené třídě
}
};
Zde je age chráněný, takže není přístupný zvenčí, ale je dostupný uvnitř třídy Dog, která dědí Animal.
2. Použití přístupových modifikátorů v třídě
Chcete-li v třídě definovat přístupové modifikátory, uveďte modifikátor následovaný dvojtečkou (:). Všechny členy deklarované po modifikátoru budou mít tento přístup, dokud není použit jiný modifikátor.
#include <iostream>
#include <string>
class Player {
private:
std::string name;
int health;
int xp;
public:
void talk(std::string text_to_say) {
std::cout << "Player říká: " << text_to_say << std::endl;
}
};
3. Porozumění chybám kompilace
Pokus o přístup k soukromým členům zvenčí třídy vyvolá chybu kompilace. Podívejme se na příklad:
#include <iostream>
#include <string>
class Player {
private:
std::string name;
int health;
int xp;
public:
void attack() {
std::cout << "Útočí" << std::endl;
}
};
auto main() -> int {
Player* barbarian = new Player();
// barbarian->name = "John"; // ❌ Chyba: 'name' je soukromý
barbarian->attack(); // ✅ Funguje správně
delete barbarian;
}
Zde pokus o přímou změnu barbarian->name způsobí chybu kompilace, protože name je soukromý. Nicméně volání metody attack() funguje správně, protože je veřejná.
4. Proč používat přístupové modifikátory?
Zapouzdření je klíčovým principem objektově orientovaného programování (OOP). Omezením přístupu k některým členům třídy dosáhneme následujících výhod:
✔️ Zabráníme neúmyslným změnám dat
✔️ Zajistíme kontrolovaný přístup přes metody třídy
✔️ Zlepšíme údržbu kódu centralizací logiky v metodách
✔️ Usnadníme ladění kódu, protože všechny změny probíhají přes definovaná rozhraní
Například v bankovní aplikaci by bylo špatné, pokud by bylo možné přímo měnit zůstatek účtu. Místo toho používáme kontrolované metody, které zajistí správné ověření a zabezpečení:
#include <iostream>
class Account {
private:
double balance;
public:
void deposit(double amount) {
if (amount > 0) {
balance += amount;
}
}
};
Zde je přímý přístup k balance zakázán, což zajišťuje, že vklady se provádějí pouze prostřednictvím metody deposit(), která zahrnuje ověření.