Klasy

Ten artykuł został zbudowany od nowa przez : komputer098

Klasa to inaczej mówiąc typ. Ogólna konstrukcja klasy wygląda następująco:

class nasz_typ
{
 // składniki klasy -----
} ;

Definicja klasy składa się ze słowa kluczowego class, nazwy klasy i bloku z ciałem klasy. Ważny jest też średnik po klamrze zamykającej blok klasy.

Aby stworzyć egzemplarz klasy, należy podać nazwę jej typu i nazwę tego konkretnego obiektu:

nasz_typ abc ;

Dzięki temu w pamięci maszyny zostaje utworzony jeden obiekt klasy nasz_typ z nazwą abc. Przy tworzeniu drugiego obiektu, analogicznie tworzone są nowe zestawy danych. Do własnego typu można odwołać się poprzez wskaźnik:

nasz_typ *wsk ;

Lub przez referencję(przezwisko):

nasz_typ &przezwisko = obiekt ;

Składniki klasy

Składnikami klasy może być dowolny typ lub funkcja. Na przykład:

class zmywarka
{
public:
 int nr_programu ;
 float temp_wody ;
 char nazwa[80] ;
} ;

Aby odnieść się do składników obiektu możemy posłużyć się jedną z poniższych notacji:

• obiekt.składnik
• wskaźnik -> składnik
• referencja.składnik

Tak więc:

zmywarka czarna ; // definicja egzemplarza obiektu
zmywarka *wskaz ; // definicja wskaźnika
zmywarka &ciemna = czarna ; // definicja referencji

Składnikami klasy mogą też być funkcje. Nazywają się funkcjami składowymi. Oto rozbudowana klasa zmywarka o kilka funkcji:

class zmywarka
{
public:
 int nr_programu ;
 float temp_wody ;
 char nazwa[80] ;

 bool plukaj( nr_programu, temp_wody ) ;
 bool susz( nr_programu ) ;
} ;

WAŻNE: niezależnie od tego, w jakim miejscu umieścisz deklaracje składników klasy, znane są one w całej klasie!. Do klas nawiązuje także enkapsulacja, czyli formowanie danych w określoną grupę.

Etykiety public, private, protected

Tworząc nową klasę możemy decydować, co ma udostępniać, a co nie. Przykład:

class zmywarka
{
public:
 int nr_programu ;
 float temp_wody ;
 char nazwa[80] ;

 bool plukaj( nr_programu, temp_wody ) ;
 bool susz( nr_programu ) ;
private:
 int cisnienie_wody ;
 int obciazenie ;

 bool zwolnijzawory( nr_programu ) ; 
} ;

Oto rodzaje dostępu do składników klasy:

*public - jest dostępny bez ograniczeń.
*private - jest dostępny tylko dla funkcji składowych danej klasy i funkcji zaprzyjaźnionych tej klasy.
*protected - jest dostępny tak, jak składnik private, ale jest jeszcze dodatkowo dostępny dla klas wywodzących się od tej klasy.
Etykiety te można umieszczać w dowolnej kolejności, mogą też się powtarzać.
Domniemanie - zakłada się, że dopóki nie wystąpi żadna z powyższych etykiet, to składniki mają dostęp private.

Zapamiętaj to!

*Definicja klasy nie definiuje żadnych obiektów! Jest to jakby pieczątka - wiadomo do czego służy, ale nie została odbita na papierze(zapisana w pamięci).
*Klasa to typ obiektu, a nie sam obiekt.
*W składnikach klasy nie może występować inicjalizator, czyli:

class paszport
{
 char nazwisko[40] ;
 char imie[40] ;
 int numer ;
 int wzrost = 176 ;  // BŁĄD!!!
} ;

Gdyby tak wyglądała definicja klasy paszport, to wszystkie paszporty miały by na zawsze wydrukowany wzrost właściciela równy 176cm.
*Każda definicja obiektu klasy tworzy nowe komplety obiektów, ale funkcje są tylko w jednym egzemplarzu.
*Aby odwołać się do funkcji operującej na danym obiekcie należy wywołać ją przez ten obiekt:

obiekt.funkcja( argumenty ) ;

Funkcje takie można wywoływać także przez wskaźniki i referencje:

osoba *wsk ;
wsk = &profesor ;

wsk -> wykladaj( "sala nr 4", 30 ) ;
// ----------
osoba belfer = profesor ;

belfer.wykladaj( "sala nr 1", 45 ) ;

Aby zdefiniować funkcję w klasie, trzeba to zrobić w jeden z poniższych sposobów:

// pierwszy sposób - funkcje zdefiniowane w ten sposób będą automatycznie typu inline
class osoba
{
 // pamiętaj, to są składniki private --------
 char nazwisko[80] ;
 int wiek ;
public:
 // definicje funkcji składowych --------
 void zapamietaj( char *napis, int lata ) ;
 {
   strcpy( nazwisko, napis ) ;
   wiek = lata ;
 }
 void wypisz( void )
 {
   cout << nazwisko << " , lat : " << wiek << endl ;
 }
} ;

// drugi sposób, zalecany dla funkcji mających więcej niż 5-10 linii kodu ---------
class osoba
{
 // pamiętaj, to są składniki private --------
 char nazwisko[80] ;
 int wiek ;
public:
 // definicje funkcji składowych --------
 void zapamietaj( char *napis, int lata ) 
 void wypisz( void ) ;
} ;
// ------
void osoba::zapamietaj( char*napis, int lata ) 
{
 strcpy( nazwisko, napis ) ;
 wiek = lata ;
}

inline void osoba::wypisz( void )   //wpisywanie w nawias void nie jest konieczne,
// aby ta funkcja była typu inline, trzeba to wyraźnie zaznaczyć
{
 cout << nazwisko << " , lat : " << wiek << endl ;
}

Po więcej szczegółów zapraszam do działów poniżej.

Zobacz też:

• Class
• Konstruktory
• Destruktory
• Dziedziczenie
• Public
• Funkcje