Rozdział 3. Pierwszy program

Wiesz już jak wygląda programowanie w języku C++ i masz zainstalowane środowisko programistyczne (program, dzięki któremu możesz tworzyć własne programy). W tej chwili zapewne nasuwa Ci się pytanie: „Od czego zacząć”?

Tak naprawdę to już zaczęliśmy programować. Oczywiście na razie nie potrafisz jeszcze napisać żadnego wielkiego programu. Trójwymiarowe aplikacje działające w czasie rzeczywistym są jeszcze poza Twoim zasięgiem. Ale wszystko po kolei. W tym rozdziale skoncentrujemy się na wyświetleniu tekstu na ekranie.

3.1. Niezwykły świat konsoli

Po przeczytaniu, że zaczynamy programować zapewne pomyślałeś sobie: „Znakomicie, zawsze chciałem nauczyć się robić to i tamto”. Chcielibyśmy Cię nieco uspokoić i pokazać Ci wszystko po kolei.

Zaczniemy od podstaw. Aby nauczyć się pisać skomplikowane trójwymiarowe aplikacje, to nie ma innego wyjścia, jak tylko najpierw przyswoić sobie podstawowe zasady programowania.

Wyróżnia się dwa rodzaje programów: z graficznym interfejsem użytkownika i konsolowe.

3.1.1. Programy z graficznym interfejsem użytkownika

Programy z graficznym interfejsem użytkownika to takie, które mają własne okno. Z pewnością wiesz o co chodzi, ponieważ z takimi aplikacjami masz najczęściej do czynienia. Okno takiego programu jest widoczne na ekranie i można je zminimalizować, zamknąć, powiększyć itd. W terminologii programistycznej graficzny interfejs użytkownika często określa się akronimem GUI (ang. Graphical User Interface — graficzny interfejs użytkownika).

3.1.2. Programy konsolowe

Programy konsolowe częściej spotyka się w systemach Linux niż Windows czy Mac OS X. Steruje się nimi za pomocą prostych poleceń wyświetlanych w oknie z najczęściej czarnym tłem.

Do obsługi tych programów używa się wyłącznie klawiatury, mysz nie jest do tego w ogóle potrzebna. Ich wykonywanie odbywa się liniowo, tzn. komunikaty programu są wyświetlane od góry do dołu.

3.1.3. Pierwszy cel — program konsolowy

Przygodę z programowaniem rozpoczniemy od pisania programów konsolowych. Mimo iż na pierwszy rzut oka wydają się one mało atrakcyjne wizualnie, to znacznie łatwiej się je tworzy niż programy graficzne. Dlatego też każdy początkujący programista powinien zacząć naukę od tworzenia właśnie od tego rodzaj aplikacji.

Oczywiście zdajemy sobie sprawę, że programy konsolowe to nie jest szczyt Twoich ambicji. Możesz być spokojny — wiemy że większość czytelników interesuje przede wszystkim tworzenie programów z graficznym interfejsem użytkownika. Dlatego całą jedną część tego kursu poświęciliśmy tworzeniu graficznych interfejsów użytkownika programów przy użyciu biblioteki Qt. Biblioteka ta jest czymś w rodzaju rozszerzenia języka C++, które pozwala na tworzenia właśnie tego typu programów.

Zanim jednak do tego dojdziemy, musimy zakasać rękawy i ostro wziąć się do pracy!

3.2. Utworzenie i uruchomienie pierwszego projektu

W poprzednim rozdziale objaśniliśmy, jak zainstalować środowisko programistyczne, czyli program zawierający wszystkie narzędzia potrzebne do pisania programów. Napisaliśmy, że istnieje wiele takich środowisk (m.in. Code::Blocks, Visual C++ i Xcode). Wymieniliśmy tylko kilka najbardziej popularnych, ale jest ich znacznie więcej.

