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, i tak nie są to wszystkie języki programowania):

• 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

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.

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.

Na początku rozpoczniemy programowanie w języku C++ wykorzystując interfejs sieciowy, który znajdziesz pod adresem:

https://www.programiz.com/cpp-programming/online-compiler/

Takie rozwiązanie jest wygodne w czasie nauki zdalnej. Gdy wrócimy do pracowni w szkole, będziemy wykorzystywali zintegrowane środowisko programowania Code::Blocks (ang. IDE - Integrated Developement Environment), które zawiera edytor oraz kompilator. Poniżej umieściłem instrukcję krok po kroku instalacji tego środowiska. Instalacja jest prosta i nie wymaga wysokich umiejętności "informatycznych" (ta uwaga odnosi się do rodziców niektórych uczniów).

Wszystkie przykłady, które wykonamy on-line, można również wykonać w środowisku Code::Blocks.

Poniższy opis dotyczy instalacji CodeBlocs 20.03 w systemie Windows 10.

Pobranie instalatora

Kliknij w poniższy link (zakładam, że pracujesz w przeglądarce Firefox):

https://www.fosshub.com/Code-Blocks.html?dwl=codeblocks-20.03-32bit-mingw-32bit-setup.exe

Powinno pojawić się okienko z informacją o ładowaniu pliku instalatora:

Kliknij w przycisk Zapisz plik, aby rozpocząć proces ładowania. Gdy przeglądarka Firefox ukończy ładowanie, powiadomi cię o tym u góry ekranu po prawej stronie niebieską strzałką:

Kliknij lewym przyciskiem myszki w niebieską strzałkę, aby otworzyć listę załadowanych plików:

Pobrany plik jest plikiem instalacyjnym środowiska Code::Blocks w wersji 20.03 wraz z kompilatorem MingW języka C++ dla 64-bitowych systemów Windows (czyli dla większości współczesnych instalacji Windows). Nasz opis dotyczy systemu Windows 10, jednakże instalacja wygląda identycznie również w starszych systemach Windows.

Instalacja

Gdy otwarłeś listę pobranych plików, kliknij lewym przyciskiem myszki w plik instalatora. Musisz posiadać uprawnienia administratora na swoim komputerze, aby zainstalować Code::Blocks (jeśli nie wiesz o co chodzi, zawołaj do pomocy tatę lub mamę).

Gdy instalator się uruchomi, na ekranie zobaczysz poniższe okienko (lub podobne):

Kliknij w przycisk Tak, w przeciwnym razie przerwiesz instalację.

Gdy instalacja się rozpocznie, na ekranie zaczną się pojawiać kolejne okienka dialogowe instalacji. Poniżej masz przetłumaczoną ich treść. Jest to typowy proces instalacyjny i, jeśli nie masz jakiś specjalnych powodów, to po prostu zatwierdzaj je klikając na przycisk Next.

	Witaj w Programie Instalacyjnym Code::Blocks   Program instalacyjny poprowadzi cię poprzez instalację Code::Blocks. Zalecane jest zamknięcie wszystkich innych aplikacji przed uruchomieniem instalacji. Pozwoli to uaktualnić istotne pliki systemowe bez potrzeby ponownego uruchomienia komputera. Aby kontynuować, kliknij na Dalej.   Dalej >    Anuluj
	Zgoda licencyjna Proszę przeglądnąć warunki licencji przed instalacją Code::Blocks. Naciśnij klawisz PgDn, aby zobaczyć resztę zgody licencyjnej. [Treść licencji GNU] Jeśli zgadzasz się na warunki zgody licencyjnej, kliknij przycisk Zgadzam się. Musisz zaakceptować zgodę licencyjną, aby zainstalować Code::Blocks.   < Wstecz     Zgadzam się    Anuluj
	Wybierz Składniki Wybierz, które cechy Code::Blocks chcesz zainstalować. Zaznacz składniki, które chcesz zainstalować, a skazuj zaznaczenie dla tych, których nie chcesz instalować. Kliknij Dalej, aby kontynuować. Wybierz rodzaj instalacji: Pełna instalacja: wszystkie wtyczki, wszystkie narzędzia, po prostu wszystko Lub wybierz opcjonalne składniki, które chcesz zainstalować   [ Drzewo składników] Wymagane miejsce: 576,0MB Opis Umieść kursor myszki ponad składnikiem, aby zobaczyć jego opis   < Wstecz     Dalej >    Anuluj
	Wybierz Miejsce Instalacji Wybierz katalog, w którym zostanie zainstalowane Code::Blocks. Program instalacyjny zainstaluje Code::Blocks w następującym katalogu. Aby zainstalować w innym, kliknij przycisk Przeglądaj... i wybierz inny katalog. Kliknij przycisk Instaluj, aby rozpocząć instalację. Katalog Docelowy [C:\Program Files (x86)\Code::Blocks ]  [ Przeglądaj... ] Wymagane miejsce: 576,6MB Dostępne miejsce: 1602,9GB   < Wstecz     Instaluj >    Anuluj
	Instalowanie Proszę poczekać w trakcie instalacji Code::Blocks. [pasek postępu instalacji] [instalowane składniki]     < Wstecz     Dalej >    Anuluj
