|
Serwis Edukacyjny w I-LO w Tarnowie 
Materiały dla uczniów liceum |
Wyjście Spis treści Wstecz Dalej
Autor artykułu: mgr Jerzy Wałaszek |
©2024 mgr Jerzy Wałaszek
|
|
Serwis Edukacyjny w I-LO w Tarnowie
Materiały dla uczniów liceum |
Wyjście Spis treści Wstecz Dalej
Autor artykułu: mgr Jerzy Wałaszek |
©2024 mgr Jerzy Wałaszek
|
Język programowania (ang. programming language) umożliwia wydawanie poleceń komputerowi, które ten następnie wykonuje. W pierwszych komputerach stosowano binarne kody instrukcji, które bezpośrednio rozumie komputer. Procesor najpierw pobiera kod instrukcji, a następnie analizuje go i po rozpoznaniu wykonuje pożądaną operację. Na przykład, w jednym z pierwszych komputerów Konrada Zuse program był tworzony na taśmie filmowej w postaci dziurek, które odzwierciedlały binarną postać instrukcji. Zuze wybrał taśmę, ponieważ zawierała perforację (otwory z boku) do jej przesuwu w projektorze.
Dziurka/brak dziurki jest informacją bitową. Rząd takich dziurek tworzył słowo instrukcji binarnej. Komputer Konrada Zuse rozróżniał 16 instrukcji. Gdy liczba instrukcji maszyny cyfrowej rosła, a same instrukcje stawały się coraz bardziej skomplikowane, wymyślono język asemblera (ang. assembler language). Zamiast binarnych kodów instrukcji w języku asemblera stosuje się ich nazwy symboliczne (jak ADD, SUB, JMP). Dzięki temu łatwiej je zapamiętać, a i sam program staje się dużo prostszy.
| Asembler | Kod binarny | |
START: LDA #"Z LOOP: STA $INOUT DEC JMP #LOOP END |
0001010001011010
0010100000000000
1001000000000000
1010010000000010
0000000000000000
|
Procesor rozumie tylko i wyłącznie swój kod binarny. Dlatego tworząc programy w asemblerze musimy je kompilować, czyli zamieniać na postać binarną. Konwersji takiej dokonuje program, który również nazywamy asemblerem. Pierwszy program asemblera musiał jednak być napisany bezpośrednio w kodzie binarnym.
Asembler daje programiście dostęp do wszystkich składników komputera. Jednakże tworzenie programu jest bardzo żmudne, ponieważ każdą operację należy rozbijać na poszczególne instrukcje procesora. Np. sprawdzenie, czy komórki o etykietach L1 i L2 (etykieta to nazwa obszaru pamięci, w którym jest jakaś informacja, np. liczba lub instrukcja do wykonania - dzięki etykietom programista nie musiał podawać adresów liczbowych) są sobie równe, wymaga kilku instrukcji procesora:
| Asembler |
LDA $L1 ; pobierz komórkę L1 SUB $L2 ; odejmij od niej komórkę L2 JZR #ROWNE ; jeśli wynik zero, skocz do ROWNE ... ; jeśli nie, jesteś tutaj |
Czyż nie byłoby lepiej zapisać tak?:
| Jakiś język programowania |
JEŚLI L1 = L2, TO ... INACZEJ ... |
I tak dochodzimy do koncepcji języków wysokiego poziomu – HLL (ang. High Level Language). Asembler, a tym bardziej kod binarny instrukcji procesora, to języki niskiego poziomu – LLL (ang. Low Level Language), które operują bezpośrednio na zasobach komputera: na procesorze, pamięci, rejestrach wejścia/wyjścia. Aby w nich efektywnie programować, programista musi posiadać dużą wiedzę na temat budowy komputera oraz urządzeń towarzyszących. Również musi dokładnie wiedzieć, w jaki sposób realizować złożone polecenia. Pomyłki w kodzie są trudne do wyłapania. Wszystko to powoduje, że chociaż asembler jest bardzo potężnym narzędziem, to jednak jest również bardzo trudny w opanowaniu i mało efektywny przy dużych projektach. Dzisiaj w asemblerze tworzone są tylko fragmenty programów, które muszą być naprawdę szybkie i efektywne.
Język wysokiego poziomu oddala się od sprzętu komputera i pozwala tworzyć bardziej abstrakcyjne konstrukcje, które zbliżone są do pojęć matematycznych. Dzięki temu programista może dużo szybciej pisać złożone programy, niż jest to możliwe w asemblerze. Wszystkie języki wysokiego poziomu muszą być przetwarzane na postać binarną (nie dotyczy to języków interpretowanych, tzw. skryptowych, np. PYTHON, o których dowiemy się później). Konwersję taką wykonuje program zwany kompilatorem (ang. compiler).
Pierwsze języki wysokiego poziomu zaczęły się pojawiać po II Wojnie Światowej. Wcześniej stosowano kody binarne oraz asemblery. Poniżej podajemy chronologiczną listę najważniejszych języków programowania (niech cię nie przeraża ich liczba):
Bjarne Stroustrup
– twórca C++
Język C++ jest językiem programowania stworzonym przez Bjarne Stroustrupa, profesora Texas A&M University. Jest to język wysokiego poziomu i należy do grupy języków kompilowanych. Oznacza to, iż programista w edytorze tworzy tekst programu, który następnie jest przekazywany do kompilatora. Kompilator analizuje otrzymany tekst i na jego podstawie tworzy program wynikowy zawierający binarne instrukcje dla procesora.
| edytor | kompilator | system | ||
|
tworzenie tekstu programu |
→ |
kompilacja tekstu na język maszynowy |
→ |
uruchomienie programu wynikowego |
Języki wysokiego poziomu są bardziej czytelne dla ludzi. Jednakże procesor komputera nie potrafi bezpośrednio wykonywać zawartych w takim programie poleceń - program musi być przetłumaczony do postaci zrozumiałej dla procesora, czyli do binarnych kodów instrukcji maszynowych. Takie instrukcje są umieszczane w pliku wykonywalnym (w systemie Windows pliki wykonywalne posiadają rozszerzenie EXE od angielskiego słowa executable).
Język C++ powstał jako rozwinięcie poprzedniego języka C, który był bardzo popularny w latach 80-tych ubiegłego wieku. Program napisany w języku C da się bez większych problemów uruchomić w środowisku C++, jednak w drugą stronę to już zwykle nie zadziała, ponieważ C++ posiada wiele nowych rozwiązań, których brak w C.
Do programowania w języku C++ będziemy używali zintegrowanego środowiska programowania (ang. IDE - Integrated Developement Environment), które zawiera edytor oraz kompilator. Na lekcjach oprzemy się o darmowe środowisko Code::Blocks, które można pobrać z sieci Internet. Sposób instalacji jest dokładnie opisany w naszym serwisie:
Możesz też oprzeć się o inne środowisko, które dobrze znasz, np. Microsoft Visual Studio. Jednak wtedy będziesz musiał samodzielnie przystosować nasze programy do swojego IDE (nie jest to specjalnie trudne, ale jeśli coś ci nie zadziała, to nie miej pretensji do nas).
Załóż przy jego pomocy katalog roboczy na wybranym dysku. Ja założyłem katalog "lekcje" bezpośrednio na dysku C:
W ten sposób projekty będą w jednym miejscu. Dodatkowo projekty będziemy nazywali 3-cyfrowymi numerami: 000, 001... Oczywiście ty możesz zrobić wg własnego uznania, lecz staraj się trzymać pliki i tworzone katalogi w jednym miejscu na dysku.
|
Jeśli pracujesz w systemie Linux (nauka informatyki nie zależy od używanego systemu operacyjnego, ale narzędzia tak. Code::Blocks w Linuxie pracuje identycznie jak w Windows), to postępujesz podobnie. Uruchom Menadżera Plików:
i w katalogu domowym (w Linuxie nie ma dysków jako takich, wszystkie zasoby są katalogami w katalogu głównym), utwórz katalog na projekty (u mnie katalog ten nazywa się lekcje). |
Zanim uruchomimy Code::Blocks, podamy kilka słów wyjaśnienia na temat konsoli (ang. console). Pierwsze komputery IBM-PC (ang. Internatioal Business Machines - Personal Computer) pracowały w trybie znakowym.
Tryb znakowy pozwalał wyświetlać na ekranie monitora literki o ustalonych kształtach. Takie rozwiązanie było wtedy ekonomiczne, gdyż grafika wymagała szybszych procesorów oraz większej pamięci, a te były bardzo drogie (o kolorze już nie wspomnę...). Tryb znakowy służył do wyświetlania tekstów oraz tzw. grafiki znakowej (tabelki, proste kształty zakodowane w zestawie znaków, itp.). Było to wystarczające do pracy biurowej: pisanie listów, sprawozdań, wykonywanie obliczeń, nawet Internet początkowo był przeglądany znakowo. Tekst był wyświetlany na ekranie monitora zwykle w 25...50 wierszach, w każdym po 80 znaków. Obraz wyglądał następująco:
Tryb konsoli oznacza właśnie pracę w takim prostym środowisku tekstowym. Program będzie wyświetlał literki oraz odczytywał znaki, które użytkownik wprowadzi z klawiatury. Programy dla konsoli znakowej są łatwiejsze do napisania od programów graficznych, dlatego ten tryb pracy jest wybierany przy nauce programowania. W środowisku Windows tryb konsoli powoduje wyświetlenie specjalnego okna tekstowego, w którym program pracuje. Okno to nazywamy oknem konsoli znakowej (ang. character console). W środowisku Linux okno nosi nazwę okna terminala. W oryginalnym trybie znakowym literki widoczne na ekranie monitora były tworzone sprzętowo, obecnie okno konsoli jest rysowane graficznie. Klawisze Lewy Alt+Enter włączają/wyłączają tryb pełnoekranowy.
Uruchom Code::Blocks. Gdy pojawi się okno startowe, wybierz opcję Create a new project (Utwórz jakiś nowy projekt).
Spowoduje to uruchomienie kreatora projektu (ang. Project Wizzard). Kreator jest procedurą, która zbiera od użytkownika potrzebne dane i na ich podstawie tworzy odpowiedni projekt. Na początku kreator wyświetli okno:
W oknie wybieramy typ projektu: Console application, czyli aplikacja pracująca w oknie konsoli. Do następnego okna przechodzimy po kliknięciu przycisku Go (dalej).
Kolejne okno pozwala ci wybrać język programowania dla twojego projektu: C lub C++:
Wybierasz oczywiście C++ (Code::Blocks zapamiętuje twoje wybory na przyszłość). Klikasz w przycisk Next.
Trzecie okno dialogowe kreatora projektu jest bardzo ważne:
W polu Project title (nazwa projektu) wpisz 001, czyli projekt pierwszy. Ja stosuję trzy cyfry w takich nazwach, aby były one później ładnie uporządkowane w katalogu, co ułatwia szybkie wyszukiwanie projektów. W polu Folder to create project in (katalog do utworzenia w nim projektu) powinna się znaleźć ścieżka dostępu do katalogu, który wcześniej utworzyliśmy na dysku C:
W Linuxie będzie to katalog /home/użytkownik/lekcje:
Jeśli w polu tym masz inny katalog, to kliknij przycisk po prawej stronie pola i wybierz katalog lekcje (lub ten, który sobie przygotowałeś).
Pozostałych dwóch pól nie zmieniaj, chyba że bardzo musisz:
Project filename – nazwa pliku projektu. Rozszerzenie cbp oznacza Code::Blocks Project.
Resulting filename – wynikowa nazwa pliku.
Kliknij Next.
Ostatnie okno dialogowe kreatora pozwala wybrać dostępne konfiguracje dla projektu:
Nie wnikając w szczegóły, są dostępne dwie konfiguracje:
Na tym etapie to nie jest ważne, zatem nic w tym oknie nie zmieniaj, kliknij przycisk Finish.
Kreator zebrał wszystkie potrzebne mu informacje i utworzy teraz dla ciebie projekt 001. Dostęp do tego projektu masz w panelu Management (zarządzanie):
Jeśli nie widzisz tego panelu, naciśnij klawisze Shift+F2.
Otwórz gałąź Sources (źródła):
Wewnątrz znajdziesz plik main.cpp. Jest to główny plik tekstu programu w języku C++ (main = główny, cpp = C plus plus, czyli C++). Plik otwierasz w edytorze przez podwójne kliknięcie go lewym przyciskiem myszki.
Kreator tworzy prosty plik programu z szablonu:
#include <iostream>
using namespace std;
int main()
{
cout << "Hello world!" << endl;
return 0;
}
|
Jeśli chcesz uruchomić ten program, musisz go najpierw skompilować, czyli utworzyć binarne instrukcje dla procesora. Naciśnij klawisz F9 (kompilacja + uruchomienie programu, jeśli nie było błędów w programie). Pojawi się okienko konsoli znakowej z napisami
Hello world! Process returned 0 (0x0) execution time : 0.094 s Press any key to continue.
Po polsku:
Cześć świecie! Proces zwrócił kod 0 (0x0) czas wykonania : 0,094 sek Naciśnij dowolny klawisz, aby kontynuować.
Pierwszy wiersz jest efektem pracy programu. Dwa ostatnie wiersze pochodzą od Code::Blocks i nie są wyświetlane, jeśli program zostanie uruchomiony z poziomu systemu operacyjnego.
Naciśnij jakiś klawisz. Okno konsoli zostanie zamknięte i wrócisz z powrotem do edytora programu.
Gdy program został raz poprawnie skompilowany, można go wielokrotnie uruchamiać klawiszami Ctrl+F10 lub przez kliknięcie w zieloną strzałkę na pasku narzędziowym u góry ekranu.
Po powrocie do edytora, spójrz na dolny panel Logs & other (logi i inne). Jeśli nie widzisz tego panelu, naciśnij klawisz F2. Wybierz zakładkę Build log. Zobaczysz polecenia oraz odpowiedzi programów środowiska Code::Blocks, które zostały użyte do kompilacji programu C++ w edytorze. Nie przejmuj się, jeśli nic z tego nie rozumiesz, z czasem to się zmieni. Najważniejszy jest ostatni wiersz. Jeśli jest niebieski, to wszystko w porządku.
Naciśnij Cntr+F10, aby uruchomić program ponownie. Teraz nie naciskaj klawisza, tylko zamknij okno konsoli x-em na pasku tytułowym. Ponieważ nie jest to normalne zakończenie, to w oknie Build log ostatni wiersz będzie czerwony:
Executing: "C:\Program Files\CodeBlocks/cb_console_runner.exe" "C:\lekcje\001\bin\Debug\001.exe" (in C:\lekcje\001\.) Process terminated with status -1073741510 (0 minute(s), 4 second(s))\ Wykonywanie: "C:\Program Files\CodeBlocks/cb_console_runner.exe" "C:\lekcje\001\bin\Debug\001.exe" (w C:\lekcje\001\.) Proces zakończony ze stanem -1073741510 (0 minut, 4 sekundy)
Program po kompilacji może być uruchamiany z poziomu systemu. Jak to zrobić? Przede wszystkim musisz wiedzieć, gdzie ten program został umieszczony na dysku.
W systemie Windows uruchamiamy okno konsoli (jest wiele sposobów, ja podam tylko jeden):
Naciśnij klawisze Window + R (klawisz Window to ten z okienkiem po lewej stronie w dolnym rzędzie klawiatury).
W polu Otwórz: wpisz nazwę cmd (pochodzi od słowa command, czyli polecenie, cmd jest aplikacją systemową, interpreterem poleceń, który pracuje w oknie konsoli i pozwala użytkownikowi wpisywać różne polecenia słowne). Po wpisaniu nazwy cmd wciśnij klawisz Enter. Pojawi się okno konsoli:
Komputer czeka na twoje polecenie. Wpisz (ścieżkę możesz sobie skopiować z okna Build log w Code::Blocks):
C:\lekcje\001\bin\Debug\001.exe
Twój program zostanie uruchomiony, pojawi się napis Hello world!, program zakończy działanie i nastąpi powrót do interpretera poleceń. Jeśli chcesz uruchomić swój program ponownie, naciśnij strzałkę do góry, co przywoła ostatnie polecenie, i wciśnij Enter.
Zwróć uwagę na ścieżkę dostępu do twojego programu:
Zatem ścieżka dostępu do twojego programu jest następująca:
Dysk:/katalog_projektów/projekt/bin/Debug/projekt.exe
W systemie Linux:
Skompiluj i uruchom program, po czym skopiuj ścieżkę dostępu do pliku wykonywalnego z okna Build log do schowka (clipboard).
Uruchom terminal przez naciśnięcie klawiszy: Ctrl + Lewy Alt + T.
Wklej do terminala skopiowaną ścieżką i wciśnij Enter.
W systemie Linuks ścieżka dostępu do pliku jest następująca:
/home/użytkownik/katalog_projektów/projekt/bin/Debug/projekt
Przejdź do edytora (kliknij lewym przyciskiem myszki w okno edytora). Czcionkę w edytorze możesz powiększać lub pomniejszać. Wciśnij i przytrzymaj klawisz Ctrl, po czym pokręć kółkiem myszki. Dobierz taką wielkość czcionki, aby tekst był dobrze widoczny.
Naciśnij klawisze Ctrl+A (wybór całego tekstu w edytorze), a następnie klawisz Del (usunięcie zaznaczonego tekstu). Okno edytora powinno być puste. Programowania najlepiej jest się uczyć wpisując cały program samemu.
Program w języku C++ zbudowany jest z funkcji. Wykonanie programu rozpoczyna się od funkcji głównej (main). Funkcje dokładnie omówimy później. Funkcja wymaga odpowiedniej definicji. Wpisz w edytorze tekst:
int main()
{
return 0;
}
|
Skompiluj ten program i uruchom. Co on robi? Niewiele. To chyba najprostszy program w języku C++. Gdy zostanie uruchomiony, instrukcja return w funkcji main( ) kończy działanie programu zwracając wpisana za nią liczbę, czyli 0.
Wyjaśnijmy elementy tego programu. Widzimy tutaj kilka angielskich słów (język C++ powstał w sferze anglojęzycznej i stosuje nazwy angielskie, lecz nie jest ich dużo).
int jest skrótem słowa integer (czytaj inidżer), które oznacza wartość całkowitą. Określa tutaj rodzaj informacji zwracanej przez funkcję. Funkcja jest fragmentem kodu, który coś robi, a następnie zwraca wynik. int informuje kompilator (program analizujący tekst programu i tworzący na jego podstawie kod wykonywalny, który rozumie procesor komputera), że definiowana funkcja będzie zwracała w wyniku liczbę całkowitą.
main jest nazwą naszej funkcji. Do kodu funkcji program odwołuje się poprzez jej nazwę. Dokładnie omówimy to w dalszej części kursu. Nazwa main jest unikalna i oznacza funkcję główną, od której rozpoczyna się wykonywanie programu. Funkcja główna musi występować w każdym programie C++. Język C++ rozróżnia w nazwach litery małe i duże, zatem nazwa Main jest różna od nazwy main – pamiętaj o tym.
( ) za nazwą funkcji muszą wystąpić nawiasy. W nawiasach tych możemy zdefiniować tzw. parametry, czyli informację, którą przekazujemy do funkcji. Nasza funkcja main( ) nie posiada tutaj parametrów, zatem nawiasy są puste, ale nie wolno ich pominąć, ponieważ informują one kompilator, iż main( ) jest funkcją.
{ } w klamerkach umieszczamy kod funkcji, czyli polecenia, które będą wykonane w ramach funkcji.
return 0; to jest jedyne polecenie w naszej funkcji. Gdy komputer napotka return, kończy wykonywanie kodu funkcji (nawet, jeśli za return umieścisz inne polecenia). Jeśli funkcja ma zwracać wartość, to za return umieszczamy ją. Jeśli return jest w funkcji głównej, to zakończy wykonywanie programu, a wartość za return zostanie zwrócona do systemu (tutaj do Code::Blocks). Wartość 0 jest standardowa i oznacza: wszystko OK. Inne wartości mogą być wykorzystane przez programistę do przekazania jakiejś informacji (najczęściej o błędzie).
Zwróć uwagę na średnik (;). Znak ten oznacza koniec instrukcji. Kompilator analizuje tekst programu C++ wiersz po wierszu z góry na dół i od lewej do prawej. Nie rozpoznaje końca wierszy i zakończenie wiersza nie kończy instrukcji, musi być średnik. Dla eksperymentu wpisz taki program:
int main(){return 0;}
|
Po prostu wszystko jest w jednym wierszu. To też jest poprawny zapis, ale mało czytelny dla ludzi, dlatego programiści wprowadzili pewne zasady pisania programów. Na razie naśladuj to, co widzisz. Po pewnym czasie zrozumiesz te zasady, teraz nie będę cię nimi zanudzał.
Zmień wartość zwracaną przez funkcję main( ) z 0 na np. 255:
int main()
{
return 255;
}
|
Skompiluj i uruchom program (każda zmiana w programie wymaga ponownej kompilacji, inaczej uruchomisz starą wersję programu). Zwróć uwagę na dwa ostatnie wiersze tekstu w oknie konsoli:
Process returned 255 (0xFF) execution time : 0.037 s Press any key to continue.
Tekst ten jest wypisywany przez Code::Blocks (przy uruchomieniu programu z poziomu systemu nie pojawi się). W pierwszym wierszu na początku jest informacja o zwracanej przez program wartości.
Również po powrocie do Code::Blocks w okienku Logs & others w ostatnim wierszu wyświetlanym na czerwono jest informacja o wartości zwróconej przy zakończeniu funkcji głównej.
main( ) Komentarz wierszowy rozpoczyna się od znaków // i obowiązuje do końca wiersza. Ustaw kursor na początku pierwszego wiersza, wciśnij klawisz Enter, a następnie strzałkę w górę. Spowoduje to wstawienie do tekstu programu pustego wiersza na samym początku. Zwróć uwagę, iż obok numeru wiersza pojawiła się żółta kreska:
W ten sposób Edytor pokazuje ci wiersze, które zostały zmienione w programie od ostatniej kompilacji.
Masz pusty wiersz, wpisujesz zatem komentarz, np. taki:
Po wpisaniu komentarza naciśnij klawisz Enter. Pod komentarzem zostanie wstawiony nowy pusty wiersz. Możemy zatem kontynuować wstawianie komentarzy:
// Program 001
//--------------
int main()
{
return 0;
}
|
Komentarze nie są wstawiane do programu exe, ponieważ mikroprocesor ich nie potrzebuje.
Zmień w instrukcji return zwracaną wartość na 0, aby nie denerwować systemu. 0 oznacza: jest dobrze :).
Chciałbyś teraz zapewne wyświetlić jakiś tekst w oknie konsoli. Tutaj pojawia się pierwsza trudność dla początkujących: język C++ nie posiada wbudowanej instrukcji wykonującej takie operacje (w innych językach takie instrukcje istnieją). Czy to źle, czy dobrze? Musisz sam ocenić w późniejszym czasie.
Dostęp do konsoli uzyskuje się za pomocą tzw. strumienia (ang. stream). Strumień jest zaprogramowanym obiektem, do którego wstawiamy informację, a on przesyła tę informację w określone miejsce (do okna konsoli, do pliku na dysku, do pamięci komputera...). Strumień wyświetlający informację w oknie konsoli nazywa się std::cout. (ang. console output). Słówko std to tzw. przestrzeń nazw (ang. namespace, std = standard, później wyjaśnimy to pojęcie). Strumień cout jest zdefiniowany wewnątrz przestrzeni std, o czym informuje podwójny dwukropek (to tzw. operator zakresu, ang. scope operator). Aby twój program mógł korzystać ze strumienia cout, musisz dołączyć do swojego programu plik nagłówkowy (ang. header file), w którym programiści zdefiniowali ten strumień. Pliki nagłówkowe wymyślono dosyć dawno. Chodzi tutaj o to, aby programista nie musiał w każdym nowym programie definiować wszystkiego od początku. Często używane definicje umieszcza się w pliku nagłówkowym, który dołącza się do programu. W naszym przypadku plik ten nazywa się iostream (strumień wejścia/wyjścia). Plik dołączamy dyrektywą:
#include <iostream>
Tuż przed kompilacją dyrektywa #include zastępuje ten
wiersz zawartością pliku iostream tak, jakby ta zawartość była wpisana do
naszego programu. Nawiasy trójkątne < > oznaczają, iż plik iostream
należy pobrać z wewnętrznego katalogu aplikacji Code::Blocks, a nie z katalogu projektowego
(bo go tam nie ma). Na razie nie zaprzątaj sobie tym
głowy. Zatem wstawiamy do naszego programu plik nagłówkowy definicji strumienia
wejścia/wyjścia:
// Program 001
//--------------
#include <iostream>
int main()
{
return 0;
}
|
Teraz możemy wypisać jakiś tekst w oknie konsoli (pamiętaj o średniku na końcu instrukcji):
// Program 001
//--------------
#include <iostream>
int main()
{
std::cout << "Witaj w C++";
return 0;
}
|
Co tutaj się dzieje? Otóż program ten pokazuje sposób wykorzystania strumienia:
std |
– | przestrzeń nazw, w której znajduje się strumień. |
:: |
– | operator zasięgu, który określa, iż element po jego prawej stronie jest w zasięgu przestrzeni nazw std. |
cout |
– | strumień wyjścia na konsolę: console output. |
<< |
– | operator przesłania do strumienia, musi być przed każdym elementem, który trafi do strumienia. Przypomina strzałkę i jakby wskazuje kierunek przesyłania informacji. |
"..." |
– | tekst w języku C++ umieszczamy w cudzysłowach. |
; |
– | koniec instrukcji przesłania do strumienia. |
Zwróć uwagę na odstępy elementów w klamerkach (ja stosuję 4 spacje). Dzięki nim program staje się bardziej przejrzysty. Staraj się powtarzać ten styl pisania programów. Dzięki temu program staje się bardziej czytelny i łatwiejszy do analizy. Umówmy się również na przyszłość, że klamerka otwierająca { i zamykająca } są w tej samej kolumnie.
Skompiluj i uruchom ten program. Wynik powinien wyglądać tak:
Witaj w C++ Process returned 0 (0x0) execution time : 0.190 s Press any key to continue.
// Program 001
//--------------
#include <iostream>
int main()
{
std::cout << "Witaj w C++";
std::cout << "-----------";
return 0;
}
|
Skompiluj i uruchom program (klawisz F9). Co otrzymałeś?
Witaj w C++----------- Process returned 0 (0x0) execution time : 0.068 s Press any key to continue.
Nasze piękne minusy nie zostały wyświetlone w nowym wierszu. Otóż strumień
reaguje tylko na to, co otrzymał, a nie na to jak to sobie ułożyłeś w edytorze.
W naszym przypadku strumień otrzymał dwa teksty: "Witaj
w C++" oraz "-----------".
W strumieniu zostały one połączone w jeden tekst:
i taki tekst trafił do
okna konsoli.
Jeśli chcesz, aby minusy były wyświetlone w nowym wierszu, musisz poinformować strumień, iż należy zakończyć wiersz po pierwszym tekście. Uzyskamy to przesyłając do strumienia tzw. manipulator std::endl. Manipulator jest specjalną funkcją, która manipuluje strumieniem. Manipulator std::endl oznacza end line (koniec wiersza). Powoduje on zakończenie tekstu w wierszu, zatem następny tekst pojawi się w nowym wierszu. Zmodyfikujmy program:
// Program 001
//--------------
#include <iostream>
int main()
{
std::cout << "Witaj w C++";
std::cout << std::endl; // Koniec wiersza
std::cout << "-----------";
return 0;
}
|
Skompiluj i uruchom go:
Witaj w C++ ----------- Process returned 0 (0x0) execution time : 0.061 s Press any key to continue.
Do strumienia możemy przesyłać po kolei wiele elementów, co znacznie upraszcza programowanie. Musisz jedynie pamiętać, aby każdy element poprzedzać operatorem <<.
// Program 001
//--------------
#include <iostream>
int main()
{
std::cout << "Witaj w C++" << std::endl << "-----------";
return 0;
}
|
Jeśli instrukcja jest zbyt długa, to zawsze możesz ją podzielić na wiele wierszy w dogodny dla siebie sposób – instrukcję kończy średnik, a nie koniec wiersza:
// Program 001
//--------------
#include <iostream>
int main()
{
std::cout << "Witaj w C++" << std::endl
<< "-----------"; // Kontynuacja
return 0;
}
|
Kolejną rzeczą jest przestrzeń nazw std. Wprowadzono ją po to, aby nazwy języka C++ nie kolidowały z nazwami języka C, ponieważ w założeniu programy języka C miały być bezpośrednio uruchamiane w środowisku C++. Jednakże ciągłe wpisywanie std i operatora zakresu :: jest męczące w programie C++, dlatego istnieje specjalna dyrektywa:
using namespace std;
informująca kompilator, aby szukał nazw w tej przestrzeni. Gdy ją umieścisz na początku swojego programu, nie będziesz musiał używać std::.
// Program 001
//--------------
#include <iostream>
using namespace std;
int main()
{
cout << "Witaj w C++" << endl
<< "-----------" << endl << endl
<< "PROGRAMOWANIE JEST PROSTE"
<< "*************************"
<< endl << endl; // Tutaj koniec
return 0;
}
|
Efekt:
Witaj w C++ ----------- PROGRAMOWANIE JEST PROSTE *************************
Ten podrozdział dotyczy systemu Windows, w Linuksie problem nie występuje.
Załóżmy, że chciałbyś się ładnie przywitać w języku polskim, a później wypisać coś mądrego. Zmień w edytorze program na następujący:
// Program 001
//--------------
#include <iostream>
using namespace std;
int main()
{
cout << "Witaj w języku C++" << endl
<< "------------------" << endl << endl
<< "O książę, zażółć gęślą jaźń!" // Wszystkie polskie litery
<< "============================"
<< endl << endl;
return 0;
}
|
W wyniku otrzymasz:
Witaj w jŕzyku C++ ------------------ O ksi╣┐ŕ, za┐ˇ│Š gŕťl╣ jač˝! ============================
Co tutaj się stało? Z pierwszej lekcji wiesz (wiesz,
prawda?), że znaki są kodowane za pomocą słów dwójkowych, które tworzą
kod znakowy. Literki łacińskie mają ogólnie przyjęte kody, natomiast polskie
literki były kodowane różnymi liczbami. W dawnym systemie DOS
(ang. Disk Operating System = dyskowy system operacyjny)
polskie litery kodowano wg standardu LATIN2. Jednakże system Windows
przyjął inny standard dla kodów polskich literek: WINDOWS 1250. W efekcie np.
kod literki ą w standardzie Windows staje się znaqkiem ╣ w
standardzie LATIN2. Co z tym zrobić? Jest kilka rozwiązań. Najprostszym z
nich jest przestawienie konsoli na ten sam sposób kodowania, który wykorzystuje
Windows. Najprostszy nie znaczy najlepszy, ale na początek wystarczy. Aby
ustawić w konsoli system kodowania Windows, wykorzystamy funkcję setlocale( ).
Funkcja ta wymaga dwóch parametrów: stałej (co to jest
stała, dowiesz się później) o nazwie LC_ALL oraz pustego tekstu,
czyli dwóch znaków cudzysłowu "". Znaczenia tych parametrów nie będziemy
tu omawiać. Funkcję setlocale( ) należy umieścić na początku kodu w
funkcji main( ) i wystarczy to zrobić jeden raz. Zmodyfikuj program:
// Program 001
//--------------
#include <iostream>
using namespace std;
int main()
{
setlocale(LC_ALL,""); // Konsola w tryb Windows 1250
cout << "Witaj w języku C++" << endl
<< "------------------" << endl << endl
<< "O książę, zażółć gęślą jaźń!" // Wszystkie polskie litery
<< "============================"
<< endl << endl;
return 0;
}
|
Skompiluj i uruchom program (klawisz F9). Teraz otrzymasz:
Na dzisiaj to wszystko, zapraszam do kolejnej lekcji.
 |
Zespół Przedmiotowy Chemii-Fizyki-Informatyki w I Liceum Ogólnokształcącym im. Kazimierza Brodzińskiego w Tarnowie ul. Piłsudskiego 4 ©2024 mgr Jerzy Wałaszek |
Materiały tylko do użytku dydaktycznego. Ich kopiowanie i powielanie jest dozwolone
pod warunkiem podania źródła oraz niepobierania za to pieniędzy.
Pytania proszę przesyłać na adres email:
Serwis wykorzystuje pliki cookies. Jeśli nie chcesz ich otrzymywać, zablokuj je w swojej przeglądarce.
Informacje dodatkowe.