Koło informatyczne

Zajęcia organizacyjne

Każdy uczestnik koła informatycznego powinien zainstalować na swoim domowym komputerze środowisko Code::Blocks do programowania w języku C++. Jest ono dostępne do pobrania na stronie projektu:

 

Instalacja Linuxa w Windows

Na konkursach informatycznych zwykle stosowane jest środowisko Linux wraz z odpowiednimi narzędziami. Zainstalujesz je na swoim komputerze z Windows przy pomocy tzw. maszyny wirtualnej. Jest to program, który tworzy w twoim komputerze wirtualny komputer. Ten z kolei może uruchomić w obrębie swoich zasobów dowolny system operacyjny. Co więcej, między tym systemem a Windows może istnieć komunikacja, np. poprzez schowek. Ja w ten sposób pracuję już od lat na swoim komputerze domowym. W pracowni mamy system Lubuntu, a w domu mam system Windows 10. Jeśli chcę coś przygotować na lekcje lub koła, muszę to sprawdzić w Linuxie. Tutaj idealnym rozwiązaniem jest technologia maszyny wirtualnej.

Najpierw pobierz z sieci aplikację VMWare Workstation Player. Znajdziesz ją pod adresem:

 

 

Przewiń stronę na koniec sekcji Desktop & End-User Computing. Tam znajdziesz pożądaną aplikację. Na dzień dzisiejszy jest to VMWare Workstation 12 Player. Aplikacja jest 64-bitowa i powinna zainstalować się bez problemu w nowych systemach Windows. Po uruchomieniu pojawi się okienko powitalne:

 

 

Zaznacz pierwszą opcję (pozwala darmowo używać programu w zastosowaniach niekomercyjnych) i w podanym polu tekstowym wpisz swój adres e-mail. Kliknij w przycisk Continue. Ukaże się dalsza część informacji wstępnych:

 

Kliknij w przycisk Finish.

 

 

Przypnij program do paska zadań. Wtedy będziesz go mógł szybko uruchamiać. Po zatwierdzeniu okienka powitalnego ukaże się okno robocze VMPlayera.

 

 

Jest ono podzielone na dwie części. Z lewej strony będą się pojawiać zainstalowane maszyny wirtualne. Z prawej strony mamy kilka opcji. Gdy rozpoczniesz pracę z aplikacją, zapewne będziesz chciał utworzyć nową maszynę wirtualną i zainstalować w niej system Linux. W tym celu musisz najpierw pobrać z Internetu odpowiednią dystrybucję Linuxa. Polecam Ubuntu, ponieważ jest bardzo wszechstronne i popularne – nie będziesz miał kłopotów ze znalezieniem aplikacji oraz informacji na temat tej dystrybucji.

Dystrybucję Ubuntu znajdziesz pod adresem:

 

 

Wybierz Ubuntu Desktop. Na stronie ładowania ustaw wersję 64-bitową i kliknij w przycisk Download. Spowoduje to załadowanie pliku iso, który jest obrazem płyty DVD. Za pomocą nagrywarki obraz ten możesz wypalić na fizycznym nośniku (z takiej płytki DVD możesz instalować Ubuntu na innym komputerze). Jednakże dla VMPLayera wystarczy sam plik iso.

Gdy plik iso zostanie pobrany, możemy rozpocząć jego instalację w maszynie wirtualnej. W VMPlayerze wybierz opcję Create a New Virtual Machine. Pojawi się okienko dialogowe tworzenia nowej maszyny wirtualnej:

 

 

 Wybierz opcję Installer disk image file (iso), kliknij w przycisk Browse, wyszukaj i wybierz pobrany z sieci plik iso. U mnie ten plik nazywa się ubuntu-15.04-desktop-amd64.iso i znajduje się w katalogu images na dysku D. U ciebie plik może posiadać inną nazwę i znajdować się w innym miejscu przestrzeni dyskowej komputera. Po wybraniu dysku instalacyjnego, kliknij w Next.

 

 