Jak już wspominaliśmy, najczęściej używamy środowiska Code::Blocks, ale w razie potrzeby będziemy też podawać objaśnienia dotyczące innych środowisk. Na szczęście wszystkie te programy są do siebie bardzo podobne, a więc na pewno w żadnym z nich się nie pogubisz.

3.2.1. Tworzenie projektu

Pierwszą czynnością, jaką należy wykonać, aby rozpocząć programowanie jest utworzenie nowego projektu w środowisku programistycznym. To tak, jakby uruchomić edytor tekstu i utworzyć w nim pusty dokument.

Aby utworzyć nowy projekt, kliknij kolejno File/New/Project (plik/nowy/projekt) — rysunek 3.2.

Zostanie uruchomiony kreator tworzenia nowego projektu, którego opis znajduje się w poprzednim rozdziale. Utwórz nowy program konsolowy C++ zgodnie ze wskazówkami zawartymi w tamtym rozdziale.

Po zakończeniu wszystkich czynności kreator utworzy nowy projekt z gotowym jednym plikiem. Rozwiń znajdujące się po lewej stronie drzewo plików, aby uzyskać dostęp do pliku main.cpp. Kliknij ten plik dwukrotnie, aby go otworzyć. Jak widać, zawiera on już trochę kodu źródłowego — rysunek 3.3!

Ten pierwszy program utworzony automatycznie przez Code::Blocks jest bardzo prosty. Wyświetla on jedynie na ekranie tekst Hello, World (Witaj, świecie).

W tym programie jest aż dziesięć wierszy kodu źródłowego w języku C++, a ja nie rozumiem ani jednego z nich.

Na pierwszy rzut oka kod ten może się wydawać skomplikowany, ale wkrótce wszystko się wyjaśni i okaże się, że wcale nie jest tak źle.

3.2.2. Uruchamianie programu

Teraz chcielibyśmy, abyś wykonał bardzo prostą czynność: spróbuj skompilować i uruchomić ten domyślny program. Nie wiesz jak? Po lewej stronie paska narzędzi znajduje się specjalny przycisk o nazwie Build and Run (skompiluj i uruchom), który służy do tego celu — jego ikona przedstawia koło zębate z zieloną strzałką (rysunek 3.4).

Kliknięcie tego przycisku spowoduje uruchomienie kompilatora. W dolnej części okna środowiska (w okienku Build log) zostaną wyświetlone różne komunikaty.

Jeśli kompilacja nie powiedzie się i program zgłosi następujący komunikat o błędzie:

"My-program - Release" uses an invalid compiler. Skipping...
Nothing to be done.

… to znaczy, że masz wersję Code::Blocks bez narzędzia mingw (kompilatora). Wejdź ponownie na stronę Code::Blocks i pobierz program jeszcze raz, tym razem zwracając uwagę na to, czy wybrałeś wersję z kompilatorem.

Jeśli wszystko pójdzie dobrze, na ekranie pojawi się okno konsoli z wynikiem działania naszego programu (rysunek 3.5).

Zgodnie z oczekiwaniami w powyższym oknie widnieje napis Hello, World. Czyż to nie jest piękne? Właśnie skompilowałeś i uruchomiłeś swój pierwszy w życiu program komputerowy!

Na dysku Twojego komputera został zapisany plik wykonywalny. Jeśli pracujesz w systemie Windows, plik ten ma rozszerzenie .exe. Znajduje się on w folderze release (albo debug) w katalogu projektu.

Jeśli do kompilacji tego programu użyjesz środowiska Visual C++, konsola zostanie zamknięta natychmiast po zakończeniu jego wykonywania i nic nie zdążysz zobaczyć. Środowisko Visual C++ nie utrzymuje otwartego okna konsoli tak, jak to robi Code::Blocks. Można ten problem rozwiązać wpisując przed instrukcję return 0; instrukcję system("PAUSE"), która zapobiegnie natychmiastowemu zamknięciu konsoli.

3.3. Objaśnienie kodu źródłowego domyślnego programu

Środowisko Code::Blocks utworzyło automatycznie plik o nazwie main.cpp zawierający następujący kod źródłowy:

#include <iostream>
using namespace std;
int main()
{
    cout << "Hello world!" << endl;
    return 0;
}

Wszystkie opisywane wcześniej IDE tworzą wstępny plik podobny do tego, którego zawartość jest przedstawiona powyżej. To pozwala szybciej rozpocząć programowanie. Trzy pierwsze wiersze powyższego kodu znajdziesz prawie w każdym programie w języku C++. Od nich będziesz zaczynać praktycznie każdy swój program.

Poniżej znajduje się opis po kolei wszystkich wierszy przykładowego kodu. Na razie nie podaję zbyt szczegółowych informacji, ponieważ dla początkującego programisty nie są one aż tak ważne. Podobny kod znajdziesz w większości programów, które opisujemy w tym kursie.

3.3.1. Dyrektywa #include

W pierwszym wierszu programu znajduje się następujący kod źródłowy:

#include <iostream>

Jest to tzw. dyrektywa preprocesora. Jej zdaniem jest spowodowanie wczytania funkcji języka C++, za pomocą których będziemy mogli wykonać określone czynności.

Możliwość dołączania takich modułów oznacza, że język C++ jest językiem modularnym. W wersji podstawowej niewiele można przy jego użyciu zrobić, nawet nie wyświetli się komunikatu na ekranie! Aby móc zrobić coś pożytecznego, musimy dołączyć do programu specjalne rozszerzenia zwane bibliotekami, które zawierają mnóstwo narzędzi umożliwiających robienie różnych rzeczy.

Za pomocą opisywanej instrukcji dołączamy do programu plik o nazwie iostream, który jest biblioteką zawierającą funkcje umożliwiające m.in. wyświetlanie komunikatów w oknie konsoli. Wydaje się, że wyświetlenie czegoś na ekranie to bardzo prosta czynność, a jednak aby to zrobić trzeba dołączyć do programu specjalną bibliotekę.

W dalszej części kursu poznasz także inne biblioteki, które również będą dołączane na początku kodu programu w sposób podobny do pokazanego w tym przykładzie. Gdy na przykład będziemy omawiać tworzenie graficznych interfejsów użytkownika programów, będziemy do naszych aplikacji dołączać bibliotekę Qt za pomocą poniższego wiersza kodu:

#include <Qt>

Należy podkreślić, że do programu można dołączyć wszystkie potrzebne biblioteki na raz.

3.3.2. Instrukcja using namespace

Poniższy wiersz kodu informuje program, z jakiego zestawu funkcji będziemy w nim korzystać:

using namespace std;

Każda biblioteka załadowana do programu zawiera wiele różnych funkcji. Jeśli wczytamy kilka bibliotek, może się zdarzyć, że niektóre nazwy funkcji będą się powtarzać. Weźmy na przykład funkcję, której nazwa po polsku brzmiałaby „WyświetlKomunikat”. Funkcję taką można znaleźć zarówno w bibliotece iostream, jak i w Qt! Jeśli załadujesz do programu obie te biblioteki i wywołasz funkcję „WyświetlKomunikat”, komputer nie będzie wiedział, czy ma wyświetlić komunikat w oknie konsoli przy użyciu funkcji z biblioteki iostream, czy w oknie przy użyciu funkcji z biblioteki Qt!

Rozwiązaniem tego typu problemów jest użycie tzw. przestrzeni nazw (ang. namespace), które są czymś w rodzaju katalogów nazw. Wiersz kodu using namespace std; oznacza, że w dalszej części pliku z kodem źródłowym zamierzamy używać przestrzeni nazw o nazwie std. Przestrzeń ta jest jedną z najbardziej znanych, ponieważ należy do biblioteki standardowej języka C++. Biblioteka ta jest dostępna jako integralna część języka C++, a jednym z jej składników jest biblioteka iostream.

3.3.3. Funkcja int main()

