Jezyk Cpp, informatyka
[ Pobierz całość w formacie PDF ]
Jerzy Kisilewicz
Język
C
++
Programowanie obiektowe
Wydanie III
Oficyna Wydawnicza Politechniki Wrocławskiej
Wrocław 2005
Opiniodawca
Marian ADAMSKI
Opracowanie redakcyjne
Hanna BASAROWA
Projekt okładki
Dariusz GODLEWSKI
© Copyright by Jerzy Kisilewicz, Wrocław 2002
OFICYNA WYDAWNICZA POLITECHNIKI WROCŁAWSKIEJ
Wybrzeże Wyspiańskiego 27, 50-370 Wrocław
ISBN 83-7085-891-0
Drukarnia Oficyny Wydawniczej Politechniki Wrocławskiej. Zam. nr 582/2002.
Spis treści
1. Wprowadzenie................................................................................................................
5
1.1. Rozszerzenia C++ ...................................................................................................
5
1.1.1. Prototypy funkcji ...........................................................................................
6
1.1.2. Instrukcje deklaracyjne..................................................................................
6
1.1.3. Wyrażenia strukturowe..................................................................................
7
1.1.4. Obiektowe operacje wejścia i wyjścia ...........................................................
7
1.1.5. Pojęcie klasy ..................................................................................................
7
1.1.6. Zmienne ustalone...........................................................................................
9
1.1.7. Operator zakresu............................................................................................
9
1.1.8. Zmienne referencyjne ....................................................................................
10
1.1.9. Funkcje przeciążone ......................................................................................
12
1.1.10. Argumenty domniemane .............................................................................
12
1.1.11. Funkcje otwarte ...........................................................................................
13
1.1.12. Operatory
new
i
delete
.................................................................................
13
1.2. Przykładowy program ZESP ...................................................................................
15
1.2.1. Program w języku C ......................................................................................
15
1.2.2. Program proceduralny w języku C+ + ...........................................................
16
1.2.3. Program obiektowy........................................................................................
17
1.2.4. Program z oprogramowaną klasą...................................................................
18
1.3. Tworzenie bibliotek. Program TLIB .......................................................................
20
1.4. Budowanie klas .......................................................................................................
22
1.4.1. Hermetyzacja danych i metod .......................................................................
22
1.4.2. Pola i funkcje statyczne .................................................................................
23
1.4.3. Wzorce klas i funkcji .....................................................................................
25
1.5. Obiektowe wejście i wyjście ...................................................................................
28
1.5.1. Obiekty strumieniowe....................................................................................
28
1.5.2. Wprowadzanie i wyprowadzanie...................................................................
30
1.5.3. Formatowanie wejścia i wyjścia ....................................................................
32
1.5.4. Strumienie plikowe........................................................................................
35
1.5.5. Strumienie pamięciowe .................................................................................
38
4
1.5.6. Strumienie ekranowe .....................................................................................
39
1.6. Podejście obiektowe ................................................................................................
42
1.6.1. Hermetyzacja danych i metod .......................................................................
43
1.6.2. Dziedziczenie ................................................................................................
44
1.6.3. Przeciążanie funkcji i operatorów .................................................................
45
1.6.4. Polimorfizm...................................................................................................
46
2. Konstruktory i destruktory .............................................................................................
49
2.1. Konstruktor bezparametrowy ..................................................................................
50
2.2. Konstruktor kopiujący.............................................................................................
51
2.3. Konwersja konstruktorowa......................................................................................
52
2.4. Konstruktory wieloargumentowe ............................................................................
54
2.5. Destruktor................................................................................................................
56
2.6. Przykład klasy TEXT ..............................................................................................
57
3. Funkcje składowe i zaprzyjaźnione ................................................................................
63
3.1. Właściwości funkcji składowych ............................................................................
63
3.2. Funkcje zaprzyjaźnione...........................................................................................
66
3.3. Funkcje operatorowe ...............................................................................................
68
3.4. Operatory specjalne.................................................................................................
76
3.5. Konwertery..............................................................................................................
82
4. Dziedziczenie ................................................................................................................. 84
4.1. Klasy bazowe i pochodne........................................................................................ 84
4.2. Dziedziczenie sekwencyjne..................................................................................... 89
4.3. Dziedziczenie wielobazowe .................................................................................... 92
4.4. Funkcje polimorficzne............................................................................................. 98
4.5. Czyste funkcje wirtualne ......................................................................................... 101
5. Bibliografia..................................................................................................................... 127
4
1. Wprowadzenie
Książka jest przeznaczona dla osób znających standard języka C i programujących
proceduralnie (nieobiektowo) wtym języku. Opisano te elementy języka
obiektowego, które zostały zaimplementowane wwersji3.1 kompilatora Bor-
land C+ + . Zamieszczone przykłady zostały sprawdzone za pomocą tego właśnie
kompilatora.
W trosce o niewielką objętość książki pominięto takie zagadnienia, jak: obsługa
wyjątków (szczególnie przydatna do obsługi błędów), wykorzystanie klas kontene-
rowych, programowanie z użyciem pakietu Turbo Vision oraz tworzenie aplikacji
windowsowych z użyciem Object Windows Library (OWL). Obsługę wyjątków oraz
wykorzystanie klas kontenerowych szeroko opisano w książkach [12,13, 25]. Pakiet
programowy OWL opisano w [1, 25, 28], natomiast proste przykłady użycia Turbo
Vision w C++ zamieszczono w [21].
1.1. Rozszerzenia C++
W porównaniu ze standardem języka C, w języku C+ + wprowadzono wiele
zmian i rozszerzeń, takich jak: prototypy funkcji, operator zakresu, pojęcie klasy,
wyrażenia strukturowe, instrukcje deklaracyjne, zmienne ustalone, zmienne referen-
cyjne, funkcje przeciążone, argumenty domniemane, funkcje otwarte, operatory
new
i
delete
, obiektowe operacje wejścia i wyjścia.
W języku C literały (np. 'A' lub '\n') są stałymi typu
int
, natomiast w języku C++
są one stałymi typu
char
. Tak więc literały znaków o kodach większych od 127 mają
wartości ujemne.
W języku C brak listy argumentów w nagłówku funkcji (np.
int main
( ) ) oznacza
funkcję z nieokreśloną listą argumentów. Funkcję bezargumentową definiuje się
z argumentem typu
void
(np
int getch
(
void
)). W języku C++ brak listy argumentów,
tak samo jak argument typu
void
oznacza funkcję bezargumentową.
[ Pobierz całość w formacie PDF ]