Jeśli instalujesz Ubuntu, to możesz skorzystać z ułatwionej instalacji i niektóre czynności VMPlayer wykona automatycznie. W następnym okienku dialogowym wpisz kolejno swoje nazwisko, nazwę użytkownika oraz dwukrotnie hasło dostępu do konta (później to wszystko możesz zmienić). Kliknij w przycisk Next.

 

 

Tutaj określasz nazwę swojej maszyny wirtualnej oraz jej położenie na dysku. Proponuję nic nie zmieniać i kliknąć w przycisk Next.

 

 

Tutaj określasz wielkość dysku dla maszyny wirtualnej. Dysk będzie tworzony jako plik. Na początku nie będzie on duży, lecz w miarę zapełniania danymi jego wielkość będzie rosła. Proponuję ustawić 40GB. Również wybierz opcję Store virtual disk as single file, co przyspieszy operacje zapisu danych. Kliknij Next.

 

 

W tym okienku znajduje się podsumowanie parametrów dla maszyny wirtualnej. Jeśli zechcesz coś zmienić, kliknij w przycisk Customize Hardware... Wtedy pojawi się inne okienko dialogowe z różnymi zasobami:

 

 

Jeśli masz mocny komputer, to wybierz 2...4GB pamięci (Memory), liczba procesorów 2...4. W opcjach USB wybierz wszystko i ustaw kompatybilność na USB 3.0 (jeśli twój komputer to obsługuje). Kliknij w Close, aby zamknąć okienko opcji sprzętowych, po czym kliknij w Finish. Maszyna wirtualna zostanie utworzona i uruchomiona. Rozpocznie się instalacja Ubuntu.

 

 

W trakcie instalacji może pojawić się okienko z informacją o dostępności narzędzi VMWare Tools. Należy je zatwierdzić. Narzędzia te dadzą ci dostęp do komputera hosta z poziomu Ubuntu oraz pozwolą zmieniać rozmiar ekranu Linuxa bezpośrednio w oknie Windows (Jeśli narzędzia VMWare Tools nie zainstalują się automatycznie, tutaj masz poradnik). Ubuntu instaluje się w wersji angielskiej, ale można to później łatwo sobie zmienić.

Po instalacji uruchom terminal (Ctrl+lewy Alt+T) i wpisz:

 

sudo apt-get update
sudo apt-get upgrade
sudo apt-get install build-essential
sudo apt-get install g++
exit

 

Code::Blocks znajdziesz w Centrum Oprogramowania Ubuntu. Zainstaluj to środowisko. Następnie uruchom. Przy pierwszym starcie Code::Blocks wykrywa dostępne kompilatory C++. Wybierz GNU GCC Compiler i ustaw go jako domyślny. Dobrze jest jeszcze zmienić terminal konsoli na gnome-terminal. W tym celu wybierz opcję menu Settings → Environment i zmień wpis w polu Terminal to launch console programs: na

 

gnome-terminal $TITLE -x

 

Masz już gotowy system Linux do ćwiczenia programowania.

Oprócz Ubuntu również godną do polecenia dystrybucją Linuxa jest Mint, z którego sam korzystam. Jest on troszeczkę trudniejszy w instalacji od Ubuntu, ponieważ nie jest wykrywany automatycznie przez VMPlayera, lecz jest to naprawdę mała trudność. Wystarczy w trakcie instalacji poinformować VMPlayera, że ma do czynienia z systemem Linux z rodziny Ubuntu, reszta ustawień jest taka sama jak dla opisanej wyżej dystrybucji podstawowej. W Mint ustawiamy w Code::Blocks terminal:

 

gnome-terminal --disable-factory -t $TITLE -x

 

i mamy to samo co w Ubuntu:

Wielką zaletą Linuxa jest kompatybilność terminalu i edytora Code::Blocks pod względem polskich liter. W systemie Windows konsola korzysta z kodowania Latin-2 (852), a reszta systemu z Windows-1250. Powoduje to, że polskie litery są źle wyświetlane w konsoli. Linux z kolei stosuje jeszcze inne kodowanie: pl_PL.UTF-8. Więcej o tym znajdziesz tutaj.

