Informatyka dla klas II

Taśma filmowa z kodem programu

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.

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 asembler 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 są sobie równe, wymaga kilku instrukcji procesora:

LDA $L1    ; załaduj do akumulatora komórkę L1
SUB $L2    ; odejmij od niej komórkę L2
JZR #ROWNE ; jeśli są równe, skocz
...        ; jeśli są różne, jesteś tutaj

Czyż nie byłoby lepiej zapisać:

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 tworzyć 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, 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):

• 1952 - Autokod
• 1954 - IPL (poprzednik języka LISP)
• 1955 - FLOW-MATIC (poprzednik języka COBOL)
• 1957 - FORTRAN (pierwszy kompilator)
• 1957 - COMTRAN (poprzednik języka COBOL)
• 1958 - LISP
• 1958 - ALGOL 58
• 1959 - FACT (poprzednik języka COBOL)
• 1959 - COBOL
• 1959 - RPG
• 1962 - APL
• 1962 - Simula
• 1962 - SNOBOL
• 1963 - CPL (poprzednik języka C)
• 1964 - BASIC
• 1964 - PL/I
• 1966 - JOSS
• 1967 - BCPL (poprzednik języka C)
• 1968 - Logo
• 1969 - B (poprzednik języka C)
• 1970 - Pascal
• 1970 - Forth
• 1972 - C
• 1972 - Smalltalk
• 1972 - Prolog
• 1973 - ML
• 1975 - Scheme
• 1978 - SQL (początkowo jedynie język zapytań do bazy danych, później rozbudowany o instrukcje programowania)
• 1980 - C++ (jako C z klasami, nazwa zmieniona w lipcu 1983)
• 1983 - Ada
• 1984 - Common Lisp
• 1984 - MATLAB
• 1985 - Eiffel
• 1986 - Objective-C, kurs Objective-C
• 1986 - Erlang
• 1987 - Perl
• 1988 - Tcl
• 1988 - Mathematica
• 1989 - FL (Backus);
• 1990 - Haskell
• 1991 - Python
• 1991 - Visual Basic
• 1993 - Ruby
• 1993 - Lua
• 1994 - CLOS (część języka ANSI Common Lisp)
• 1995 - Java
• 1995 - Delphi (Object Pascal)
• 1995 - JavaScript
• 1995 - PHP
• 1996 - WebDNA
• 1997 - Rebol
• 1999 - D
• 2000 - ActionScript
• 2001 - C#
• 2001 - Visual Basic .NET
• 2002 - F#
• 2003 - Groovy
• 2003 - Scala
• 2007 - Clojure
• 2009 - Go
• 2011 - Dart

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.

Języki wysokiego poziomu są bardziej czytelne dla ludzi. Jednakże procesor 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.

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 13.12, które można pobrać z sieci Internet. Na komputerze domowym ucznia musi być bezwzględnie zainstalowane podane środowisko programowania, aby mógł wykonywać ćwiczenia w domu.

W katalogu domowym uczen klikamy prawym przyciskiem myszki w puste pole i z menu kontekstowego wybieramy opcję Utwórz nowy... Katalog.

W okienku dialogowym, które się ukaże, wpisujemy nazwę katalogu 2k1 lub 2k2 w zależności od numeru grupy.

Będzie to katalog roboczy na projekty klasowe. Gdy klikniesz OK, w katalogu domowym uczen pojawi się nowy katalog.

Uruchamiamy środowisko Code::Blocks. Na ekranie monitora zobaczymy następujące okno:

Z dostępnych opcji startowych wybieramy Create a new project (Utwórz nowy projekt). Teraz pojawi się okno dialogowe wyboru typu projektu:

Zaznaczamy tutaj opcję Console application (aplikacja konsoli). Projekt aplikacji konsoli pozwoli nam utworzyć tzw. program konsolowy, czyli program pracujący w środowisku tekstowym. Jest to najprostsze środowisko programowania, ponieważ nie musimy w nim obsługiwać w programie współpracy z systemem okienkowym. Wszyscy uczący się programowania zwykle zaczynają od konsoli.

