Będziemy mieli 2 klasy: Osoba, dla której zapamiętamy dane takie

Osoba
Student
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
{
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()
:
//Konstruktory dla Studenta
{ }
kierunek_studiow("")
Student::Student(string
kierunek_studiow(kierunek_studiow)
{ }
Student::Student(
kierunek_studiow):
(o.getNazwisko()),
(kierunek_studiow)
{ }
kierunek_studiow):
const
Osoba
&
o,
string
im(
o.getImie()
),
nazw
wi(o.getWiek()),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
void
void
void
wyswietl_menu();
czysc_bufor();
opisz_osobe();
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
zakonczyc: ";
}
(q)uit
/*******************************************/
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");
aby
string imie, nazwisko;
int wiek;
string kierunek_studiow;
cout << "kierunek studiow" << endl;
cout
<<
"Podaj
kierunek
";
kierunek_studiow;
cin
>>
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);
Metody ze specyfikacją const nie mogą modyfikować pól
obiektu, mogą zatem być wywoływane dla obiektów
stałych
string getImie() const;
string getNazwisko() const;
int getWiek() const;