Praca w systemie Linux

Gdy staniesz się uczestnikiem zawodów, to zwykle systemem operacyjnym będzie Linux. Jednakże w systemie tym może nie być zainstalowane środowisko Code::Blocks. Co wtedy? Otóż będziesz musiał korzystać z narzędzi, które udostępnia sam system Linux. Terminal uruchamiasz kombinacją klawiszy Ctrl+lewy Alt+T. Po uruchomieniu terminalu zwykle pracujesz w katalogu domowym (ang. home directory). Informuje cię o tym znak tyldy ~ w wierszu oczekiwania na polecenie:

Rozejrzyj się. Wpisz polecenie ls. Zostanie wyświetlona lista plików i katalogów dostępnych w bieżącym katalogu roboczym:

Teraz utwórzmy sobie katalog ki (koło informatyczne), w którym będziemy tworzyć nasze projekty. Wpisz polecenia:

Polecenie mkdir tworzy katalog (ang. make directory).

Zwróć uwagę, że teraz na liście pojawił się katalog ki. Przechodzimy do katalogu ki i tworzymy w nim katalog p01 (od projekt nr 01). Następnie wchodzimy do tego katalogu. Zwróć uwagę na zmianę wiersza zgłoszenia:

Teraz twoim bieżącym katalogiem roboczym (ang. current working directory) jest katalog p01, który znajduje się wewnątrz katalogu ki, a ten z kolei znajduje się w twoim katalogu domowym. Jeśli terminal staje się zaśmiecony, to czyścisz go przez naciśnięcie kombinacji klawiszy Ctrl+L.

W katalogu p01 utworzymy sobie plik źródłowy main.cpp z tekstem programu. Musimy skorzystać z edytora. W dystrybucji Ubuntu i jej pochodnych (np. Mint) dostępny jest prosty edytor nano. Wpisz nano main.cpp. Edytor ten pracuje w terminalu.

Górną część okna zajmuje obszar wprowadzania tekstu. Na dole masz opcje menu, które przywołujesz kombinacją klawiszy Ctrl+litera. Wpisz do edytora poniższy tekst programu:

Plik zapisujesz na dysku przez naciśnięcie klawiszy Ctrl+O (operację zapisu potwierdzasz klawiszem Enter). Wychodzisz z edytora nano, naciskając klawisze Ctrl+X. gdy teraz wpiszesz polecenie ls, to powinieneś zobaczyć na liście plik main.cpp:

W następnym kroku skompilujemy ten plik kompilatorem g++ i uruchomimy:

To wszystko. Jak widzisz, nie jest to wcale skomplikowane. Terminal zapamiętuje historię wprowadzonych poleceń. Aby ponownie wykonać któreś z nich, naciskasz klawisz strzałka w górę, aż w wierszu pojawi się pożądane polecenie, po czym naciskasz klawisz Enter, aby je wykonać. Przy pewnej wprawie można w tym systemie pracować bardzo szybko i efektywnie. Jednakże środowisko uruchomieniowe IDE jest rozwiązaniem bardziej wygodnym, szczególnie wtedy, gdy w program jest długi i zawiera błędy do poprawienia. Dlatego pomijając zawody w programowaniu, zwykle będziemy pracować w Code::Block.

Krótka powtórka C++

Komentarze

Komentarze służą do umieszczania w programie wyjaśnień i opisów. Nie trafiają one do programu wynikowego. Programy warto opatrywać komentarzami, ponieważ zwiększa to ich czytelność. W języku C++ mamy dwa rodzaje komentarzy:

  1. Komentarz wierszowy rozpoczyna się od znaków // i obowiązuje do końca wiersza.
  2. Komentarz blokowy rozpoczynamy od znaków /* i kończymy znakami */. Znaki te można umieszczać w podanej kolejności w dowolnym miejscu programu. Znakami tymi może być objęte wiele wierszy.

Przykłady:

