Informatyka dla klas II

Wprowadzenie do C++

Języki programowania

Język programowania (ang. programming language) umożliwia wydawanie poleceń komputerowi. W pierwszych komputerach stosowano binarne kody instrukcji, które bezpośrednio rozumie komputer . Procesor najpierw pobiera kod instrukcji, a następnie analizuje go i na podstawie odpowiednich pól wykonuje określone operacje. 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.

 

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.

 

 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 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:

 

 Asembler
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):

 

Język programowania C++

Grafika:BjarneStroustrup.jpg

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.

tworzenie
tekstu
programu
kompilacja
tekstu na
język
maszynowy
uruchomienie
programu
wynikowego

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.

 

Przygotowanie środowiska programowania do pracy

Najpierw odpowiednio przygotujemy swoje środowisko pracy na dysku komputera w pracowni informatycznej. W tym celu uruchamiamy Menadżera plików, klikając w pierwszą ikonkę obok przycisku Start:

 

 

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.

 

 

Uwaga
Jeśli nie widzisz panelu Management (zarządzanie), naciśnij SHIFT + F2. Klawisze te włączają lub wyłączają widoczność panelu zarządzania. Jeśli po otwarciu panelu Management nie widzisz swojego projektu p01, to należy rozwinąć sekcję Workspace (przestrzeń robocza), po czym p01 i Sources. Wtedy zobaczysz pliki źródłowe, czyli takie, które zawierają tekst tworzonego programu. Dwukrotne kliknięcie lewym przyciskiem myszki ładuje wybrany plik do edytora. W edytorze można edytować wiele plików, które wybieramy za pomocą zakładek zawierających ich nazwy.

Wielkość czcionki w edytorze regulujemy kółkiem myszki z wciśniętym klawiszem CTRL. Dobierz taką czcionkę, aby tekst programu był dla ciebie dobrze czytelny.

 

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:

 

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

g++ -Wall -fexceptions -g -c /home/uczen/2k1/p01/main.cpp -o obj/Debug/main.o
g++ -o bin/Debug/p01 obj/Debug/main.o
Output file is bin/Debug/p01 with size 9,12 KB
Process terminated with status 0 (0 minute(s), 0 second(s))
0 error(s), 0 warning(s) (0 minute(s), 0 second(s))

 

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ć:

 

/home/uczen/2k1/bin/Debug/p01

 

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:

 

2k1/p01/bin/Debug/p01

 

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:

 

Cześć. Jestem twoim programem w języku C++

Process returned 0 (0x0) execution time : 0.003 s
Press ENTER to continue.

 

<< 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;
}

 

Podsumowanie

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

 

// Przykładowy program w języku C++
// (C)2015 I LO w Tarnowie
//---------------------------------
  Komentarz
#include <iostream>
  Pliki nagłówkowe zawierające definicje używanych w programie struktur danych oraz funkcji bibliotecznych.
using namespace std;
  Jeśli wykorzystujemy elementy biblioteki STL, to wstawiamy do programu dyrektywę informującą kompilator o używanej przestrzeni nazw.
int main()
{
    cout << "Cześć. Jestem twoim programem w języku C++" << endl
         << "------------------------------------------" << endl << endl;
    return 0;
}
  Każdy program w języku C++ musi posiadać funkcję main(), od której rozpoczyna się wykonywanie programu. Zawartość tej funkcji określa to, co program robi.

 



List do administratora Serwisu Edukacyjnego Nauczycieli I LO

Twój email: (jeśli chcesz otrzymać odpowiedź)
Temat:
Uwaga: ← tutaj wpisz wyraz  ilo , inaczej list zostanie zignorowany

Poniżej wpisz swoje uwagi lub pytania dotyczące tego rozdziału (max. 2048 znaków).

Liczba znaków do wykorzystania: 2048

 

W związku z dużą liczbą listów do naszego serwisu edukacyjnego nie będziemy udzielać odpowiedzi na prośby rozwiązywania zadań, pisania programów zaliczeniowych, przesyłania materiałów czy też tłumaczenia zagadnień szeroko opisywanych w podręcznikach.



   I Liceum Ogólnokształcące   
im. Kazimierza Brodzińskiego
w Tarnowie

©2017 mgr Jerzy Wałaszek

Dokument ten rozpowszechniany jest zgodnie z zasadami licencji
GNU Free Documentation License.