Będziemy mieli 2 klasy:
Osoba, dla której zapamiętamy dane takie jak: imie, nazwisko i wiek
Oraz klasę Student, w której będziemy też dodatkowo pamiętać kierunek studiów.
Deklaracja klasy Osoba:
Class Osoba {
public:
Osoba();
Osoba( string i, string n, int w );
Osoba( Osoba & innaOsoba );
void wypiszDaneOsobowe();
void setImie( string i );
void setNazwisko( string n );
void setWiek( int w );
// Akcesory
string getImie() const;
string getNazwisko() const;
int getWiek() const;
private:
string i; string n;int w;
};
Deklaracja klasy Student:
class Student
Osoba Student
{
public:
Student();
Student( string kierunek_studiow );
Student( const Osoba & o, string kierunek_studiow);
void wypiszDaneOsobowe();
// Modyfikatory
void setImie( string im );
void setNazwisko( string nazw );
void setWiek( int wi );
// Akcesory
string getImie() const;
string getNazwisko() const;
int getWiek() const;
// Realizator
private:
string im, nazw;
int wi;
string kierunek_studiow;
};
Stosując zasadę hermetyzacji ukrywamy dane w części prywatnej i zapewniamy dostęp poprzez metody dostępowe (interfejsowe).
Funkcje publiczne klasy można nieformalnie podzielić na;
akcesory — funkcje umożliwiające pobieranie wartości pol, akcesorem jest np. metoda getImie .
modyfikatory — funkcje dokonujące modyfikacji wartości
pol, modyfikatorem jest np. metoda setImie .
realizatory — funkcje realizujące właściwe dla danej klasy usługi, realizatorem jest np. metoda wypiszDaneOsobowe.
Obiekt klasy Osoba od strony programisty-użytkownika
Osoba o1;
Deklaracja obiektu o1 klasy Osoba:
O1.setImie(„Agnieszka” );
Ustalenie imienia jako „Agnieszka”
Sekcje private i public
Dwie podstawowe sekcje:
private — elementy zadeklarowane w tej sekcji mogą być wykorzystywane wyłącznie przez funkcje składowe danej klasy. Elementami tymi mogą być zarówno pola i funkcje.
Mowi się o nich, że są prywatne.
public — elementy zadeklarowane w tej sekcji są dostępne rownież dla innych elementow programu. Mowi się o nich, że są publiczne lub stanowią interfejs klasy.
Definicja funkcji składowych
–
Osoba::Osoba() : i("Stefek"),n("Burczymucha"), w(100) //Konstruktory dlaOsoby
{ }
Osoba::Osoba(string i, string n, int w) : w(w), i(i), n(n)
{ }
Osoba::Osoba( Osoba & innaOsoba ) : i (innaOsoba.i), n(innaOsoba.n), w(innaOsoba.w)
{ }
void Osoba::wypiszDaneOsobowe() {
cout << "\nImie osoby " << Osoba::getImie() <<
"\nnazwisko " << Osoba::getNazwisko() << endl;
cout << "\nOsoba ma lat "<< Osoba::getWiek() <<
endl;
}
void Osoba::setImie( string im ) { Osoba::i = im; }
void Osoba::setNazwisko( string nazw ) { Osoba::n = nazw; }
// Akcesory
string Osoba::getImie() const { return i; }
string Osoba::getNazwisko() const { return n; }
void Osoba::setWiek( int w ) { Osoba::w = w; }
int Osoba::getWiek() const { return w; }
Teraz to samo dla klasy Student:
Student::Student() : kierunek_studiow("") //Konstruktory dla Studenta
{ }
Student::Student(string kierunek_studiow):
kierunek_studiow(kierunek_studiow) { }
Student::Student( const Osoba & o, string kierunek_studiow): im( o.getImie() ), nazw (o.getNazwisko()), wi(o.getWiek()),kierunek_studiow (kierunek_studiow)
{ }
void Student::setImie( string im ) { Student::im = im; }
void Student::setNazwisko( string nazw ) { Student::nazw = nazw; }
void Student::setWiek( int w ) { Student::wi = w; }
// Akcesory
string Student::getImie() const { return im; }
string Student::getNazwisko() const { return nazw; }
int Student::getWiek() const { return wi; }
void Student::wypiszDaneOsobowe() {
cout << "\nkierunek studiow " << kierunek_studiow
<< endl;
}
A teraz ciało funkcji main a więc główny program…
void wyswietl_menu();
void czysc_bufor();
void opisz_osobe();
void opisz_Studenta();
int main() {
char klawisz;
//Osoba o1;
do {
wyswietl_menu();
cin >> klawisz;
switch( klawisz ) {
case '1' : opisz_osobe();
break;
case '2' : opisz_Studenta();
break;
default : if( klawisz != 'q' ) cout<< '\a';
break;
} }
while ( klawisz != 'q' );
return EXIT_SUCCESS;
}
/*******************************************/
//Funkcja wyswietl menu void wyswietl_menu() {
system("cls");
cout << "Opisy..." << endl;
cout << endl;
cout << "1. osoba \n2. student";
cout << "\n\nWybierz numer lub (q)uit aby zakonczyc: ";
}
/*******************************************/
void opisz_osobe() {
system("cls");
string imie, nazwisko;
int wiek;
cout << "Opisy dla osoby" << endl;
cout << "Podaj imie: "; cin >> imie;
cout << "Podaj nazwisko: "; cin >> nazwisko;
cout << "Podaj wiek: "; cin >> wiek;
Osoba o1;
o1.setImie(imie);
o1.setNazwisko(nazwisko);
o1.setWiek(wiek);
o1.wypiszDaneOsobowe();
system("PAUSE");
}
/*******************************************/
void opisz_Studenta() {
system("cls");
string imie, nazwisko;
int wiek;
string kierunek_studiow;
cout << "kierunek studiow" << endl;
cout << "Podaj kierunek "; cin >>
kierunek_studiow;
Osoba o2;
Student s1(o2,kierunek_studiow);
o2.wypiszDaneOsobowe();
s1.wypiszDaneOsobowe();
system("PAUSE");
}
/*******************************************/
Jak zainicjować obiekt na etapie jego definiowania?
Konstruktor jest specjalną funkcją, aktywowaną przez kompilator automatycznie w momencie gdy obiekt jest tworzony. Dzieje się tak zanim programista będzie mogł
„dorwać” obiekt. Konstruktor ma przygotować obiekt do
„życia”.
Konstruktor to specyficzna funkcja. Konstruktor nie ma typu rezultatu, nosi taką nazwę jak nazwa klasy i zwykle nie wywołuje się go jawnie w kodzie programu.
Rodzaje konstruktorów
Występują cztery rodzaje konstruktorów:
Konstruktor domyślny (ang. default constructor) aktywowany, gdy tworzony jest obiekt bez jawnie określonych danych inicjalizujących.
Konstruktor ogólny (ang. general constructor), zwany też
parametrowym, aktywowany gdy tworzymy obiekt z
jawnie określonymi danymi inicjalizującymi.
Konstruktor kopiujący (ang. copy constructor) aktywowany wtedy, gdy tworzymy obiekt, inicjalizując go danymi z innego obiektu tej samej klasy. Operator & oznacza referencję, umieszczony w deklaracji parametru oznacza przekazanie przez zmienną.
Konstruktor rzutujący (ang. cast constructor) aktywowany wtedy, gdy tworzymy obiekt, inicjalizując go danymi z obiektu innej klasy.
Przykład konstruktora domyślnego:
Osoba o1;
Przykład konstruktora ogólnego:
Osoba o0 ("Ala","Nowak", 33);
Przykład konstruktora kopiującego:
Osoba o2;
Osoba o3(o2);
Przykład konstruktora rzutującego:
Osoba o2;
Student s1(o2,kierunek_studiow);