W tym miejscu znajduje się główna część programu. Jak się wkrótce przekonasz, programy składają się przede wszystkim z funkcji. Każda funkcja ma jakieś określone zadanie do wykonania i może wywoływać inne funkcje, jeśli jest taka potrzeba.

Każdy program zawiera tzw. funkcję główną o nazwie main(), która jak sama nazwa wskazuje, jest najważniejszą funkcją w aplikacji.

W najprostszej formie wywołanie funkcji main() wygląda następująco:

int main()
{
}

Początek i koniec właściwej treści funkcji wyznaczają klamry. Jak widać w kodzie źródłowym, który wygenerowało dla środowisko Code::Blocks, za funkcją main() nic już nie ma. To normalne, ponieważ koniec tej funkcji oznacza również koniec wykonywania programu. Mówiąc krótko początek i koniec wykonywania aplikacji wyznaczają początek i koniec funkcji main().

Czy to oznacza, że cały program będzie zapisany w funkcji main()? Nie! Mimo iż byłoby to możliwe, to jednak zarządzanie kodem programu, który w całości jest zapisany w funkcji main() byłoby dla wielu programistów bardzo niewygodne. Dlatego zazwyczaj wewnątrz funkcji main() wywołuje się tylko inne funkcje, które z kolei mogą wywoływać jeszcze inne funkcje itd. Innymi słowy funkcja ta przekazuje zadania do wykonania innym funkcjom. Na początku tego kursu będziemy jednak pisać programy w całości mieszczące się w tej funkcji, ponieważ będą one na tyle proste, że nie sprawi nam to żadnego problemu.

3.3.4. Instrukcja cout

Dobrnęliśmy w końcu do pierwszej instrukcji, która robi coś konkretnego! Znajduje się ona w pierwszym wierszu kodu funkcji głównej, a więc określa pierwszą czynność, jaka zostanie wykonana dla nas przez komputer (cały dotychczasowy kod był zatem tylko przygotowaniem infrastruktury do właściwego działania).

cout << "Hello world!" << endl;

Instrukcja cout (wym. si aut) służy do wyświetlania napisów na ekranie. Z tego typu konstrukcji zbudowane będą nasze programy — z instrukcji do wykonania przez komputer.

Koniec instrukcji oznacza się średnikiem. Znak ten pozwala odróżnić instrukcje od innych elementów kodu źródłowego. Jeśli zapomnisz choćby jednego średnika, kompilacja programu nie powiedzie się i nie zostanie utworzony plik wykonywalny.

W omawianym wierszu kodu znajdują się trzy ważne elementy:

• instrukcja cout: polecenie wyświetlające napis na ekranie.
• łańcuch "Hello World": napis, który ma zostać wyświetlony.
• ciąg endl: ciąg znaków oznaczający przejście do nowego wiersza w konsoli.

Za pomocą jednej instrukcji można wyświetlić więcej niż jeden napis, np.:

cout << "Witajcie, szanowni czytelnicy!" << endl << "Jak się macie?"
<< endl;

Powyższa instrukcje spowoduje wyświetlenie w konsoli dwóch napisów w osobnych wierszach. Skompiluj ten kod, aby to sprawdzić.

W systemie Windows występują problemy z wyświetlaniem w konsoli znaków z „ogonkami”. Jest to wada samej konsoli tego systemu, która bardzo rzadko występuje w systemach Mac OS X i Linux. Usterkę tę można usunąć na kilka sposobów, ale żaden z nich nie jest w pełni satysfakcjonujący. Dlatego lepiej jest po prostu unikać stosowania znaków mających „ogonki”, kiedy pracuje się w konsoli w systemie Windows. Ponadto, w graficznych interfejsach użytkownika, które będziemy tworzyć przy użyciu biblioteki Qt problem ten nie występuje!

3.3.5. Instrukcja return

Ostatni wiersz kodu zawiera następującą instrukcję:

return 0;

Instrukcja tego rodzaju znajduje się na końcu większości funkcji i określa ich wartość zwrotną (np. liczbę). Funkcja, o której jest tutaj mowa zwraca wartość 0, która oznacza, że jej wykonywanie zakończyło się pomyślnie (wszystkie inne wartości oznaczają jakiś problem).