// To jest komentarz wierszowy
// Obowiązuje tylko do końca wiersza
// ---------------------------------

/*----------------------------------
  Tutaj mamy komentarz blokowy,
  który może składać się z dowolnej
  liczby wierszy
  ---------------------------------*/

Budowa programu w C++

Typowy program w języku C++ zbudowany jest następująco:

 

// Opis programu (nieobowiązkowy)

#include <iostream>;  // Dołączanie plików nagłówkowych

using namespace std;  // Definicja przestrzeni nazw (nieobowiązkowa)

// Opis funkcji (nieobowiązkowy)
int main()            // Funkcja główna (obowiązkowa)
{
                      // treść programu
}

 

Pliki nagłówkowe zawierają definicje obiektów używanych w programie. Dyrektywa #include dołącza je do tekstu programu w trakcie kompilacji. Dzięki plikom nagłówkowym nie musimy tych definicji wpisywać ręcznie przy każdym nowotworzonym programie.

Wykonanie programu rozpoczyna się w języku C++ od funkcji main(), zwanej funkcją główną lub startową.

 

Typy danych

int liczba 32b ze znakiem w kodzie U2, zakres -2147483648...2147483647. Występuje w odmianach:
short int liczba 16b ze znakiem w kodzie U2, zakres -32768...32767
long long int liczba 64b ze znakiem w kodzie U2, zakres -9223372036854775808...9223372036854775807
unsigned int liczba 32b bez znaku w kodzie NBC, zakres 0...4294967295
unsigned short int liczba 16b bez znaku w kodzie NBC, zakres 0...65535
unsigned long long int liczba 64b bez znaku w kodzie NBC, zakres 0...18446744073709551617
char znak ASCII, 8b. Występuje w dwóch odmianach:
unsigned char kody od 0 do 255
signed char kody od -128 do 127

Typ char jest traktowany przez C++ jak typ liczbowy

bool typ logiczny. Przyjmuje tylko dwie wartości: 0 (false) lub 1 (true).
float typ zmiennoprzecinkowy pojedynczej precyzji. Zajmuje w pamięci 32b. Posiada 7-8 cyfr znaczących. Z uwagi na małą precyzję dzisiaj już jest stosowany rzadko.
double typ zmiennoprzecinkowy podwójnej precyzji. Zajmuje w pamięci 64b. Posiada 15 cyfr znaczących. Jest standardowym typem zmiennoprzecinkowym. Występuje w odmianie:
long double w zależności od systemu jest to liczba zmiennoprzecinkowa 64b, 80b lub 128b. Z tego powodu unikaj polegania na określonej długości danych tego typu.

 

Aby sprawdzić wspierane typy danych, utwórz w Code::Blocks nowy projekt konsoli, wpisz do edytora poniższy program, skompiluj i uruchom go:

 
// Typy danych w C++
// (C)2015 I LO w Tarnowie
//------------------------

#include <iostream>

using namespace std;

int main()
{
    cout << "int           - " << sizeof(int) << endl
         << "short int     - " << sizeof(short int) << endl
         << "long long int - " << sizeof(long long int) << endl
         << "char          - " << sizeof(char) << endl
         << "bool          - " << sizeof(bool) << endl
         << "float         - " << sizeof(float) << endl
         << "double        - " << sizeof(double) << endl
         << "long double   - " << sizeof(long double) << endl;
    return 0;
}

 

Zmienne

Zmienna jest obiektem w programie, który przechowuje dane. Każda zmienna w języku C++ posiada swój typ określający rodzaj przechowywanych danych. Zmienna musi zostać zdefiniowana przed pierwszym użyciem. Definicja zmiennej wygląda następująco:

 

typ nazwa;

 

lub

 

typ nazwa = wartość;

 