Gdy wybierzesz rodzaj tworzonej aplikacji, kliknij myszką przycisk Go. Okienko wyboru rodzaju projektu zostanie zastąpione nowym oknem dialogowym:

Jest to okienko powitalne, które informuje o tym, że właśnie uruchomiłeś kreatora tworzenia aplikacji konsoli. Jeśli zaznaczysz dostępną w nim opcję, to następnym razem okno się nie pojawi. Kliknij przycisk Next.

Tutaj upewnij się tylko, czy jest wybrana opcja C++ i kliknij przycisk Next. Kolejne okienko dialogowe jest bardzo ważne, więc omówimy je szczegółowo:

W polu tekstowym Project title (nazwa projektu) wpisz swoją nazwę projektu. Proponuję numerować projekty kolejno p01, p02, itd. Nazwa projektu stanie się nazwą katalogu z projektem oraz nazwą programu wynikowego.

W polu Folder to create project in (Katalog na projekt) określasz miejsce, gdzie ma się znaleźć katalog z projektem. Wpisz tam ścieżkę dostępu do katalogu, który utworzyliśmy przed chwilą. Jeśli nie pamiętasz nazwy tej ścieżki, to kliknij przycisk z trzema kropkami i wybierz katalog 2k1 lub 2k2 w katalogu domowym uczen.

Pole Project filename (Nazwa pliku projektu) służy do określania nazwy pliku, w którym Code::Blocks będzie przechowywało informacje o twoim projekcie. Jeśli w pierwszym polu określiłeś nazwę projektu, to nie zmieniaj zawartości tego pola.

Ostatnie pole Resulting filename (Wynikowa nazwa pliku) jest polem podsumowującym. Nie zmieniaj jego zawartości.

Gdy określisz nazwę i położenie swojego projektu na dysku, kliknij w przycisk Next. Na ekranie pojawi się ostatnie okno dialogowe:

Tutaj nie powinieneś nic zmieniać. Okno to służy do wyboru kompilatora oraz opcji konfiguracyjnych. Kliknij w przycisk Finish. Na ekranie pojawi się okno środowiska Code::Blocks. W lewym panelu otwórz sekcję Sources (źródła), a następnie kliknij dwukrotnie w plik main.cpp. Plik zostanie załadowany z dysku i wyświetlony w oknie edytora.

Ponieważ rozpoczynasz naukę języka C++, usuń wszystko z edytora i wprowadź poniższy kod.

int main()
{

}

Program w języku C++ zbudowany jest z tzw. funkcji, czyli fragmentów kodu, które można wielokrotnie używać. Najprostszy program posiada tylko jedną funkcję, która nosi nazwę main (główna). Nazwa ta musi być pisana małymi literami, ponieważ język C++ rozróżnia duże i małe litery. Wykonanie programu w języku C++ zawsze rozpoczyna się od kodu w funkcji main, dlatego jest to główna funkcja programu.

Powyższy program zawiera pustą funkcję main, czyli po prostu nic nie robi, lecz można go skompilować i uruchomić, a o to nam w tym momencie chodzi.

Aby skompilować program (czyli utworzyć na dysku plik programu z rozszerzeniem exe), kliknij myszką na ikonę (na pasku narzędziowym u góry okna):

Jeśli nie zrobiłeś błędów, to panelu na spodzie ekranu dostaniesz raport z kompilacji:

Ważny jest ostatni wiersz, który informuje cię o błędach. Jeśli program zawiera jakieś błędy (ang. errors), to nie będziesz go mógł uruchomić. Błędy zawsze muszą zostać usunięte.

Gdy kompilacja przebiegła poprawnie, to na dysku pojawi się plik programu o nazwie takiej samej jak nazwa projektu. U nas jest to p01 i ma rozmiar 9,12KB. Plik ten znajduje się wewnątrz katalogu bin/Debug w naszym katalogu projektowym, zatem pełna ścieżka dostępu ma postać:

W systemie Linux w nazwach plików i katalogów są rozróżniane duże i małe litery. Aby uruchomić plik, nie musisz opuszczać środowiska Code::Blocks. Wystarczy, że klikniesz myszką ikonę:

Na ekranie pojawi się czarne okienko terminala, a w nim tekst:

Po naciśnięciu klawisza Enter nastąpi powrót do edytora. Tekst ten będzie się pojawiał tylko wtedy, gdy program uruchamiasz w środowisku Code::Blocks. Program możesz również uruchomić z poziomu systemu poza środowiskiem Code::Blocks. W tym celu naciśnij klawisze lewy Ctrl + lewy Alt + T. Spowoduje to uruchomienie terminala systemowego. Terminal zwykle przenosi użytkownika do jego katalogu domowego. U nas katalogiem domowym jest /home/uczen. Ten fragment ścieżki można pominąć i wprowadzić polecenie:

Nic specjalnie się nie stanie, ponieważ nasz program na razie nic nie robi. Lecz zwróć uwagę, że teraz nie pojawił się żaden napis. Ostatnio wydane polecenia można przywracać w terminalu klawiszem strzałki w górę. Zatem, aby ponownie uruchomić nasz program (np. po wprowadzeniu w nim zmian i przekompilowaniu), wystarczy nacisnąć strzałkę w górę i Enter. Wypróbuj to. Terminal opuszczasz poleceniem exit lub klikając w X na pasku tytułowym okna.

Funkcja main() zwraca wartość całkowitą, którą można wykorzystać (i często to się robi) do zwrócenia dodatkowych informacji przez program - np. czy wykonanie powiodło się, czy też wystąpił jakiś błąd. Do zwracania wartości przez funkcję używamy polecenia return. Jeśli je pominiesz, to funkcja zwróci zero. Zmień program w edytorze na poniższy:

int main()
{
    return 155;
}

Instrukcję języka C++ kończy się za pomocą średnika. Dlatego po liczbie 155 mamy średnik.

Jeśli teraz skompilujesz i uruchomisz program, w oknie konsoli pojawi się informacja:

Process returned 155 (0x9B) execution time : 0.006 s
Press ENTER to continue.

To właśnie jest argument instrukcji return. Tak będzie zawsze, jeśli funkcja main() zwróci wartość różną od 0 (oznaczającego wykonanie z sukcesem - inna wartość jest zawsze interpretowana jako błąd). Najczęściej funkcję main() będziemy kończyli instrukcją:

int main()
{
    return 0;
}

Jeśli teraz skompilujesz i uruchomisz program, to w oknie Logs & others nie pojawi napis na czerwonym tle, lecz napis niebieski:

Process terminated with status 0 (0 minutes, 1 seconds)
Proces zakończył się ze statusem 0 ...

Zwykle program w C++ musi odczytywać dane z konsoli i wyprowadzać na nią wyniki swojego działania. Operacje wejścia/wyjścia nie są częścią definicji języka C++, lecz osobną biblioteką. Jeśli chcemy z nich korzystać, to musimy poinformować kompilator o obiektach, które tych operacji dokonują. Definicje tych obiektów zawarte są w tzw. plikach nagłówkowych (ang. header files), które dołączamy do programu dyrektywą #include. Wpisz poniższy program:

#include <iostream>

int main()
{
    return 0;
}

Pliki nagłówkowe są bardzo wygodnym rozwiązaniem - zamiast w każdym programie wpisywać żmudnie definicje tych samych obiektów, wpisujemy jedynie prostą dyrektywę. Przed rozpoczęciem kompilacji plik źródłowy jest wstępnie obrabiany przez tzw. preprocesor. Wyszukuje on w programie źródłowym swoich poleceń, które nazywamy dyrektywami preprocesora. Np. polecenie #include każe preprocesorowi zastąpić się zawartością odpowiedniego pliku nagłówkowego, który jest wstawiany w miejscu tej dyrektywy. Następnie tak zmieniony plik wędruje do kompilatora, który ma już pod ręką wszystkie potrzebne definicje.