Tego kodu nie trzeba będzie modyfikować, a więc pozostawimy go bez zmian. Do instrukcji return wrócimy jeszcze, gdy będziemy jej używać w innych funkcjach.

3.4. Komentarze

Oprócz kodu stanowiącego instrukcje do wykonania przez komputer w programach powinno się także umieszczać specjalne komentarze objaśniające działanie programu dla ludzi.

Komentarze te nie mają żadnego wpływu na sposób działania programu. Kompilatory nie przetwarzają ich i usuwają je z kodu wynikowego programu. Są one jednak niezbędne dla programistów, ponieważ zawierają objaśnienie tego, co dany fragment kodu robi.

Gdy zaczniesz pisać nieco bardziej skomplikowane programy (a uwierz mi, to szybko nastąpi), to już po krótkim czasie będziesz mieć problemy ze zrozumieniem, o co chodzi w różnych częściach ich kodu. Nie wspominając już o innych programistach, którym pokażesz swój kod. Bardzo trudno jest rozszyfrować działanie programu patrząc tylko na jego kod źródłowy. Aby to ułatwić, pisze się właśnie komentarze!

3.4.1. Rodzaje komentarzy

W języku C++ wyróżnia się dwa rodzaje komentarzy, które różnią się między sobą długością.

3.4.1.1. Komentarze krótkie

Komentarz krótki, czyli taki, który w całości znajduje się w jednym wierszu rozpoczyna się znakami //. Wszystko, co znajduje się za nimi jest komentarzem, np.:

// To jest komentarz

Komentarz taki można także umieścić za kodem źródłowym w wierszu, aby objaśnić jego działanie, np.:

cout << "Hello world!" << endl; // Wyświetla napis na ekranie

3.4.1.2. Komentarze długie

Jeśli komentarz zajmuje więcej niż jeden wiersz, należy jego początek oznaczyć znakami /*, a koniec — znakami */, np.:

/* Ten fragment kodu jest dość skomplikowany,
dlatego postanowiłem objaśnić go nieco szerzej,
aby za kilka miesięcy nie mieć problemu z
jego zrozumieniem. */

Ogólnie rzecz biorąc komentarze powinny być zwięzłe i jak najkrótsze, chyba że sytuacja naprawdę wymaga trochę dłuższej wypowiedzi.

3.4.2. Pisz komentarze w swoim kodzie

Przepiszemy kod źródłowy programu, który omawialiśmy wcześniej i dodamy do niego komentarze, dzięki którym za kilka tygodni nie zapomnimy, co program ten dokładnie robi.

#include <iostream> // Dołączenie biblioteki iostream (do wyświetlania tekstu)
using namespace std; // Informujemy, jakiej przestrzeni nazw będziemy używać
/*
Funkcja główna main
Wykonywanie każdego programu zaczyna się od tej funkcji
*/
int main()
{
cout << "Hello world!" << endl; // Wyświetlenie napisu
return 0; // Zakończenie funkcji głównej i działania programu
}

Gdy skompilujesz i uruchomisz ten program, nie zauważysz w nim nic nowego w stosunku do poprzedniej wersji. Jak napisaliśmy, komentarze są przez kompilatory ignorowane.

W tym przykładzie napisaliśmy komentarz dla każdego wiersza kodu, ale w prawdziwych programach nie należy tego robić. Jeśli działanie fragmentu kodu jest oczywiste, to nie należy go komentować. Ponadto komentarzami opisuje się raczej całe fragmenty kodu źródłowego, a nie jego pojedyncze wiersze.

Napisałeś i uruchomiłeś swój pierwszy program. Gratulacje!

Umiesz już wyświetlić napis na ekranie, ale tak naprawdę to dopiero początek tego, czego nauczysz się w kolejnych rozdziałach. W następnym rozdziale dowiesz się, jak operować na pamięci.