W tym drugim przypadku dodatkowo określana jest zawartość zmiennej. Nazwa zmiennej musi być utworzona wg następujących reguł:

  1. Dozwolone są tylko łacińskie litery duże i małe, cyfry oraz znak podkreślenia _.
  2. Nazwa nie może rozpoczynać się od litery.
  3. Nazwa nie może być identyczna ze słowem kluczowym języka C++. Jeśli taka nazwa jest konieczna, to należy w niej zmienić wielkość liter, np. Int, INT.
  4. Język C++ traktuje w nazwach litery małe i duże jako różne znaki. Nazwy Alfa i alfa są zatem różnymi nazwami i mogą się odnosić do różnych obiektów.

W jednej definicji można zdefiniować wiele zmiennych. Np.:

 

int a,b,c=15,d,e,f;

 

Ta definicja tworzy 6 zmiennych. Zmienna c otrzymuje wartość początkową 15. Wartości pozostałych zmiennych są nieokreślone.

Dane wprowadzamy do zmiennych za pomocą instrukcji przypisania:

 

zmienna = wyrażenie;

 

Komputer oblicza wartość wyrażenia i wynik wpisuje do zmiennej. Np.:

 

a = 5;
b = a * a + 10;

 

Zmienna b będzie zawierała liczbę 35 (5 * 5 + 10).

Modyfikacja zmiennej występuje wtedy, gdy w wyrażeniu w instrukcji przypisania znajduje się przypisywana zmienna. Np:

 

a = a + 5;
b = c * (d + b);

 

W języku C++ mamy wiele różnych operatorów modyfikacji:

 
zmienna += wyrażenie;
działa jak
zmienna = zmienna + wyrażenie;
 
zmienna -= wyrażenie;
działa jak
zmienna = zmienna - wyrażenie;
 
zmienna *= wyrażenie;
działa jak
zmienna = zmienna * wyrażenie;
 
zmienna /= wyrażenie;
działa jak
zmienna = zmienna / wyrażenie;
 
zmienna %= wyrażenie;
działa jak
zmienna = zmienna % wyrażenie;
reszta z dzielenia

 

Ogólna zasada operatora modyfikacji brzmi: operacja_dwuargumentowa=.

Oprócz tych operatorów mamy również operator zwiększania o 1 (++) oraz zmniejszania o 1 (--). Występuję one w dwóch postaciach:

 

++zmienna; --zmienna;
zmienna++; zmienna--;

 

Jeśli operacja zwiększania lub zmniejszania o 1 występuje samodzielnie, to oba warianty dają ten sam wynik. Różnica pojawia się, gdy operację zastosujemy w wyrażeniu:

 

a = 15;
b = ++a;

 

W tym przypadku b przyjmie wartość 16, ponieważ umieszczenie operatora ++ przed zmienną powoduje wczesne zwiększenie jej zawartości o 1 i w wyrażeniu zmienna będzie miała wartość już zwiększoną.

 

a = 15;
b = a++;

 

Tutaj zmienna b przyjmie wartość 15, ponieważ umieszczenie operatora ++ za zmienną powoduje późne zwiększenie jej wartości o 1 i w wyrażeniu posiada ona swoją pierwotną wartość. W obu powyższych przykładach zmienna a zostanie zwiększona do wartości 16.

 

Wartości logiczne

Język C++ rozróżnia dwie wartości logiczne:

true (prawda) jest to dowolna wartość różna od zera

false (fałsz) jest to wartość równa zero.

Wartość logiczną zwracają operatory porównań oraz funkcje logiczne.

Wyrażenie: a > 10 ma wartość 0, jeśli a jest mniejsze lub równe 10. Jeśli a spełnia warunek, to wyrażenie to przyjmie wartość true, czyli 1. Mamy następujące operatory porównań:

 

==   równe, np. a == b
!=   różne, np. a != 15
>   większe, np. a > b
<   mniejsze, np a < 10
>=   większe lub równe, np. a + 5 > b - 6
<=   mniejsze lub równe, np. a - 4 <= b + c

 

Funkcje logiczne:

!   negacja, np. !a
||   alternatywa, np. (a > 10) || (a < 5)
&&   koniunkcja, np. (a > 10) && (a < 15)

 

Operacje bitowe