Plik nagłówkowy iostream definiuje tzw. strumienie wejścia/wyjścia konsoli (ang. input output streams). Strumień wyjścia cout (ang. console output) pozwala wyświetlać informację w oknie konsoli. Strumień wejścia cin (ang. console input) z kolei pozwala odczytywać informację wpisaną przez użytkownika z klawiatury. Wpisz poniższy program:

#include <iostream>

int main()
{
    std::cout << "Cześć. Jestem twoim programem w języku C++" << std::endl;
    return 0;
}

Po uruchomieniu zobaczymy w oknie konsoli napis:

<< jest operatorem przesłania danych do strumienia.

endl to tzw. manipulator powodujący przejście z wydrukiem do następnego wiersza w oknie konsoli. Dzięki niemu po napisie Tutaj program w C++ mamy jeden pusty wiersz odstępu. Zamiast manipulatora endl można w tekście umieszczać znaki końca wiersza - \n:

#include <iostream>

int main()
{
    std::cout << "Cześć. Jestem twoim programem w języku C++\n"
                 "------------------------------------------\n\n";
    return 0;
}

Zauważ, że na końcu pierwszego tekstu nie dodajemy średnika, ponieważ instrukcja nie jest tutaj jeszcze zakończona. Po prostu kontynuujemy przesyłanie dalszej części tekstu w drugim wierszu.

Nazwy cout oraz endl są poprzedzone napisem std::. Jeśli go usuniesz, to program nie da się skompilować, ponieważ kompilator nie potrafi odnaleźć cout i endl. Napis std to tzw. przestrzeń nazw, w której żyją obiekty biblioteki STL. Wyobraź sobie ją jako worek z napisem std. Poza tym workiem nazwy zdefiniowanych w nim obiektów są niedostępne, o ile nie poprzedzisz je napisem std:: - wtedy kompilator będzie po prostu wiedział, gdzie ich szukać. Możesz jednakże poinformować kompilator, że chcesz standardowo korzystać z danej przestrzeni nazw - do tego celu służy dyrektywa using namespace, za którą wpisujemy nazwę przestrzeni nazw. Gdy taką dyrektywę umieścisz w swoim programie, to nie będziesz musiał poprzedzać nazw cout, cin i innych z STL kwalifikatorem std:: - do duże ułatwienie. Dyrektywa using namespace std mówi po prostu kompilatorowi, że jeśli nie znajdzie danej nazwy w standardowym środowisku, to ma jej poszukać w "worku" o nazwie std. Przestrzenie nazw zmniejszają ryzyko konfliktów nazw różnych obiektów i z tego powodu znalazły się w języku C++. Uwierz nam, to dobry wynalazek.

Wpisz poniższy program:

#include <iostream>

using namespace std;

int main()
{
    cout << "Cześć. Jestem twoim programem w języku C++" << endl
         << "------------------------------------------" << endl << endl;
    return 0;
}

Na początku programu umieszczamy zwykle krótki komentarz informujący użytkownika o przeznaczeniu danego programu, autorze i dacie utworzenia. Komentarze mamy za darmo - nie są one przenoszone do programu wynikowego i w żaden sposób nie zwiększają jego pojemności ani nie zmniejszają szybkości działania. Komentujmy zatem programy - staną się o wiele czytelniejsze nawet dla samych ich autorów - szczególnie po upływie kilku tygodni od daty utworzenia.

// Przykładowy program w języku C++
// (C)2015 I LO w Tarnowie
//---------------------------------

#include <iostream>

using namespace std;

int main()
{
    cout << "Cześć. Jestem twoim programem w języku C++" << endl
         << "------------------------------------------" << endl << endl;
    return 0;
}