Tutaj może pojawić się okno dialogowe:	W okienku jest zapytanie, czy chcesz uruchomić teraz Code::Blocks. Wybierz Nie, aby dokończyć pracę instalatora.
	Instalacja Zakończona Instalacja zakończyła się sukcesem. [  ] [  ]   < Wstecz     Dalej >    Anuluj
	Kończenie Instalacji Code::Blocks   Code::Blocks został zainstalowany na twoim komputerze. Kliknij przycisk Zakończ, aby zakończyć program instalacyjny.   < Wstecz     Zakończ >    Anuluj

Test instalacji

Uruchom Code::Blocks

W oknie głównym wybierz opcję Create a new project (utworzenie nowego projektu).

Pojawi się okno wyboru typu projektu aplikacji:

Wybierz Console application (aplikacja konsoli) i kliknij w przycisk Go.

Co to jest aplikacja konsoli? Kiedyś, dawno temu, gdy jeszcze nie powstał system Windows, komputery programowane były w systemie DOS w trybie znakowym. Ekran wyświetlał ustalony zestaw znaków. Tryb ten pojawia się czasem na niektórych starszych komputerach IBM-PC przy starcie systemu, zanim Windows/Linux przejmą kontrolę. Ekran w trybie tekstowym wyglądał tak:

Na dzisiejszych komputerach tryb ten stał się już przestrzały, jednak wciąż możemy go symulować w Windows oraz w Linuxie. Zaletą konsoli jest prostota używania. Nie musisz walczyć z procedurami graficznymi Windows, aby wyświetlić wynik działania swojego programu: po prostu przesyłasz do konsoli tekst, a ten zostanie wyświetlony.

Gdy wybierzesz aplikację konsoli, to twój program otrzyma możliwość wysyłania tekstu do konsoli oraz odczytywania informacji, którą użytkownik wprowadził z klawiatury.

Po kliknięciu w przycisk Go uruchomiony zostaje proces tworzenia projektu takiej aplikacji. Rozpoczyna się on oknem powitalnym:

Kliknij w Next. Kolejne okno wybiera rodzaj języka programowania, w którym będziesz tworzył swój program. Powinien być ustawiony język C++:

Kliknij w Next. Następne okienko określa katalog, w którym będzie tworzony projekt.

Kliknij w przycisk obok pola Folder to create project in (katalog do utworzenia w nim projektu) i wybierz swój katalog na pliki projektów. Może to być ten sam katalog, w którym zapisywałeś swoje pliki ćwiczeniowe na lekcjach on-line. Następnie w polu Project title (tytuł projektu) wpisz nazwę swojego projektu. Pozostałych pól nie zmieniaj, kliknij Next.

W ostatnim okienku nic nie zmieniaj, kliknij Finish. Projekt zostanie utworzony i okno startowe Code::Blocks zmieni się w okno edytora:

W panelu Management (zarządzanie) otwórz gałąź Sources (źródła). Znajdziesz tu plik o nazwie main.cpp. Jest to główny plik źródłowy programu w języku C++. Kliknij go dwukrotnie muszką, wtedy w oknie edytora pojawi się jego zawartość:

Na razie nie wnikamy w znaczenie tego programu (tym zajmiemy się dalej). Aby program uruchomić, musimy go najpierw skompilować, czyli zamienić tekst programu w instrukcje dla procesora twojego komputera. Efektem kompilacji jest plik wykonywalny z rozszerzeniem exe (po angielsku executable). Program kompilujemy klikając w ikonę kółka zębatego: .  Gdy to zrobisz, w dolnym panelu Build log pojawią się napisy:

-------------- Build: Debug in test (compiler: GNU GCC Compiler)---------------

g++.exe -Wall -fexceptions -g  -c C:\Users\geo19\OneDrive\Obrazy\Dokumenty\test\main.cpp -o obj\Debug\main.o
g++.exe  -o bin\Debug\test.exe obj\Debug\main.o   
Output file is bin\Debug\test.exe with size 74.76 KB
Process terminated with status 0 (0 minute(s), 1 second(s))
0 error(s), 0 warning(s) (0 minute(s), 1 second(s))
 

To po prostu polecenia uruchamiające odpowiednie aplikacje kompilatora. Dla nas istotny jest ostatni wiersz. Jeśli liczba błędów (errors) jest równa 0, to wszystko w porządku, inaczej możesz zacząć się martwić. Nasz program wypisuje w oknie konsoli napis "Hello world!". Aby sprawdzić, czy tak faktycznie będzie, musisz teraz uruchomić skompilowany program. Kliknij w ikonę z zieloną strzałką: . Powinno pojawić się okno konsoli znakowej:

Po zakończeniu działania programu pojawi się raport oraz napis Press any key to continue (naciśnij dowolny klawisz, aby kontynuować). Zamknij okno konsoli i okno Code::Blocks.

Przechodzimy do strony:

https://www.programiz.com/cpp-programming/online-compiler/

W sieci Internet jest wiele kompilatorów on-line języka C++. Ten wybrałem ze względu na jego ekstremalną prostotę.

Z lewej strony wybierz kompilator C++:

Okno robocze podzielone jest na dwie części: edytor z lewej i wynikowe okno konsoli z prawej. System ten pozwala tylko na pracę z oknem konsoli.

Nad okienkiem edytora są trzy przyciski:

Oznaczają one kolejno: tryb okna/pełnego ekranu; tryb dzienny/nocny; uruchomienie (kompilacja + uruchomienie programu wynikowego). Naprawdę, trudno o coś bardziej prostego.

Nad oknem konsoli jest tylko jeden przycisk:

Powoduje on wyczyszczenie zawartości okna konsoli.

Po tym wstępie możemy rozpocząć pisanie pierwszych programów w języku C++.

https://www.programiz.com/cpp-programming/online-compiler/

Najprostszy program w języku C++ wygląda następująco:

int main()
{
    return 0;
}

Program zbudowany jest z tzw. funkcji. Nazwa main oznacza po angielsku funkcję główną, czyli taką, od której rozpoczyna się wykonywanie programu. Słowo int jest skrótem angielskiej nazwy integer, czyli liczba całkowita. Określa ono, iż funkcja main daje jako wynik swojego działania liczbę całkowitą. W klamrach umieszcza się polecenia, które mają być wykonane. Tutaj w klamrach zostało umieszczone tylko jedno polecenie return, które kończy funkcję i zwraca jako jej wynik liczbę umieszczoną za return. Każda instrukcja języka C++ kończy się średnikiem.

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 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 umieścić w tym miejscu programu zawartość odpowiedniego pliku nagłówkowego. 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 << "Witaj. Jestem twoim programem w 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 Jestem twoim programem 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 << "Witaj. Jestem twoim programem w C++\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 (ang. Standard Template Library). 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 << "Witaj. Jestem twoim programem w C++" << 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)2021 I LO w Tarnowie
//---------------------------------

#include <iostream>

using namespace std;

int main()
{
    cout << "Witaj. Jestem twoim programem w C++" << endl
         << "-----------------------------------" << endl;
    return 0;
}

Podsumowanie

Program w języku C++ posiada następującą strukturę:

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

#include <iostream>

using namespace std;

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