Wyróżniamy przesuwy bitowe oraz funkcje logiczne, które działają na poszczególnych bitach argumentów.

<<   przesuw bitowy w lewo: np. a << 5
<<=   modyfikacja z przesuwem bitowym w lewo: np. a <<= 5; // bity zmiennej a przesuną się w lewo o 5 pozycji
>>   przesuw bitowy w prawo:, np. a >> 2
>>=   modyfikacja z przesuwem bitowym w prawo: np. a >>= 2; // bity zmiennej a przesuną się w prawo o 2 pozycje
~   negacja bitowa: np. ~a
|   alternatywa bitowa: np. a | 5
|=   modyfikacja alternatywą bitową: np. a |= 5;
&   koniunkcja bitowa: np. a & 1
&=   modyfikacja koniunkcją bitową: np. a &= 1;
^   bitowa suma modulo 2: np a ^ 3
^=   modyfikacja bitową sumą modulo 2: np. a ^= 3;

 

Funkcja warunkowa

Składnia:

if(warunek) instrukcja;

Instrukcja jest wykonywana, jeśli warunek jest prawdziwy.

if(warunek) instrukcja1; else instrukcja2;

Gdy warunek jest prawdziwy, zostaje wykonana tylko instrukcja 1. Gdy warunek jest fałszywy, zostaje wykonana tylko instrukcja2.

W miejsce pojedynczej instrukcji można wstawić instrukcję blokową, która zbudowana jest z klamerek zawierających dowolną liczbę instrukcji:
instrukcja {
   instrukcja;
   ...
   instrukcja;
}

Zwróć uwagę, że po klamerce zamykającej blok nie umieszczamy średnika (umieszczenie go nie jest błędne, lecz zbędne). Dzięki tej podmianie, otrzymujemy:

if(warunek)
{
   blok instrukcji wykonywanych, gdy warunek jest prawdziwy
}

 

lub

 

if(warunek)
{
   blok instrukcji wykonywanych, gdy warunek jest prawdziwy
}
else
{
   blok instrukcji wykonywanych, gdy warunek jest fałszywy
}

Instrukcja warunkowa pozwala tworzyć rozgałęzienia w programie.

 

Pętle

W języku C++ mamy trzy rodzaje pętli:

while(warunek) instrukcja;

Najpierw sprawdzany jest warunek. Jeśli jest prawdziwy, to zostaje wykonana instrukcja, po czym następuje powrót do sprawdzania warunku.

do instrukcja; while(warunek);

Najpierw zostaje wykonana instrukcja. Następnie sprawdzany jest warunek. Jeśli jest prawdziwy, to następuje powrót do wykonywania instrukcji.

for(inicjalizacja;warunek;kontynuacja) instrukcja;

Jest to pętla ogólna, którą najczęściej wykorzystuje się do zliczania obiegów. Inicjalizacja jest kodem wykonywanym przed rozpoczęciem pętli. Następnie sprawdzany jest warunek. Jeśli jest prawdziwy, to zostaje wykonana instrukcja, po czym wykonuje się kod kontynuacji i następuje powrót do sprawdzania warunku.

Przykłady:
// Instrukcja pętli warunkowej
// Koło informatyczne
// (C)2015 I LO w Tarnowie
//------------------------

#include <iostream>

using namespace std;

int main()
{
    int suma,granica,i;

    cout << "Podaj granicę: "; cin >> granica;
    cout << endl;
    i = 1;
    suma = 0;
    while(suma < granica) cout << (suma += i++) << " ";
    cout << "\n\nSuma wynosi: " << suma << endl;
}

 
// Pętla iteracyjna
// Koło informatyczne
// (C)2015 I LO w Tarnowie
//------------------------

#include <iostream>

using namespace std;

int main()
{
    int i,a,b;

    cout << "a = "; cin >> a;
    cout << "b = "; cin >> b;

    for(i = a; i <= b; i++) cout << "Obieg nr " << i << endl;

    return 0;
}

 

Resztę przypomnimy sobie w trakcie kolejnych zajęć koła. Zapraszam.



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.