Rozdział 2.
Anatomia programu C++
Programy C++ składają się z obiektów, funkcji, zmiennych i innych elementów składowych[Author ID1: at Tue Nov 13 10:15:00 2001
]. Większość tej książki jest poświęcona dogłębnemu [Author ID1: at Tue Nov 13 10:15:00 2001
]stanowi obszerny [Author ID1: at Tue Nov 13 10:15:00 2001
]opisowi[Author ID1: at Tue Nov 13 10:15:00 2001
] tych elementów, ale by[Author ID1: at Tue Nov 13 10:16:00 2001
]jednakże w celu[Author ID1: at Tue Nov 13 10:16:00 2001
] zrozumieć[Author ID1: at Tue Nov 13 10:16:00 2001
]nia[Author ID1: at Tue Nov 13 10:16:00 2001
] zasad ich współdziałania, [Author ID1: at Tue Nov 13 10:16:00 2001
]jak one do siebie pasują, [Author ID1: at Tue Nov 13 10:16:00 2001
]musisz najpierw poznać pełny [Author ID1: at Tue Nov 13 10:16:00 2001
]cały [Author ID1: at Tue Nov 13 10:16:00 2001
]działający program.
W tym rozdziale:
D[Author ID1: at Tue Nov 13 10:17:00 2001
]d[Author ID1: at Tue Nov 13 10:17:00 2001
]owiesz się,[Author ID1: at Tue Nov 13 10:17:00 2001
] czym jest funkcja i do czego służy.
Prosty program
Nawet prosty program HELLO.cpp z rozdziału pierwszego, „Zaczynamy”, miał wiele interesujących elementów. W tym podrozdziale omówimy go bardziej szczegółowo. Listing 2.1 zawiera [Author ID1: at Tue Nov 13 10:17:00 2001
]przypomn[Author ID1: at Tue Nov 13 10:17:00 2001
]ienie[Author ID1: at Tue Nov 13 10:17:00 2001
]na[Author ID1: at Tue Nov 13 10:17:00 2001
] treści[Author ID1: at Tue Nov 13 10:17:00 2001
]ć[Author ID1: at Tue Nov 13 10:17:00 2001
] programu HELLO.cpp z poprzedniego rozdziału.
Listing 2.1. HELLO.cpp demonstruje elementy programu C++.[Author ID1: at Tue Nov 13 10:17:00 2001
]
0: #include <iostream>
1:
2: int main()
3: {
4: std::cout << "Witaj Swiecie!\n";
5: return 0;
6: }
Wynik działania:[Author ID1: at Tue Nov 13 10:17:00 2001
]
Witaj Swiecie!
Analiza:
W linii 0.[Author ID1: at Tue Nov 13 10:18:00 2001 ] do bieżącego pliku jest dołączany plik iostream.
Oto jak to[Author ID1: at Tue Nov 13 10:18:00 2001
]sposób jego[Author ID1: at Tue Nov 13 10:18:00 2001
] działania[Author ID1: at Tue Nov 13 10:19:00 2001
]: pierwszy znak jest symbolem #, który stanowi sygnał dla preprocesora. Za każdym razem gdy uruchamiasz kompilację, uruchamiany jest preprocesor. Preprocesor odczytuje kod źródłowy, wyszukując linii zaczynających się od znaku # (hasz) i operuje na nich jeszcze przed uruchomieniem właściwego kompilatora. Preprocesor zostanie szczegółowo omówiony [Author ID1: at Tue Nov 13 10:19:00 2001
]opisany [Author ID1: at Tue Nov 13 10:19:00 2001
]w rozdziale 21., „Co dalej.”
Polecenie #include jest instrukcją preprocesora,[Author ID1: at Tue Nov 13 10:19:00 2001
] mówiącą mu: „Po mnie następuje nazwa pliku. Znajdź ten plik i wstaw go w to miejsce.” Nawiasy kątowe dookoła nazwy pliku informują preprocesor,[Author ID1: at Tue Nov 13 10:19:00 2001
] by szukał pliku w standardowych miejscach dla tego typu plików. Jeśli twój kompilator jest odpowiednio skonfigurowany, nawiasy kątowe powodują,[Author ID1: at Tue Nov 13 10:19:00 2001
] że preprocesor szuka pliku iostream w kartotece zawierającej wszystkie pliki nagłówkowe dostarczane wraz z kompilatorem. Plik iostream (Input Output Stream — strumień wejścia-wyjścia) jest używany przez obiekt cout, asystujący przy wypisywaniu tekstu na ekranie. Efektem działania [Author ID1: at Tue Nov 13 10:19:00 2001
]linii 0.[Author ID1: at Tue Nov 13 10:19:00 2001
] jest wstawienie zawartości pliku iostream w [Author ID1: at Tue Nov 13 10:20:00 2001
]do [Author ID1: at Tue Nov 13 10:20:00 2001
]kodu[Author ID1: at Tue Nov 13 10:20:00 2001
] programu, tak jakby został on wpisany przez ciebie. Preprocesor działa przed każdym rozpoczęciem kompilacji, poprzedzając jej właściwą fazę. Preprocesor tłumaczy[Author ID1: at Tue Nov 13 10:20:00 2001
]Ponadto zamienia[Author ID1: at Tue Nov 13 10:20:00 2001
] wszystkie linie rozpoczynające się od znaku hasz (#) na specjalne polecenia, przygotowując ostateczny kod źródłowy dla kompilatora.
Linia 2.[Author ID1: at Tue Nov 13 10:20:00 2001
] rozpoczyna rzeczywisty program od funkcji o nazwie main(). Funkcję tę posiada każdy program C++. Funkcja jest blokiem kodu wykonującym jedną lub więcej operacji. Zwykle funkcje są wywoływane przez inne funkcje, lecz funkcja main() jest [Author ID1: at Tue Nov 13 10:20:00 2001
]pod tym względem specjalna[Author ID1: at Tue Nov 13 10:20:00 2001
]odbiega od standardu[Author ID1: at Tue Nov 13 10:20:00 2001
]. Gdy program rozpoczyna działanie, funkcja [Author ID1: at Tue Nov 13 10:21:00 2001
]main()[Author ID1: at Tue Nov 13 10:21:00 2001
] [Author ID1: at Tue Nov 13 10:21:00 2001
]jest ona [Author ID1: at Tue Nov 13 10:21:00 2001
]wywoływana automatycznie.
Funkcja main (), podobnie jak inne funkcje, musi określić rodzaj zwracanej przez siebie wartości. Typem zwracanej przez nią w programie [Author ID1: at Tue Nov 13 10:21:00 2001
]HELLO.cpp[Author ID1: at Tue Nov 13 10:21:00 2001
] [Author ID1: at Tue Nov 13 10:21:00 2001
]wartości zwracanej przez funkcję [Author ID1: at Tue Nov 13 10:21:00 2001
]main()[Author ID1: at Tue Nov 13 10:21:00 2001
] w programie [Author ID1: at Tue Nov 13 10:21:00 2001
]HELLO.cpp[Author ID1: at Tue Nov 13 10:21:00 2001
] [Author ID1: at Tue Nov 13 10:21:00 2001
]jest typ int, c[Author ID1: at Tue Nov 13 10:21:00 2001
]t[Author ID1: at Tue Nov 13 10:21:00 2001
]o oznacza że po zakończeniu działania ta [Author ID1: at Tue Nov 13 10:22:00 2001
]funkcja ta [Author ID1: at Tue Nov 13 10:22:00 2001
]zwraca systemowi operacyjnemu wartość całkowitą (ang. integer). W tym przypadku zwracaną wartością jest 0, tak jak to widzimy w linii 5. Zwrócenie wartości systemowi operacyjnemu jest stosunkowo mało ważną i rzadko wykorzystywaną możliwością, ale standard C++ wymaga,[Author ID1: at Tue Nov 13 10:22:00 2001
] by funkcja main() była [Author ID1: at Tue Nov 13 10:22:00 2001
]została [Author ID1: at Tue Nov 13 10:22:00 2001
]zadeklarowana tak jak pokazano.
UWAGA Niektóre kompilatory pozwalają na deklarację main() [Author ID1: at Tue Nov 13 10:22:00 2001
], [Author ID1: at Tue Nov 13 10:22:00 2001
]jeśli funkcja main ma zwracać typ void. Nie jest to zgodne ze standardem C++ i nie powinieneś się do tego przyzwyczajać. Niech funkcja main() zwraca wartość typu int, zaś w ostatniej linii tej funkcji po prostu zwracaj wartość 0.
UWAGA Niektóre systemy operacyjne umożliwiają sprawdzanie (testowanie),[Author ID1: at Tue Nov 13 10:22:00 2001
] jaka wartość została zwrócona przez program. Zgodnie z konwencją, zwrócenie wartości 0 oznacza, że program normalnie [Author ID1: at Tue Nov 13 10:22:00 2001
]zakończył działanie normalnie[Author ID1: at Tue Nov 13 10:22:00 2001
].
Wszystkie funkcje rozpoczynają się od nawiasu otwierającego ({) i kończą nawiasem zamykającym (}). Nawiasy dla funkcji main() znajdują się w liniach 3.[Author ID1: at Tue Nov 13 10:23:00 2001 ] i 6. Wszystko, co znajduje się[Author ID1: at Tue Nov 13 10:23:00 2001 ] pomiędzy nawiasem otwierającym a zamykającym,[Author ID1: at Tue Nov 13 10:23:00 2001 ] jest uważane za treść funkcji.
Prawdziwa zawartość [Author ID1: at Tue Nov 13 10:23:00 2001
]treść [Author ID1: at Tue Nov 13 10:23:00 2001
]programu znajduje się w linii 4. Obiekt cout jest używany do wypisywania komunikatów na ekranie. Obiektami zajmiemy się ogólnie [Author ID1: at Tue Nov 13 10:24:00 2001
]w rozdziale 6., „Programowanie zorientowane obiektowo”, zaś obiekt cout i powiązany z nim obiekt cin omówimy szczegółowo w rozdziale 17., „Strumienie.” Te dwa obiekty, cin i cout, są w C++ używane, odpowiednio,[Author ID1: at Tue Nov 13 10:24:00 2001
]:[Author ID1: at Tue Nov 13 10:24:00 2001
] do obsługi wejścia (na przykład z klawiatury) oraz wyjścia (na przykład na ekran).
Obiekt cout jest dostarczany przez bibliotekę [Author ID1: at Tue Nov 13 10:24:00 2001
]standardową bibliotekę[Author ID1: at Tue Nov 13 10:24:00 2001
]. Biblioteka jest kolekcją klas. Standardowa biblioteka jest standardową kolekcją dostarczaną wraz [Author ID1: at Tue Nov 13 10:24:00 2001
]z każdym kompilatorem zgodnym z ANSI.
Używając specyfikatora przestrzeni nazw, std, informujemy kompilator,[Author ID1: at Tue Nov 13 10:24:00 2001
] że obiekt cout jest częścią biblioteki standardowej. Ponieważ możesz mieć kilka, pochodzących od różnych dostawców, obiektów o tych samych nazwach, C++ dzieli „świat” na „przestrzenie nazw.[Author ID1: at Tue Nov 13 10:24:00 2001
]”. [Author ID1: at Tue Nov 13 10:24:00 2001
] [Author ID1: at Tue Nov 13 10:24:00 2001
]Przestrzeń nazw jest sposobem na powiedzenie,[Author ID1: at Tue Nov 13 10:25:00 2001
] że: „gdy mówię cout, mam na myśli to, że cout jest częścią standardowej przestrzeni nazw, a nie jakiejś innej przestrzeni nazw.” Mówimy to kompilatorowi poprzez umieszczenie przed nazwą cout znaków sdt i podwójnego dwukropka. Więcej na temat różnych przestrzeni nazw powiemy sobie [Author ID1: at Tue Nov 13 10:25:00 2001
]w następnych rozdziałach.
Oto jak [Author ID1: at Tue Nov 13 10:25:00 2001
]sposób [Author ID1: at Tue Nov 13 10:25:00 2001
]używany[Author ID1: at Tue Nov 13 10:25:00 2001
]cia[Author ID1: at Tue Nov 13 10:25:00 2001
] jest [Author ID1: at Tue Nov 13 10:25:00 2001
]obiektu[Author ID1: at Tue Nov 13 10:25:00 2001
] cout: wpisz słowo cout, a po nim operator przekierowania wyjścia (<<). To, co następuje po operatorze przekierowania wyjścia, zostanie wypisane na ekranie. Jeśli chcesz,[Author ID1: at Tue Nov 13 10:25:00 2001
] by został wypisany łańcuch znaków, pamiętaj o ujęciu go w cudzysłowy,[Author ID1: at Tue Nov 13 10:25:00 2001
] ([Author ID1: at Tue Nov 13 10:25:00 2001
] [Author ID1: at Tue Nov 13 10:25:00 2001
]tak jak widzimy w linii 4.)[Author ID1: at Tue Nov 13 10:25:00 2001
]
Łańcuch tekstowy jest serią znaków [Author ID1: at Tue Nov 13 10:26:00 2001
]drukowalnych znaków[Author ID1: at Tue Nov 13 10:25:00 2001
].
Dwa ostatnie znaki, \n, informują obiekt cout [Author ID1: at Tue Nov 13 10:26:00 2001
], [Author ID1: at Tue Nov 13 10:26:00 2001
]by po słowach „[Author ID1: at Tue Nov 13 10:26:00 2001
]Witaj Świecie!”[Author ID1: at Tue Nov 13 10:26:00 2001
] umieścił nową linię. Ten specjalny kod zostanie wyjaśniony [Author ID1: at Tue Nov 13 10:26:00 2001
]opisany [Author ID1: at Tue Nov 13 10:26:00 2001
]szczegółowo podczas omawiania obiektu cout w rozdziale 18., „Przestrzenie nazw.”
Funkcja main() kończy się w linii 6.[Author ID1: at Tue Nov 13 10:26:00 2001 ] nawiasem zamykającym.
Rzut oka na klasę cout
W rozdziale 17. zobaczysz,[Author ID1: at Tue Nov 13 10:26:00 2001
] w jaki sposób używa się obiektu cout do wypisywania danych na ekranie. Na razie możesz z niego korzystać,[Author ID1: at Tue Nov 13 10:27:00 2001
] nie wiedząc właściwie[Author ID1: at Tue Nov 13 10:27:00 2001
],[Author ID1: at Tue Nov 13 10:27:00 2001
] jak działa. Aby wypisać wartość na ekranie, napisz słowo cout, po nim operator wstawiania (<<), uzyskiwany w wyniku dwukrotnego wpisania znaku mniejszości (<). Choć w rzeczywistości są to dwa znaki, C++ traktuje je jako pojedynczy symbol.
Po znaku wstawiania wpisz dane [Author ID1: at Tue Nov 13 10:27:00 2001
]przeznaczone do wypisania dane[Author ID1: at Tue Nov 13 10:27:00 2001
]. Listing 2.2 ilustruje sposób użycia tego obiektu. Wpisz w tym przykładzie dokładnie to,[Author ID1: at Tue Nov 13 10:28:00 2001
] co pokazano[Author ID1: at Tue Nov 13 10:28:00 2001
] na listingu, z wyjątkiem tego[Author ID1: at Tue Nov 13 10:28:00 2001
]tym[Author ID1: at Tue Nov 13 10:28:00 2001
], że zamiast nazwiska Jesse Liberty wpisz swoje własne (chyba,[Author ID1: at Tue Nov 13 10:28:00 2001
] że rzeczywiście nazywasz się Jesse Liberty).
Listing 2.2. Użycie cout.[Author ID1: at Tue Nov 13 10:28:00 2001
]
0: // Listing 2.2 użycie std::cout
1: #include <iostream>
2: int main()
3: {
4: std::cout << "Hej tam.\n";
5: std::cout << "To jest 5: " << 5 << "\n";
6: std::cout << "Manipulator std::endl ";
7: std::cout << "wypisuje nowa linie na ekranie.";
8: std::cout << std::endl;
9: std::cout << "To jest bardzo duza liczba:\t" << 70000;
10: std::cout << std::endl;
11: std::cout << "To jest suma 8 i 5:\t";
12: std::cout << 8+5 << std::endl;
13: std::cout << "To jest ulamek:\t\t";
14: std::cout << (float) 5/8 << std::endl;
15: std::cout << "I bardzo, bardzo duza liczba:\t";
16: std::cout << (double) 7000 * 7000 << std::endl;
17: std::cout << "Nie zapomnij zamienic Jesse Liberty ";
18: std::cout << "na swoje nazwisko...\n";
19: std::cout << "Jesse Liberty jest programista C++!\n";
20: return 0;
21: }
Wynik działania:[Author ID1: at Tue Nov 13 10:28:00 2001
]
Hej tam.
To jest 5: 5
Manipulator std::endl wypisuje nowa linie na ekranie.
To jest bardzo duza liczba: 70000
To jest suma 8 i 5: 13
To jest ulamek: 0.625
I bardzo, bardzo duza liczba: 4.9e+007
Nie zapomnij zamienic Jesse Liberty na swoje nazwisko...
Jesse Liberty jest programista C++!
UWAGA Niektóre kompilatory zawierają błąd,[Author ID1: at Tue Nov 13 10:29:00 2001
];[Author ID1: at Tue Nov 13 10:29:00 2001
] wymagający by [Author ID1: at Tue Nov 13 10:29:00 2001
]przed przekazaniem sumy do obiektu cout należy [Author ID1: at Tue Nov 13 10:29:00 2001
]umieścić ją w nawiasach. Tak więc linia 12.[Author ID1: at Tue Nov 13 10:29:00 2001
] powinna być zmieniona na:
12 std::cout << (8+5) << std::endl;
Analiza:
W linii 1.[Author ID1: at Tue Nov 13 10:29:00 2001
], instrukcja #include <iostream> powoduje włączenie zawartości pliku [Author ID1: at Tue Nov 13 10:29:00 2001
]iostream[Author ID1: at Tue Nov 13 10:29:00 2001
] [Author ID1: at Tue Nov 13 10:29:00 2001
]do kodu źródłowego zawartości pliku [Author ID1: at Tue Nov 13 10:29:00 2001
]iostream[Author ID1: at Tue Nov 13 10:29:00 2001
]. Jest ona wymagana,[Author ID1: at Tue Nov 13 10:29:00 2001
] jeśli używasz obiektu cout i powiązanych z nim funkcji.
W linii 4.[Author ID1: at Tue Nov 13 10:30:00 2001 ] znajduje się najprostsze zastosowanie obiektu cout, do wypisania ciągu znaków. Symbol \n jest specjalnym znakiem formatującym. Informuje on cout by wypisał na ekranie znak nowej linii (tzn. aby dalsze wypisywanie rozpoczął od następnej linii ekranu).
W linii 5.[Author ID1: at Tue Nov 13 10:31:00 2001
] przekazujemy do cout trzy wartości, oddzielone operatorem wstawiania. Pierwszą z tych wartości jest łańcuch "To jest 5: ". Zwróć uwagę na odstęp po dwukropku. Ten odstęp (spacja) jest częścią łańcucha. Następnie do operatora wstawiania jest przekazywana wartość 5 oraz znak nowej linii (zawsze w cudzysłowach lub apostrofach). To[Author ID1: at Tue Nov 13 10:31:00 2001
], co[Author ID1: at Tue Nov 13 10:31:00 2001
] powoduje wypisanie na ekranie linii
To jest 5: 5
Ponieważ po pierwszym łańcuchu nie występuje znak nowej linii, następna wartość jest wypisywana tuż za nim. Nazywa się to konkatenacją (łączeniem) dwóch wartości.
W linii 6.[Author ID1: at Tue Nov 13 10:31:00 2001
] wypisywany jest informacyjny [Author ID1: at Tue Nov 13 10:31:00 2001
]komunikat informacyjny[Author ID1: at Tue Nov 13 10:31:00 2001
], po czym (w linii 8.[Author ID1: at Tue Nov 13 10:31:00 2001
]) następuje [Author ID1: at Tue Nov 13 10:32:00 2001
]użycie[Author ID1: at Tue Nov 13 10:32:00 2001
]ty[Author ID1: at Tue Nov 13 10:32:00 2001
] zostaje [Author ID1: at Tue Nov 13 10:32:00 2001
]manipulatora[Author ID1: at Tue Nov 13 10:32:00 2001
] endl. Przeznaczeniem endl jest wypisanie nowej linii na ekranie. (Inne zastosowania dla endl zostaną omówione w rozdziale 16.). Zwróć uwagę,[Author ID1: at Tue Nov 13 10:32:00 2001
] że endl także pochodzi z biblioteki standardowej.
UWAGA endl pochodzi od słów „end line” (zakończ linię) i w rzeczywistości jest to „end-L”, a nie „end-jeden”.
W linii 9.[Author ID1: at Tue Nov 13 10:32:00 2001
] został wprowadzony nowy znak formatujący, \t. Powoduje on wstawienie znaku tabulacji i jest używany w celu wyrównywania wydruków wyników [Author ID1: at Tue Nov 13 10:32:00 2001
]w liniach od 9.[Author ID1: at Tue Nov 13 10:32:00 2001
] do 15 w celu wyrównywania wydruków wyników[Author ID1: at Tue Nov 13 10:32:00 2001
]. Linia 9.[Author ID1: at Tue Nov 13 10:33:00 2001
] pokazuje,[Author ID1: at Tue Nov 13 10:33:00 2001
] że wypisywane [Author ID1: at Tue Nov 13 10:33:00 2001
]mogą być wypisywane [Author ID1: at Tue Nov 13 10:33:00 2001
]nie tylko liczby całkowite, ale także długie liczby całkowite. Linia 12.[Author ID1: at Tue Nov 13 10:33:00 2001
] demonstruje,[Author ID1: at Tue Nov 13 10:33:00 2001
] że cout potrafi wykonać proste dodawanie. Do obiektu jest przekazywana wartość 8+5, lecz wypisywana jest suma 13.
W linii 14.[Author ID1: at Tue Nov 13 10:33:00 2001
] do cout jest wstawiana wartość 5/8. Symbol (float) informuje cout [Author ID1: at Tue Nov 13 10:33:00 2001
], [Author ID1: at Tue Nov 13 10:33:00 2001
]że chcemy aby ta wartość została obliczona jako rozwinięcie dziesiętne, więc wypisywany jest ułamek. W linii 16.[Author ID1: at Tue Nov 13 10:33:00 2001
] cout otrzymuje wartość 7000 * 7000, zaś symbol (double) służy do poinformowania cout [Author ID1: at Tue Nov 13 10:34:00 2001
], [Author ID1: at Tue Nov 13 10:34:00 2001
]że jest to wartość zmiennoprzecinkowa. Wszystko to zostanie wyjaśnione w rozdziale 3., „Zmienne i stałe,” przy okazji omawiania typów danych.
W linii 16.[Author ID1: at Tue Nov 13 10:34:00 2001
] podstawiłeś swoje nazwisko, zaś wynik potwierdza,[Author ID1: at Tue Nov 13 10:34:00 2001
] że naprawdę jesteś programistą C++. Musi być to prawda, skoro tak uważa [Author ID1: at Tue Nov 13 10:34:00 2001
]komputer tak uważa[Author ID1: at Tue Nov 13 10:34:00 2001
]!
Używanie przestrzeni nazw standardowych
Z pewnością zauważyłeś,[Author ID1: at Tue Nov 13 10:34:00 2001
] że przed każdym cout i endl występuje std::, co po jakimś czasie może być irytujące. Choć korzystanie z odnośnika do przestrzeni nazw jest poprawną form[Author ID1: at Tue Nov 13 10:34:00 2001
]e[Author ID1: at Tue Nov 13 10:34:00 2001
]ą[Author ID1: at Tue Nov 13 10:34:00 2001
], jednak jest [Author ID1: at Tue Nov 13 10:34:00 2001
]okazuje się [Author ID1: at Tue Nov 13 10:34:00 2001
]dosyć żmudne przy wpisywaniu. Standard ANSI oferuje dwa rozwiązania tej[Author ID1: at Tue Nov 13 10:35:00 2001
]go[Author ID1: at Tue Nov 13 10:35:00 2001
] niewielkiej[Author ID1: at Tue Nov 13 10:35:00 2001
]go[Author ID1: at Tue Nov 13 10:35:00 2001
] niedogodności[Author ID1: at Tue Nov 13 10:35:00 2001
]problemu[Author ID1: at Tue Nov 13 10:35:00 2001
].
Pierwszym z nich jest poinformowanie kompilatora,[Author ID1: at Tue Nov 13 10:35:00 2001
] ([Author ID1: at Tue Nov 13 10:35:00 2001
] [Author ID1: at Tue Nov 13 10:35:00 2001
]na początku listingu kodu)[Author ID1: at Tue Nov 13 10:35:00 2001
],[Author ID1: at Tue Nov 13 10:35:00 2001
] że będziemy używać cout i endl z biblioteki standardowej, tak jak pokazano na listingu 2.3.
Listing 2.3. Użycie słowa kluczowego using.[Author ID1: at Tue Nov 13 10:35:00 2001
]
0: // Listing 2.3 - użycie słowa kluczowego "using"
1: #include <iostream>
2: int main()
3: {
4: using std::cout;
5: using std::endl;
6:
7: cout << "Hej tam.\n";
8: cout << "To jest 5: " << 5 << "\n";
9: cout << "Manipulator endl ";
10: cout << "wypisuje nowa linie na ekranie.";
11: cout << endl;
12: cout << "To jest bardzo duza liczba:\t" << 70000;
13: cout << endl;
14: cout << "To jest suma 8 i 5:\t";
15: cout << 8+5 << endl;
16: cout << "To jest ulamek:\t\t";
17: cout << (float) 5/8 << endl;
18: cout << "I bardzo, bardzo duza liczba:\t";
19: cout << (double) 7000 * 7000 << endl;
20: cout << "Nie zapomnij zamienic Jesse Liberty ";
21: cout << "na swoje nazwisko...\n";
22: cout << "Jesse Liberty jest programista C++!\n";
23: return 0;
24: }
Wynik działania:[Author ID1: at Tue Nov 13 10:35:00 2001
]
Hej tam.
To jest 5: 5
Manipulator endl wypisuje nowa linie na ekranie.
To jest bardzo duza liczba: 70000
To jest suma 8 i 5: 13
To jest ulamek: 0.625
I bardzo, bardzo duza liczba: 4.9e+007
Nie zapomnij zamienic Jesse Liberty na swoje nazwisko...
Jesse Liberty jest programista C++!
Zauważ,[Author ID1: at Tue Nov 13 10:35:00 2001
] że wynik jest identyczny. Jedyną różnicą pomiędzy listingiem 2.3 i[Author ID1: at Tue Nov 13 10:35:00 2001
]a[Author ID1: at Tue Nov 13 10:35:00 2001
] 2.2 jest to, że w liniach 4.[Author ID1: at Tue Nov 13 10:35:00 2001
] i 5.[Author ID1: at Tue Nov 13 10:35:00 2001
] informujemy kompilator,[Author ID1: at Tue Nov 13 10:36:00 2001
] że będziemy używać dwóch obiektów ze standardowej biblioteki. Używamy do tego słowa kluczowego using. Gdy to zrobimy, nie musimy już kwalifikować obiektów cout i endl.
Drugim sposobem uniknięcia niedogodności [Author ID1: at Tue Nov 13 10:36:00 2001
]pisania std:: przed cout i endl jest po prostu poinformowanie kompilatora,[Author ID1: at Tue Nov 13 10:36:00 2001
] że będziemy używać całej przestrzeni nazw standardowych;[Author ID1: at Tue Nov 13 10:36:00 2001
],[Author ID1: at Tue Nov 13 10:36:00 2001
] tj.[Author ID1: at Tue Nov 13 10:36:00 2001
],[Author ID1: at Tue Nov 13 10:36:00 2001
] że każdy obiekt, który nie zostanie oznaczony, z założenia będzie pochodził z przestrzeni nazw standardowych. W tym przypadku, zamiast pisać using std::cout; napiszemy po prostu using namespace std;, tak jak pokazano na listingu 2.4.
Listing 2.4. Użycie słowa kluczowego namespace.[Author ID1: at Tue Nov 13 10:36:00 2001
]
0: // Listing 2.3 - użycie przestrzeni nazw standardowych
1: #include <iostream>
2: int main()
3: {
4: using namespace std;
5:
6: cout << "Hej tam.\n";
7: cout << "To jest 5: " << 5 << "\n";
8: cout << "Manipulator endl ";
9: cout << "wypisuje nowa linie na ekranie.";
10: cout << endl;
11: cout << "To jest bardzo duza liczba:\t" << 70000;
12: cout << endl;
13: cout << "To jest suma 8 i 5:\t";
14: cout << 8+5 << endl;
15: cout << "To jest ulamek:\t\t";
16: cout << (float) 5/8 << endl;
17: cout << "I bardzo, bardzo duza liczba:\t";
18: cout << (double) 7000 * 7000 << endl;
19: cout << "Nie zapomnij zamienic Jesse Liberty ",
20: cout << "na swoje nazwisko...\n",
21: cou << "Jesse Liberty jest programista C++!\n";
22: return 0;
23: }
Także tym razem wynik jest identyczny z wynikami uzyskiwanymi we [Author ID1: at Tue Nov 13 10:37:00 2001
]wcześniejszymi[Author ID1: at Tue Nov 13 10:37:00 2001
]ch[Author ID1: at Tue Nov 13 10:37:00 2001
] wersjami[Author ID1: at Tue Nov 13 10:37:00 2001
]ch[Author ID1: at Tue Nov 13 10:37:00 2001
] programu. Zaletą zapisu using namespace std; jest to, że nie musimy określać obiektów, z których chcemy korzystać (na przykład cout oraz endl). Wadą jest to, że [Author ID1: at Tue Nov 13 10:37:00 2001
]ryzykujemy[Author ID1: at Tue Nov 13 10:37:00 2001
]o[Author ID1: at Tue Nov 13 10:37:00 2001
] niezamierzonego[Author ID1: at Tue Nov 13 10:37:00 2001
] użycie[Author ID1: at Tue Nov 13 10:37:00 2001
]a[Author ID1: at Tue Nov 13 10:37:00 2001
] obiektów z niewłaściwej biblioteki.
Puryści preferują zapisywanie std:: przed każdym wystąpieniem cout i endl. Osoby bardziej leniwe wolą używać using namespace std; i n[Author ID1: at Tue Nov 13 10:38:00 2001
]N[Author ID1: at Tue Nov 13 10:38:00 2001
]a tym zakończmy temat. W tej książce w większości przypadków będziemy pisać, z jakich obiektów korzystamy, ale od czasu do czasu, dla samej [Author ID1: at Tue Nov 13 10:38:00 2001
]odmiany, sp[Author ID1: at Tue Nov 13 10:38:00 2001
]wyp[Author ID1: at Tue Nov 13 10:38:00 2001
]róbujemy także pozostałych[Author ID1: at Tue Nov 13 10:38:00 2001
]e[Author ID1: at Tue Nov 13 10:38:00 2001
] stylów[Author ID1: at Tue Nov 13 10:38:00 2001
]style[Author ID1: at Tue Nov 13 10:38:00 2001
].
Komentarze
Gdy piszesz program, to, co chcesz osiągnąć, [Author ID1: at Tue Nov 13 10:39:00 2001
]zawsze jest jasne i oczywiste to, co chcesz osiągnąć[Author ID1: at Tue Nov 13 10:39:00 2001
]. Jednak co zabawne,[Author ID1: at Tue Nov 13 10:39:00 2001
] miesiąc gdy do niego wracasz [Author ID1: at Tue Nov 13 10:39:00 2001
]później, gdy do niego wracasz, k[Author ID1: at Tue Nov 13 10:39:00 2001
]k[Author ID1: at Tue Nov 13 10:39:00 2001
]od może okazać się całkiem niezrozumiały. Nie jestem w stanie przewidzieć,[Author ID1: at Tue Nov 13 10:40:00 2001
] co może być niezrozumiałego w twoim programie, ale tak jest[Author ID1: at Tue Nov 13 10:40:00 2001
]zdarza się to[Author ID1: at Tue Nov 13 10:40:00 2001
] zawsze.
Aby sobie z tym poradzić, a także,[Author ID1: at Tue Nov 13 10:40:00 2001
] by pomóc innym w zrozumieniu twojego kodu, powinieneś używać komentarzy. Komentarze są tekstem całkowicie ignorowanym przez kompilator, lecz [Author ID1: at Tue Nov 13 10:40:00 2001
]mogą natomiast [Author ID1: at Tue Nov 13 10:40:00 2001
]informować czytającego o tym, co robisz w danym punkcie programu.
Rodzaje komentarzy
Komentarze w C++ występują w dwóch odmianach: jako komentarze podwójnego ukośnika (//) oraz jako komentarze ukośnika i gwiazdki (/*). Komentarz podwójnego ukośnika, nazywany komentarzem w stylu C++, informuje kompilator,[Author ID1: at Tue Nov 13 10:40:00 2001 ] by zignorował wszystko,[Author ID1: at Tue Nov 13 10:41:00 2001 ] co po nim następuje, aż do końca linii.
Komentarz ukośnika i gwiazdki informuje kompilator,[Author ID1: at Tue Nov 13 10:41:00 2001 ] by zignorował wszystko to, co jest zawarte pomiędzy znakami /* oraz */. Te znaki są nazywane komentarzami w stylu C. Każdemu znakowi /* musi odpowiadać zamykający komentarz znak */.
Jak można się domyślać, komentarze w stylu C są używane także w programach C, lecz [Author ID1: at Tue Nov 13 10:41:00 2001
]; jednakże [Author ID1: at Tue Nov 13 10:41:00 2001
]komentarze C++ nie są częścią oficjalnej definicji języka C.
Większość programistów używa w większości przypadków[Author ID1: at Tue Nov 13 10:41:00 2001
]przeważnie[Author ID1: at Tue Nov 13 10:41:00 2001
] komentarzy w stylu C++, rezerwują[Author ID1: at Tue Nov 13 10:41:00 2001
]c [Author ID1: at Tue Nov 13 10:41:00 2001
]komentarze w stylu C rezerwując dla[Author ID1: at Tue Nov 13 10:41:00 2001
]do[Author ID1: at Tue Nov 13 10:41:00 2001
] wyłączania z kompilacji większych bloków kodu. Komentarze w stylu C++ mogą występować w blokach kodu „wy[Author ID1: at Tue Nov 13 10:41:00 2001
]s[Author ID1: at Tue Nov 13 10:41:00 2001
]komentowanych” komentarzami w stylu C. Ignorowana jest zawartość całego „wy[Author ID1: at Tue Nov 13 10:42:00 2001
]s[Author ID1: at Tue Nov 13 10:42:00 2001
]komentowanego” bloku, w[Author ID1: at Tue Nov 13 10:42:00 2001
]łącznie z komentarzami w stylu C++.
Używanie komentarzy
Niektórzy programiści zalecają stosowanie komentarzy przed każdą funkcją,[Author ID1: at Tue Nov 13 10:42:00 2001
] ([Author ID1: at Tue Nov 13 10:42:00 2001
] [Author ID1: at Tue Nov 13 10:42:00 2001
]w celu wyjaśnienia,[Author ID1: at Tue Nov 13 10:42:00 2001
] jakie czynności [Author ID1: at Tue Nov 13 10:42:00 2001
]co ta [Author ID1: at Tue Nov 13 10:42:00 2001
]funkcja robi [Author ID1: at Tue Nov 13 10:43:00 2001
]wykonuje [Author ID1: at Tue Nov 13 10:43:00 2001
]i jakie wartości zwraca)[Author ID1: at Tue Nov 13 10:42:00 2001
].[Author ID1: at Tue Nov 13 10:42:00 2001
]
Osobiście nie zgadzam się z tym, gdyż [Author ID1: at Tue Nov 13 10:43:00 2001
]uważam,[Author ID1: at Tue Nov 13 10:43:00 2001
] że komentarze w nagłówkach funkcji zwykle są nieaktualne, bo prawie nikt nie pamięta o tym, by zaktualizować je [Author ID1: at Tue Nov 13 10:43:00 2001
]po modyfikacji kodu je zaktualizować[Author ID1: at Tue Nov 13 10:43:00 2001
]. Funkcje powinny mieć takie[Author ID1: at Tue Nov 13 10:43:00 2001
]przyjmować takie[Author ID1: at Tue Nov 13 10:43:00 2001
] nazwy, by [Author ID1: at Tue Nov 13 10:44:00 2001
]na ich [Author ID1: at Tue Nov 13 10:44:00 2001
]podstawie których [Author ID1: at Tue Nov 13 10:44:00 2001
]można było [Author ID1: at Tue Nov 13 10:44:00 2001
]jasno określić, do czego służą. Z kolei niejasne i skomplikowane fragmenty kodu powinny zostać przeprojektowane i przepisane,[Author ID1: at Tue Nov 13 10:44:00 2001
] tak,[Author ID1: at Tue Nov 13 10:44:00 2001
] aby same się objaśniały. Dość często zdarza się,[Author ID1: at Tue Nov 13 10:44:00 2001
] że komentarze stanowią dla leniwego programisty wymówkę [Author ID1: at Tue Nov 13 10:44:00 2001
]pretekst [Author ID1: at Tue Nov 13 10:44:00 2001
]dla niedbałości.
Nie sugeruję oczywiście by nigdy[Author ID1: at Tue Nov 13 10:45:00 2001
]żeby w ogóle[Author ID1: at Tue Nov 13 10:45:00 2001
] nie korzystać z komentarzy, choć oczywiście nie powinny służyć do wyjaśniania niejasnego kodu. Zamiast tego[Author ID1: at Tue Nov 13 10:45:00 2001
]W takim przypadku[Author ID1: at Tue Nov 13 10:45:00 2001
] należy poprawić sam kod. Mówiąc krótko, pisz swoje programy dobrze, zaś komentarzy używaj w celu poprawy jego[Author ID1: at Tue Nov 13 10:45:00 2001
]zwiększenia ich[Author ID1: at Tue Nov 13 10:45:00 2001
] zrozumiałości.
Listing 2.5 demonstruje użycie komentarzy,[Author ID1: at Tue Nov 13 10:45:00 2001
] i[Author ID1: at Tue Nov 13 10:45:00 2001
] pokazując[Author ID1: at Tue Nov 13 10:45:00 2001
]e,[Author ID1: at Tue Nov 13 10:45:00 2001
] że nie wpływają one na działanie programu an[Author ID1: at Tue Nov 13 10:45:00 2001
]i na otrzymywane wyniki.
Listing 2.5. HELP.cpp demonstruje komentarze.[Author ID1: at Tue Nov 13 10:46:00 2001
]
0: #include <iostream>
1:
2: int main()
3: {
4: using std::cout;
5:
6: /* to jest komentarz w stylu C
7: i rozciąga się on aż do zamykającego
8: znaku gwiazdki i ukośnika */
9: cout << "Witaj Swiecie!\n";
10: // ten komentarz kończy się wraz z końcem tej linii
11: cout << "Ten komentarz sie zakonczyl!\n";
12:
13: // komentarze podwójnego ukośnika mogą występować w linii same
14: /* podobnie jak komentarze ukośnika i gwiazdki */
15: return 0;
16: }
Witaj Swiecie!
Ten komentarz sie zakonczyl!
Komentarze w liniach od 6.[Author ID1: at Tue Nov 13 10:46:00 2001 ] do 8.[Author ID1: at Tue Nov 13 10:46:00 2001 ] są całkowicie ignorowane przez kompilator, podobnie jak komentarze w liniach 10.[Author ID1: at Tue Nov 13 10:46:00 2001 ], 13.[Author ID1: at Tue Nov 13 10:46:00 2001 ] oraz 14. Komentarz w linii 10.[Author ID1: at Tue Nov 13 10:46:00 2001 ] kończy się wraz z końcem linii, lecz komentarze w liniach 6.[Author ID1: at Tue Nov 13 10:46:00 2001 ] i 14.[Author ID1: at Tue Nov 13 10:46:00 2001 ] wymagają użycia [Author ID1: at Tue Nov 13 10:46:00 2001 ]zamykającego znaku komentarza.
I j[Author ID1: at Tue Nov 13 10:46:00 2001
]J[Author ID1: at Tue Nov 13 10:46:00 2001
]eszcze jedna uwaga na temat komentarzy
Komentarze, które informują o czymś oczywistym, są bezużyteczne. W rzeczywistości, m[Author ID1: at Tue Nov 13 10:46:00 2001
]M[Author ID1: at Tue Nov 13 10:46:00 2001
]ogą być wręcz szkodliwe, gdyż [Author ID1: at Tue Nov 13 10:47:00 2001
]np. gdy [Author ID1: at Tue Nov 13 10:47:00 2001
]kod może [Author ID1: at Tue Nov 13 10:47:00 2001
]ulec[Author ID1: at Tue Nov 13 10:47:00 2001
]gnie[Author ID1: at Tue Nov 13 10:47:00 2001
] zmianie, lecz [Author ID1: at Tue Nov 13 10:47:00 2001
]a [Author ID1: at Tue Nov 13 10:47:00 2001
]programista może [Author ID1: at Tue Nov 13 10:47:00 2001
]zapomnieć[Author ID1: at Tue Nov 13 10:47:00 2001
] o aktualizacji komentarza. Jednak to,[Author ID1: at Tue Nov 13 10:48:00 2001
] co jest oczywiste dla jednej osoby, może być niezrozumiałe dla innej, więc [Author ID1: at Tue Nov 13 10:48:00 2001
]zatem [Author ID1: at Tue Nov 13 10:48:00 2001
]musisz samodzielnie to osądzić[Author ID1: at Tue Nov 13 10:48:00 2001
]ocenić użyteczność komentarza[Author ID1: at Tue Nov 13 10:48:00 2001
].
Mówiąc o[Author ID1: at Tue Nov 13 10:48:00 2001
]O[Author ID1: at Tue Nov 13 10:48:00 2001
]gólnie rzecz biorąc[Author ID1: at Tue Nov 13 10:48:00 2001
], komentarze powinny informować nie o tym,[Author ID1: at Tue Nov 13 10:48:00 2001
] co się dzieje, ale o tym, dlaczego tak się dzieje.
Funkcje
Choć [Author ID1: at Tue Nov 13 10:49:00 2001
]Funkcja [Author ID1: at Tue Nov 13 10:49:00 2001
]main() nie [Author ID1: at Tue Nov 13 10:49:00 2001
]jest zwykłą [Author ID1: at Tue Nov 13 10:49:00 2001
]funkcją, jednak jest to funkcja niezwykła[Author ID1: at Tue Nov 13 10:49:00 2001
]. Aby być użyteczną,[Author ID1: at Tue Nov 13 10:49:00 2001
]Normalnie[Author ID1: at Tue Nov 13 10:49:00 2001
] funkcja musi być wywołana w czasie działania programu. Funkcja main() jest wywoływana przez system operacyjny.
Program jest wykonywany „[Author ID1: at Tue Nov 13 10:49:00 2001
]linia po linii”[Author ID1: at Tue Nov 13 10:50:00 2001
] - [Author ID1: at Tue Nov 13 10:50:00 2001
]w kolejności, w jakiej [Author ID1: at Tue Nov 13 10:50:00 2001
] ich [Author ID1: at Tue Nov 13 10:50:00 2001
]występowania[Author ID1: at Tue Nov 13 10:50:00 2001
]ują[Author ID1: at Tue Nov 13 10:50:00 2001
] w kodzie źródłowym, aż do napotkania wywołania funkcji. Wtedy działanie programu się [Author ID1: at Tue Nov 13 10:50:00 2001
]„[Author ID1: at Tue Nov 13 10:50:00 2001
]rozgałęzia” się [Author ID1: at Tue Nov 13 10:50:00 2001
] w celu wykonania funkcji. Gdy funkcja zakończy działanie, zwraca sterowanie do linii kodu następującej bezpośrednio po linii, w której funkcja została wywołana.
Dobrą[Author ID1: at Tue Nov 13 10:51:00 2001
]ym przykłądem jest [Author ID1: at Tue Nov 13 10:51:00 2001
] analogią jest [Author ID1: at Tue Nov 13 10:51:00 2001
]ostrzenie ołówka. Jeśli rysujesz obrazek i[Author ID1: at Tue Nov 13 10:51:00 2001
]a[Author ID1: at Tue Nov 13 10:51:00 2001
] w ołówku złamie się grafit, przestajesz rysować, idziesz naostrzyć ołówek, po czym wracasz do tego miejsca rysunku, w którym przerwałeś rysowanie[Author ID1: at Tue Nov 13 10:51:00 2001
]. Gdy program wymaga wykonania usługi, może w tym celu wywołać funkcję, po czym po zakończeniu [Author ID1: at Tue Nov 13 10:51:00 2001
]jej działanie [Author ID1: at Tue Nov 13 10:51:00 2001
]zakończeniu [Author ID1: at Tue Nov 13 10:51:00 2001
]podjąć działanie w tym miejscu, w którym je [Author ID1: at Tue Nov 13 10:51:00 2001
]przerwał działanie[Author ID1: at Tue Nov 13 10:51:00 2001
]. Tę ideę[Author ID1: at Tue Nov 13 10:52:00 2001
]Przebieg tego procesu[Author ID1: at Tue Nov 13 10:52:00 2001
] demonstruje listing 2.6.
Listing 2.6. Demonstracja [Author ID1: at Tue Nov 13 10:52:00 2001
]Przykład [Author ID1: at Tue Nov 13 10:52:00 2001
]wywołania funkcji.[Author ID1: at Tue Nov 13 10:52:00 2001
]
0: #include <iostream>
1:
2: // funkcja DemonstrationFunction
3: // wypisuje informacyjny komunikat
4: void DemonstrationFunction()
5: {
6: std::cout << "Wewnatrz funkcji DemonstrationFunction\n";
7: }
8:
9: // funkcja main - wypisuje komunikat, następnie
10: // wywołuje funkcję DemonstrationFunction, po czym wypisuje
11: // drugi komunikat.
12: int main()
13: {
14: std::cout << "Wewnatrz funkcji main\n" ;
15: DemonstrationFunction();
16: std::cout << "Ponownie w funkcji main\n";
17: return 0;
18: }
Wewnatrz funkcji main
Wewnatrz funkcji DemonstrationFunction
Ponownie w funkcji main
Funkcja DemonstrationFunction() jest zdefiniowana w liniach od 5.[Author ID1: at Tue Nov 13 10:52:00 2001 ] do 7. Gdy zostanie wywołana, wypisuje na ekranie komunikat, po czym wraca.
Linia 12.[Author ID1: at Tue Nov 13 10:53:00 2001
] stanowi początek rzeczywistego programu. W linii 14.[Author ID1: at Tue Nov 13 10:53:00 2001
] funkcja main() wypisuje komunikat informujący,[Author ID1: at Tue Nov 13 10:53:00 2001
] że program znajduje się wewnątrz funkcji main(). Po wypisaniu tego komunikatu, wywołuje funkcję [Author ID1: at Tue Nov 13 10:53:00 2001
]DemonstrateFunction()[Author ID1: at Tue Nov 13 10:53:00 2001
]w [Author ID1: at Tue Nov 13 10:53:00 2001
] w [Author ID1: at Tue Nov 13 10:53:00 2001
]linii 15 wywołuje funkcję [Author ID1: at Tue Nov 13 10:53:00 2001
]DemonstrateFunction()[Author ID1: at Tue Nov 13 10:53:00 2001
]. To wywołanie powoduje że wykonane zostają instrukcje zawarte wewnątrz funkcji DemonstrationFunction (). W tym przypadku, cała funkcja składa się z kodu w linii 6.[Author ID1: at Tue Nov 13 10:53:00 2001
], który [Author ID1: at Tue Nov 13 10:54:00 2001
]kod ten [Author ID1: at Tue Nov 13 10:54:00 2001
]wypisuje kolejny komunikat. Gdy funkcja DemonstrateFunction() kończy działanie (linia 7.[Author ID1: at Tue Nov 13 10:54:00 2001
]), program powraca do linii, z której ta funkcja została wywołana. W tym przypadku program wraca do linii 16.[Author ID1: at Tue Nov 13 10:54:00 2001
], w której funkcja main() wypisuje ostatnią linię komunikatu.
UWAGA Zwróć uwagę,[Author ID1: at Tue Nov 13 10:54:00 2001
] że w funkcji [Author ID1: at Tue Nov 13 10:54:00 2001
]DemonstrationFunction[Author ID1: at Tue Nov 13 10:54:00 2001
] [Author ID1: at Tue Nov 13 10:54:00 2001
]nie ma sensu stosować instrukcji using w funkcji [Author ID1: at Tue Nov 13 10:54:00 2001
]DemonstrationFunction[Author ID1: at Tue Nov 13 10:54:00 2001
],[Author ID1: at Tue Nov 13 10:54:00 2001
] [Author ID1: at Tue Nov 13 10:55:00 2001
], [Author ID1: at Tue Nov 13 10:54:00 2001
]gdyż z obiektu cout korzystamy tylko raz, w związku z czym w zupełności wystarczy zastosowanie zapisu std::cout. W funkcji [Author ID1: at Tue Nov 13 10:55:00 2001
]main()[Author ID1: at Tue Nov 13 10:55:00 2001
] m[Author ID1: at Tue Nov 13 10:55:00 2001
]M[Author ID1: at Tue Nov 13 10:55:00 2001
]ógłbym zdecydować się na skorzystanie z instrukcji using w funkcji [Author ID1: at Tue Nov 13 10:55:00 2001
]main()[Author ID1: at Tue Nov 13 10:55:00 2001
],[Author ID1: at Tue Nov 13 10:55:00 2001
],[Author ID1: at Tue Nov 13 10:55:00 2001
] ale także tym razem po prostu użyłem obiektu wraz z nazwą przestrzeni nazw, tak jak pokazano w liniach 14.[Author ID1: at Tue Nov 13 10:55:00 2001
] i 16.
Korzystanie z funkcji
Funkcje albo [Author ID1: at Tue Nov 13 10:55:00 2001
]zwracają albo [Author ID1: at Tue Nov 13 10:55:00 2001
]wartość, albo zwracają [Author ID1: at Tue Nov 13 10:55:00 2001
]typ void, który oznacza,[Author ID1: at Tue Nov 13 11:20:00 2001
] że nie zwracają niczego. Funkcja dodająca dwie liczby całkowite może zwracać ich sumę, i jako[Author ID1: at Tue Nov 13 11:21:00 2001
]funkcja[Author ID1: at Tue Nov 13 11:21:00 2001
] taka będzie zdefiniowana jako zwracająca wartość całkowitą. Funkcja, która[Author ID1: at Tue Nov 13 11:21:00 2001
] jedynie wypisująca[Author ID1: at Tue Nov 13 11:21:00 2001
]e[Author ID1: at Tue Nov 13 11:21:00 2001
] komunikat,[Author ID1: at Tue Nov 13 11:21:00 2001
] nie musi niczego zwracać i jako taka [Author ID1: at Tue Nov 13 11:21:00 2001
]może zostać zadeklarowana jako zwracająca typ void.
Funkcja składa się z nagłówka oraz ciała. Z kolei n[Author ID1: at Tue Nov 13 11:21:00 2001
]N[Author ID1: at Tue Nov 13 11:21:00 2001
]agłówek składa się ze zwracanego typu, nazwy funkcji oraz parametrów funkcji. Parametry funkcji umożliwiają przekazywanie wartości do funkcji. Tak więc[Author ID1: at Tue Nov 13 11:22:00 2001
]Zatem[Author ID1: at Tue Nov 13 11:22:00 2001
], jeśli funkcja ma dodawać dwie liczby, będą one parametrami funkcji. Oto typowy nagłówek funkcji:
int Sum(int a, int b)
Parametr jest deklaracją typu wartości, jaka zostanie przekazana funkcji; sama [Author ID1: at Tue Nov 13 11:22:00 2001
]wartość przekazywana w wywołaniu funkcji jest nazywana argumentem. Wielu programistów używa określeń parametr i argument jako synonimów. Inni zwracają uwagę na to techniczne [Author ID1: at Tue Nov 13 11:22:00 2001
]rozróżnienie. W tej książce obu terminów będziemy używać zamiennie.
Ciało funkcji składa się z otwierającego nawiasu klamrowego, braku lub [Author ID1: at Tue Nov 13 11:23:00 2001
]pewnej liczby instrukcji lub ich braku[Author ID1: at Tue Nov 13 11:23:00 2001
], oraz klamrowego nawiasu zamykającego. Instrukcje określają działanie funkcji. Funkcja może zwracać wartość,[Author ID1: at Tue Nov 13 11:23:00 2001
] używając instrukcji return. Ta instrukcja jednocześnie [Author ID1: at Tue Nov 13 11:23:00 2001
]powoduje również [Author ID1: at Tue Nov 13 11:23:00 2001
]wyjście z funkcji. Jeśli nie umieścisz instrukcji [Author ID1: at Tue Nov 13 11:24:00 2001
]return[Author ID1: at Tue Nov 13 11:24:00 2001
] [Author ID1: at Tue Nov 13 11:24:00 2001
]wewnątrz funkcji nie umieścisz instrukcji [Author ID1: at Tue Nov 13 11:24:00 2001
]return[Author ID1: at Tue Nov 13 11:24:00 2001
], funkcja automatycznie na koniec[Author ID1: at Tue Nov 13 11:24:00 2001
] zwróci wartość typu void. Zwracana wartość musi mieć typ zgodny z typem zadeklarowanym w nagłówku funkcji.
UWAGA Funkcje zostaną omówione bardziej szczegółowo w rozdziale 5., „Funkcje.” Typy, jakie mogą być przez funkcje [Author ID1: at Tue Nov 13 11:24:00 2001
]zwracane przez funkcje[Author ID1: at Tue Nov 13 11:24:00 2001
], zostaną dokładniej omówione w rozdziale 3., „Zmienne i stałe.” Informacje podane [Author ID1: at Tue Nov 13 11:24:00 2001
]zamieszczone [Author ID1: at Tue Nov 13 11:24:00 2001
]w tym rozdziale mają na celu jedynie pobieżne [Author ID1: at Tue Nov 13 11:24:00 2001
]ogólne [Author ID1: at Tue Nov 13 11:24:00 2001
]zaprezentowanie funkcji, gdyż są one używane w praktycznie wszystkich programach C++.
Listing 2.7 przedstawia funkcję, która otrzymuje dwa parametry całkowite i zwraca wartość całkowitą. Nie martw się na razie o składnię lub[Author ID1: at Tue Nov 13 11:25:00 2001
]i[Author ID1: at Tue Nov 13 11:25:00 2001
] sposób posługiwania się wartościami całkowitymi (na przykład int x); zostanie[Author ID1: at Tue Nov 13 11:25:00 2001
]ą[Author ID1: at Tue Nov 13 11:25:00 2001
] to [Author ID1: at Tue Nov 13 11:25:00 2001
]one [Author ID1: at Tue Nov 13 11:25:00 2001
]dokładnie omówione w rozdziale 3.
Listing 2.7. FUNC.cpp demonstruje prostą funkcję.[Author ID1: at Tue Nov 13 11:25:00 2001
]
0: #include <iostream>
1: int Add (int x, int y)
2: {
3: std::cout << "Funkcja Add() otrzymala " << x << " oraz " << y << "\n";
4: return (x+y);
5: }
6:
7: int main()
8: {
9: using std::cout;
10: using std::cin;
11:
12:
13: cout << "Jestem w funkcji main()!\n";
14: int a, b, c;
15: cout << "Wpisz dwie liczby: ";
16: cin >> a;
17: cin >> b;
18: cout << "\nWywoluje funkcje Add()\n";
19: c=Add(a,b);
20: cout << "\nPonownie w funkcji main().\n";
21: cout << "c zostalo ustawione na " << c;
22: cout << "\nOpuszczam program...\n\n";
23: return 0;
24: }
Jestem w funkcji main()!
Wpisz dwie liczby: 3 5
Wywoluje funkcje Add()
Funkcja Add() otrzymala 3 oraz 5
Ponownie w funkcji main().
c zostalo ustawione na 8
Opuszczam program...
Funkcja Add() jest zdefiniowana w linii 1. Otrzymuje dwa parametry w postaci liczb całkowitych i zwraca wartość całkowitą. Sam program zaczyna się w linii 7. Program prosi użytkownika o dwie liczby (linie od [Author ID1: at Tue Nov 13 11:26:00 2001
]15.[Author ID1: at Tue Nov 13 11:25:00 2001
] do 17.[Author ID1: at Tue Nov 13 11:25:00 2001
]). Użytkownik wpisuje liczby, oddzielając je spacją, po czym wciska [Author ID1: at Tue Nov 13 11:26:00 2001
]naciska [Author ID1: at Tue Nov 13 11:26:00 2001
]klawisz Enter. Funkcja main() w linii 19.[Author ID1: at Tue Nov 13 11:25:00 2001
] przekazuje funkcji Add()wartości wpisane przez użytkownika.
Przetwarzanie przechodzi do funkcji Add(), która rozpoczyna się od linii 1. Parametry a i b są wypisywane, po czym sumowane. Rezultat sumowania jest zwracany w linii 4.[Author ID1: at Tue Nov 13 11:26:00 2001 ], po czym następuje wyjście z funkcji.
Znajdujący się w[Author ID1: at Tue Nov 13 11:26:00 2001
]W[Author ID1: at Tue Nov 13 11:26:00 2001
] liniach 16.[Author ID1: at Tue Nov 13 11:26:00 2001
] i 17.[Author ID1: at Tue Nov 13 11:26:00 2001
] obiekt cin służy do uzyskania liczb dla zmiennych a i b, zaś obiekt cout jest używany do wypisania tych wartości na ekranie. Zmienne i inne aspekty tego programu zostaną dogłębnie [Author ID1: at Tue Nov 13 11:27:00 2001
]szerzej [Author ID1: at Tue Nov 13 11:27:00 2001
]omówione w kilku następnych rozdziałach.
W środowisku programowania,[Author ID1: at Tue Nov 13 10:18:00 2001
] takim,[Author ID1: at Tue Nov 13 10:18:00 2001
] jak np. Visual, pod napisem Witaj Swiecie! pojawi się jeszcze [Author ID1: at Tue Nov 13 10:18:00 2001
]dodatkowo [Author ID1: at Tue Nov 13 10:18:00 2001
]napis: Press any key to continue. Naciśnięcie jakiegokolwiek klawisza zamknie działanie programu HELLO.exe i usunie z ekranu jego okno (ramkę). — [Author ID1: at Tue Nov 13 10:18:00 2001
]przyp.redakcji.[Author ID1: at Tue Nov 13 10:18:00 2001
]
2 Część I ♦ Podstawy obsługi systemu WhizBang (Nagłówek strony)
2 F:\korekta\r02-06.doc[Author ID1: at Tue Nov 13 11:20:00 2001
]H:\Książki\!Wit\C++ dla każdego\6 po merytorycznej\r02-06.doc[Author ID1: at Tue Nov 13 10:14:00 2001
]