Interpreter to program, który czyta i analizuje kod programu napisanego w jednym języku i na bieżąco go wykonuje.

Przykładowe interpretery, to: perl, lisp, python jak również znane programy użytkowe takie jak gnuplot, mathematica, matlab.

Kompilator to program, który tłumaczy kod napisany w jednym języku, nazywanym językiem źródłowym na równoważny mu kod napisany w innym języku nazywanym językiem wynikowym. Proces tłumaczenia nazywamy kompilacją.

Zwykle praca kompilatora składa się z następujących etapów:

• analizy leksykalnej
• wykonania poleceń preprocesora
• analizy składniowej (parsowania)
• analizy semantycznej
• optymalizacji kodu
• generowania kodu wynikowego

Kodem wynikowym nie zawsze jest kod maszynowy. Na przykład kompilator języka JAVA tłumaczy kod programu napisanego w JAVA na kod pośredni zrozumiały dla wirtualnej maszyny.

W przypadku języków C/C++ językiem wynikowym jest kod maszynowy. Nie zawiera on jednak kompletnej informacji, wystarczającej do uruchomienia i wykonania tego kodu maszynowego w środowisku systemu operacyjnego. Potrzebny jest jeszcze program zwany linkerem.

Linker (konsolidator) to program, którego zadaniem jest połączenie skompilowanych niezależnie jednostek translacji w gotowy do wykonania program.

Często większe programy dzielimy na mniejsze części, które są kompilowane oddzielnie. Pozwala to na:

• zwiększenie przejrzystości kodu
• ułatwia pracę zespołową
• ułatwia wykrywanie błędów (szukamy ich w mniejszych plikach)
• przyspiesza kompilację - nie musimy kompilować jednego wielkiego programu, tylko ten, w którym wprowadziliśmy zmiany

W kompilowanej jednostce translacji możemy korzystać z bibliotek (na przykład z biblioteki standardowej).

Zadaniem linkera jest połączenie wszystkich części składowych w jeden program wykonywalny. Nawet, jeśli kod naszego programu jest zawarty w jednym pliku źródłowym, proces generowania końcowego kodu maszynowego jest rozbity na kompilację i linkowanie.

Przykład (Pokaż/ukryj kod)

• Najprostszy kompletny program w języku C musi zawierać definicję funkcji main.
• przed funkcją main musi pojawić się słowo kluczowe int (zgodnie ze standardem języka C)
• po nazwie main występują nawiasy, w których opcjonalnie można podać listę argumentów formalnych - będzie o tym mowa pod koniec wykładu
• po nawiasach okrągłych następuje ciało funkcji main ujęte w nawiasy wąsiaste
• Ciało funkcji main składa się z ciągu instrukcji zapisanego zgodnie ze składnią i semantyką języka C.

Poniżej jest przedstawiony najprostszy poprawny program w języku C - oczywiście on "nic" nie robi.

 
  int main()
  {
 
  }
 

Słowo "nic" podaliśmy w cudzysłowie, gdyż uruchomienie każdego programu, nawet pustego, powoduje utworzenie procesu realizującego ten program. System operacyjny musi wykonać sporo operacji aby taki proces uruchomić.

Przykład - najprostszy program. (Pokaż/ukryj kod)

int main()
{
 
}
 

Programy komputerowe są zapisywane w językach, które nie są językami naturalnymi człowieka. W sytuacji, gdy w programie implementujemy skomplikowane algorytmy, kod programu może stać się mało czytelny bez dodatkowych komentarzy. Co więcej, sam autor programu po pewnym czasie ma problemy ze zrozumieniem, co właściwie robi napisany przez niego program (sam wielokrotnie tego doświadczyłem;)

Komentarz to fragment kodu źródłowego, który jest ignorowany przez analizator semantyczny kompilatora. Są to informacje, które autor programu pozostawia dla osób czytających kod programu.

W języku C/C++ komentarze definiujemy za pomocą:

• dwuznaków /* */ - każdy znak zawarty pomiędzy tymi dwuznakami jest komentarzem
• za pomocą dwuznaku // - wszystkie znaki następujące po tym dwuznaku aż do końca linii są traktowane jako komentarz
• niektóre kompilatory pozwalają na zagnieżdżanie komentarzy

 
/*
  Autor: Daniel Wilczak
  Data ostatniej modyfikacji: 9.X.2010
 
  Program ilustrujący stosowanie komentarzy 
*/
 
int main()
{
// tutaj powinna się znaleźć właściwa treść programu
}
 

Przykład - użycie komentarzy. (Pokaż/ukryj kod)

/*
  Autor: Daniel Wilczak
  Data ostatniej modyfikacji: 9.X.2010
 
  Program ilustrujacy stosowanie komentarzy 
*/
 
int main()
{
// tutaj powinna sie znalezc wlassciwa tresc programu
}
 

Analizator składniowy dopuszcza właściwie dowolne stosowanie białych znaków (spacji, tabulacji, znaków końca linii).

 
int
        main      (
  ) {
                            }
 

Powyższy program jest poprawnym kodem w C - pytanie tylko, czy jest czytelny dla człowieka?

W celu zwiększenia czytelności kodu stosuje się różnego rodzaju wcięcia

 
int main()
{
  printf("witaj w programie odliczacz");
 
  int i=10;
  while(i)
  {
    printf("odliczam %d\n",i--);
  }
}
 

Inny schemat wcięć nawiasów oznaczających bloki {}

 
int main(){
  printf("witaj w programie odliczacz");
 
  int i=10;
  while(i){
    printf("odliczam %d\n",i--);
  }
}
 

Wybór metody formatowania kodu, jak i głębokość stosowanych wcięć, zwykle zależy od indywidualnych preferencji programisty. Czasem sposób formatowania określony jest przez reguły przyjęte w zespole programistycznym.

Każdy programista popełnia błędy. Najtrudniej jest wykryć i naprawić:

• błędy wykonania programu, czyli takie, które objawiają się dopiero po uruchomieniu skompilowanego programu (program zawiesza się, doprowadza do niepożądanych sytuacji).
• błędy logiczne - program kompiluje się i wykonuje, ale zwraca błędne wyniki.

Najprostsze rodzaje błędów to te sygnalizowane przez kompilator lub linker.

• Błędy kompilacji pojawiają się wtedy, gdy program jest napisany niezgodnie ze składnią języka. Kompilacja jest wtedy przerywana a programista jest informowany o przyczynie wystąpienia błędu (log kompilacji)
  prog.c:3:1: error: 'sd' was not declared in this scope
• ostrzeżenia (Warnings) - program jest napisany zgodnie ze składnią języka i kompilacja nie jest przerywana, ale kompilator zauważył "podejrzany" fragment kodu, który może być ukrytym błędem logicznym.
  Na przykład:
  • kompilator może wyświetlić ostrzeżenie, jeśli w programie deklarujemy, że będziemy korzystać z pewnych zasobów (np. zmiennej) a tego nie robimy
  prog.c:3:7: warning: unused variable 'i'
  • jeśli sprawdzamy warunek, który zawsze jest prawdziwy lub fałszywy
  • jeśli używamy zasobów, które nie były zainicjalizowane, czyli mogą być w nieokreślonym stanie (np. niezainicjalizowana zmienna)
  prog.c:6:8: warning: 'j' is used uninitialized in this function
• Błędy linkowania mogą być zgłoszone przez linker w czasie konsolidacji. Zwykle oznaczają one, że nie dostarczyliśmy linkerowi wszystkich niezbędnych części do wygenerowania kompletnego kodu maszynowego programu wykonywalnego.
  Na przykład:
  • brak funkcji main w programie

Identyfikatory (nazwy) są stosowane do nazywania zmiennych, funkcji, typów itp. W języku C/C++ identyfikatorem może być dowolny ciąg liter (alfabetu angielskiego), cyfr oraz znaków podkreślenia przy czym

Przykłady poprawnych identyfikatorów:

• i
• stanKonta
• stanKonta1
• _stan_konta_
• _stanKonta_1
• _1_stanKonta
• bardzo_dlugi_opisowy_identyfikator
• bardzoDlugiOpisowyIdentyfikator

Dobrze dobrane identyfikatory:

• znacznie podnoszą czytelność kodu
• ułatwiają wyszukiwanie i naprawianie błędów
• świadczą o wysokiej kulturze programistycznej autora kodu

Często stosuje się pewne konwencje nazywania zmiennych (tzw. notacja węgierska).

Wielkość liter ma znaczenie - licznik, Licznik, lIcZnIk to trzy różne identyfikatory.

Słowa kluczowe to zastrzeżone słowa, które definiują składnię języka. Jak już zaznaczyliśmy wcześniej, nie mogą być one używane jako identyfikatory.

Poniższa tabela przedstawia zbiór słów kluczowych języka C/C++.

Zmienna to nazwany obszar pamięci komputera. Nazwa zmiennej musi być poprawnym identyfikatorem. Możemy użyć tej nazwy do operacji na obszarze pamięci, który ta zmienna nazywa.

 
  int i;                  // linia 1
  i=3;                    // linia 2
  float z=19.5;           // linia 3
  float g = z*i;          // linia 4
 

• W powyższym przykładzie użyliśmy dwóch słów kluczowych: int oraz float.
• Linia pierwsza programu to deklaracja i definicja zmiennej o nazwie i. Zmienna ta będzie nazywać obszar pamięci, najprawdopodobniej o rozmiarze 32 bitów, który jest przeznaczony do przechowywania liczb całkowitych od około -2 mld do 2 mld (szczegóły później). Należy podkreślić, że przy takiej definicji pamięć ta może zawierać przypadkową wartość.
• Linia druga to operacja na pamięci nazwanej i. Instrukcja ta oznacza zapisanie tej w pamięci liczby 3.
Od tej pory będziemy po prostu mówić, że podstawiamy do zmiennej i wartość 3 pamiętając, że operacja ta dotyczy pamięci, której nadaliśmy nazwę i.
• Linia trzecia, to definicja zmiennej typu float połączona z inicjalizacją, czyli nadaniem wartości początkowej 19.5. Typ float określa liczbę zmiennoprzecinkową kodowaną na 32 bitach pamięci. Typ float pozwala na przechowywanie liczb z dokładnością do około siedmiu cyfr znaczących w systemie dziesiętnym.
• Linia czwarta to deklaracja i definicja zmiennej g połączonej z inicjalizacją. Najpierw zostanie obliczona wartość wyrażenia po prawej stronie (z*i = 19.5*3 = 58.5), a później ta wartość zostanie użyta do zainicjalizowania zmiennej g

int main()
{
  float stopaProcentowa = 0.0625; // czyli 6.25%
  int iloscOkresowWRoku = 2; // 2 okresy, czyli kapitalizacja co pol roku
  float stopaProcentowaZaOkres = stopaProcentowa/iloscOkresowWRoku;
 
  float kwotaPoczatkowa = 1000;
  float pierwszaKapitalizacja = kwotaPoczatkowa*(1+stopaProcentowaZaOkres);
  float drugaKapitalizacja = pierwszaKapitalizacja*(1+stopaProcentowaZaOkres);
  // itd w przypadku wiekszej liczby okresow
 
  // mnozymy tyle razy, ile bylo okresow
  float efektywnaStopaProcentowa = 100*((1+stopaProcentowaZaOkres)*(1+stopaProcentowaZaOkres)-1);
}
 

Dotychczasowe programy przykładowe nigdy nie wyświetlały informacji o wykonanych działaniach. Aby umożliwić wypisywanie wartości zmiennych na ekran potrzebujemy skorzystać z operacji wejścia-wyjścia.

Każdy język wysokiego poziomu dostarcza podstawowych funkcji do realizacji operacji wejścia-wyjścia. Na razie, nie wchodząc w szczegóły, przyjmijmy, że:

• aby skorzystać z operacji wejścia-wyjścia trzeba dodać do naszego programu linie nr 1 i 2 (tutaj mamy mały dodatek C++, ale na razie nie chcę omawiać składni funkcji printf)
• aby wypisać tekst na ekran, używamy instrukcji jak w linii 3
• aby wypisać na ekran wartość zmiennej, używamy instrukcji jak w linii 4
• aby "przejść do nowej linii", używamy instrukcji jak w linii 5
• operacje wypisywania tekstu, zmiennej i znaku końca linii można ze sobą dowolnie łączyć - tak jak to pokazano w linii 6

 
#include <iostream>             // linia 1
using namespace std;            // linia 2
 
int main()
{
  int i=0;
  cout << "Zmienna i: ";        // linia 3
  cout << i;                    // linia 4
  cout << endl;                 // linia 5
 
  int j=10;
  cout << "j=" <<  j << endl;   // linia 6
}
 

Przykład - program z wypisaniem wartości na ekran. (Pokaż/ukryj kod)

#include <iostream>
using namespace std;
 
int main()
{
  float stopaProcentowa = 0.0625; // czyli 6.25%
  int iloscOkresowWRoku = 2; // 2 okresy, czyli kapitalizacja co pol roku
  float stopaProcentowaZaOkres = stopaProcentowa/iloscOkresowWRoku;
 
  float kwotaPoczatkowa = 1000;
  float pierwszaKapitalizacja = kwotaPoczatkowa*(1+stopaProcentowaZaOkres);
  float drugaKapitalizacja = pierwszaKapitalizacja*(1+stopaProcentowaZaOkres);
  // itd w przypadku wiekszej liczby okresow
 
  // mnozymy tyle razy, ile bylo okresow
  float efektywnaStopaProcentowa = 100*((1+stopaProcentowaZaOkres)*(1+stopaProcentowaZaOkres)-1);
 
  cout << "Koncowa kwota na rachunku po roku: " << drugaKapitalizacja << endl;
  cout << "Efektywna stopa procentowa: " << efektywnaStopaProcentowa << endl;
}
 

Typ zmiennej to w szczególności sposób, w jaki interpretowana jest pamięć określona przez tą zmienną. Widzieliśmy już, że 32-bity pamięci mogą raz tworzyć liczbę całkowitą (int), a innym razem liczbę zmiennoprzecinkową (float).

W C/C++ typy podstawowe (wbudowane) dzielimy na:

• całkowite - służą do przechowywania liczb całkowitych w różnych zakresach. Na przykład: short, int, long
• zmiennopozycyjne - służą do przechowywania liczb ułamkowych: float, double
• boolowskie (logiczne) - typ bool służy do przechowywania wartości logicznych: true, false
• znakowe - służą do przechowywania kodów znaków: char, wchar_t

Przykład - typy podstawowe i operacje na nich. (Pokaż/ukryj kod)

#include <iostream>
using namespace std;
 
int main()
{
  char z = 65;
  int a = z;
 
  cout << "Litera o kodzie " << a << " to " << z << endl;
 
  float fJeden = 1;
  float f = 10;
  double dJeden = 1;
  double d = 10;
 
  // uzyj 17 cyfr przy wypisywaniu liczb zmiennoprzecinkowych
  cout.precision(17);
 
  cout << "dzielenie 1/10 w precyzji float : " << fJeden/f<< endl;
  cout << "dzielenie 1/10 w precyzji double: " << dJeden/d<< endl;
}
 

Język C/C++ dostarcza podstawowych operatorów arytmetycznych:

• operator + oznacza dodawanie
• operator - oznacza odejmowanie
• operator * oznacza mnożenie
• operator / oznacza dzielenie
• operator % oznacza resztę z dzielenia

Powstaje pytanie, jak zachowuje się program w przypadku wykonania dzielenia przez zero

Wyrażenie powstałe w wyniku użycia operatorów arytmetycznych, np. a*b+c(d+a) nazywamy wyrażeniem arytmetycznym.

Przykład - operatory arytmetyczne i dzielenie przez zero. (Pokaż/ukryj kod)

#include <iostream>
using namespace std;
 
int main()
{
  int a = 10;
  int b = 3;
 
  cout << "a=" << a << ", b=" << b << endl;
  cout << "a+b=" << a+b << endl;
  cout << "a-b=" << a-b << endl;
  cout << "a*b=" << a*b << endl;
  cout << "a/b=" << a/b << endl;
  cout << "a%b=" << a%b << endl;
 
  // blad !!! dzielenie przez zero w typie calkowitoliczbowym powoduje przerwanie programu
  // cout << "a/0" << a/0 << endl;
 
  double d = 10;
  double z = 0;
  cout << "dla typow zmiennoprzecinkowych 10/0=" << d/z << endl;
  cout << "dla typow zmiennoprzecinkowych 0/0=" << z/z << endl;
}
 

Język C/C++ pozwala modyfikować pewne typy danych przy pomocy tak zwanych specyfikatorów: short, long, signed i unsigned.

Specyfikatory short, long

• Sugerują pojemność (dopuszczalny zakres liczb) odpowiednio niższą i wyższą niż typ podstawowy.
• To jaka rzeczywiście będzie pojemność zależy od implementacji
• Język C/C++ wymaga jedynie, by
  • short int zajmował minimum 16 bitów
  • long int zajmował minimum 32 bity
  • pojemność typu ze specyfikatorem short była nie większa niż typu podstawowego
  • pojemność typu ze specyfikatorem long była nie mniejsza niż typu podstawowego
• Oba mogą być stosowane do typu int, a tylko drugi do typu double

Specyfikatory signed, unsigned

• Określają czy jeden bit ma być przeznaczony na znak czy też nie. Wpływa to na pojemność typu.
• Mogą być stosowane do typów char i int.

Przykład - rozmiar i zakres poszczególnych typów (Pokaż/ukryj kod)

#include <climits>
#include <cfloat>
#include <iostream>
using namespace std;
 
int main()
{
  cout << "Rozmiar char       : " << sizeof(char) << endl;
  cout << "Rozmiar wchar_t    : " << sizeof(wchar_t) << endl;
 
  cout << "Rozmiar short int  : " << sizeof(short int) << endl;
  cout << "Rozmiar int        : " << sizeof(int) << endl;
  cout << "Rozmiar long int   : " << sizeof(long int) << endl;
  cout << "Rozmiar long long  : " << sizeof(long long) << endl;
 
  cout << "Rozmiar float      : " << sizeof(float) << endl;
  cout << "Rozmiar double     : " << sizeof(double) << endl;
  cout << "Rozmiar long double: " << sizeof(long double) << endl;
 
  cout << "Zakres short int         : [" << SHRT_MIN << "," << SHRT_MAX << "]" << endl;
  cout << "Zakres int               : [" << INT_MIN << "," << INT_MAX << "]" << endl;
  cout << "Zakres long long         : [" << LONG_LONG_MIN << "," << LONG_LONG_MAX << "]" << endl;
  cout << "Zakres unsigned long long: [0," << ULONG_LONG_MAX << "]" << endl;
 
  cout << "Zakres double            : [" << DBL_MIN << "," <<  DBL_MAX << "]" << endl;
}
 

W programach (dosyć często) używamy wielkości, o których wiadomo, że nie powinny się zmieniać. Typowym przykładem jest liczba π.

Możemy oczywiście zastąpić każde wystąpienie π przez np. 3.14. Rozwiązanie to ma jednak bardzo poważną wadę - jeśli uznamy, że wielkość ta powinna być podana z inną dokładnością, to będziemy musieli przeglądnąć cały program i wprowadzić odpowiednią zmianę.

Powracając do przykładu z liczbą π - możemy zdefiniować stałą pi i wykorzystywać ją tak jak każdą inną zmienną z jednym zastrzeżeniem - nie można przypisać nowej wartości do stałej

const float pi = 3.14;
 
float promien = 3;
float poleKola = pi*r*r;
float obwodKola = 2*pi*r;

Próba przypisania nowej wartości do takiej zmiennej skończy się błędem kompilacji. Oznacza to w szczególności, że takie zmienne muszą być od razu zainicjalizowane

const float pi; // BŁĄD (na ogół) stała niezainicjalizowana
prog.cpp:3:15: error: uninitialized const 'pi'

Użycie zmiennej z modyfikatorem const ma wiele zalet

• przejrzystość kodu - jawne odwołanie do nazwy zmiennej pi mówi nam, co tak naprawdę jest wykorzystywane w programie. Wpisana "na sztywno" wartość 3.14 może być równie dobrze kursem EUR/PLN.
• modyfikator const gwarantuje, że kompilator sprawdzi i zasygnalizuje wszelkie próby zmiany takiej zmiennej

  const float pi=3.14;
  pi = 3.1415;
  prog.cpp:4:8: error: assignment of read-only variable 'pi'

• w przypadku konieczności zmiany wartości stałej (np. zwiększenia dokładności z jaką podajemy π) wystarczy to zrobić w jednym miejscu programu

Przykład - użycie stałej pi (Pokaż/ukryj kod)

#include <iostream>
using namespace std;
 
int main()
{
  const float pi = 3.1415;
 
  float r = 3;
  cout << "Pole kola:" << pi*r*r << endl;
  cout << "Obwod kola: " << 2*pi*r << endl;
}
 

Powiedzieliśmy już, że zmienne to nazwane komórki pamięci. Należy rozróżnić dwa aspekty związane ze zmiennymi:

• czas życia zmiennej - jest to czas, w którym komórki pamięci są zarezerwowane dla tej zmiennej i nie zostaną przydzielone innej zmiennej
• zakres ważności zmiennej - jest to zbiór tych instrukcji programu, w których zmienna jest dostępna za pomocą identyfikatora.

Na ogół czas życia zmiennej nie pokrywa się z czasem wykonywania instrukcji, w których zmienna jest widoczna (dostępna za pomocą identyfikatora). Szczegóły przedstawimy w dalszej części kursu. Teraz odnotujemy tylko dwie podstawowe sytuacje:

• zmienna może być zadeklarowana globalnie, czyli poza wszystkimi blokami programu
• zmienna może być zadeklarowana lokalnie, czyli wewnątrz jakiegoś bloku programu

Podkreślamy, że powyższa lista nie jest kompletna - szczegóły będą w dalszej części kursu.

 
int z; // zmienna globalna, inicjalizowana zerem
 
int main()
{
  int k; // zmienna lokalna, może mieć losową wartość
}

• Zmienna typu bool może przyjmować tylko dwie wartości: true (prawda) albo false (fałsz).
• Typ bool wprowadzono do języka C++ stosunkowo niedawno.
• Język C nie stosuje specjalnego typu do przechowywania zmiennych logicznych.
• W języku C przyjmuje się, że liczba zero każdego typu reprezentuje fałsz, a liczba niezerowa prawdę.
• Dla zachowania kompatybilności z językiem C przyjęto zasadę, że wszędzie gdzie powinien być użyty typ bool, a użyto liczby, dokonywana jest konwersja zera na false, a wartości różnej od zera na true
• Przy wypisywaniu do strumienia wartość false jest reprezentowana jako zero, a true jako jeden.

Język C/C++ definiuje podstawowe operatory (bramki) logiczne. W szczególności:

• operator && oznacza koniunkcję, w C++ można użyć słowa kluczowego and
• operator || oznacza alternatywę, w C++ można użyć słowa kluczowego or
• operator ! oznacza negację, w C++ można użyć słowa kluczowego not
• operator ^ oznacza alternatywę wykluczającą, w C++ można użyć słowa kluczowego xor

Przykład użycia operatorów logicznych. (Pokaż/ukryj kod)

#include <iostream>
using namespace std;
 
int main()
{
  bool p=true;
  bool q=false;
 
  cout << "p=" << p << ", q=" << q << endl;
 
  cout << endl;
 
  cout << "p && q = " << (p && q) << endl; 
  cout << "p || q = " << (p || q) << endl; 
  cout << "p ^ q = " << (p ^ q) << endl; 
 
  cout << endl;
 
  cout << "p and q = " << (p and q) << endl; 
  cout << "p or q = " << (p or q) << endl; 
  cout << "p xor q = " << (p xor q) << endl; 
}
 

Do budowania wyrażeń logicznych używa się również operatorów porównania:

• operator > oznacza relację "większe"
• operator >= oznacza relację "większe lub równe"
• operator < oznacza relację "mniejsze"
• operator <= oznacza relację "mniejsze lub równe"
• operator == oznacza relację "równe"
• operator != oznacza relację "różne"

Operatory te zwracają prawdę lub fałsz, w zależności od tego, czy porównywane argumenty są w relacji, czy nie.

Przykład użycia operatorów porównania. (Pokaż/ukryj kod)

#include <iostream>
using namespace std;
 
int main()
{
  int p=10;
  int q=3;
 
  cout << "p=" << p << ", q=" << q << endl;
 
  cout << endl;
 
  cout << "p > q = " << (p > q) << endl; 
  cout << "p >= q = " << (p >= q) << endl; 
  cout << "p < q = " << (p < q) << endl; 
  cout << "p <= q = " << (p <= q) << endl; 
  cout << "p != q = " << (p != q) << endl; 
  cout << "p == q = " << (p == q) << endl; 
}
 

Operatory podobnie jak w matematyce nie zawsze są wykonywane w kolejności od lewej do prawej, ale mają określone priorytety.

Poznane do tej pory operatory wykonają się w następującej kolejności

1. *, / ,%
2. +, -
3. >>, << (operacje na strumieniach)
4. >, >=, <, <=
5. ==, !=
6. &&
7. ||

Pełną listę można znaleźć np. na stronie cppreference.com.

Na przykład kod

if(a+2<c||b*2==c&&a*b%c)
   cout<<a+b*c<<a-b/c<< endl;

if( (a + 2 < c) || ((b * 2 == c) && (a * b % c)) )
  cout << (a + b * c) << (a - b/c) << endl; 

Każdy język programowania udostępnia instrukcje warunkowe. Pozwalają one na sterowanie przebiegiem wykonywania programu w zależności od wartości wyrażenia logicznego.

Podstawowa instrukcja warunkowa to if, a jej podstawowa składnia jest następująca:

 
if(warunek)
  instrukcja
 

Instrukcja warunkowa if-else pozwala podać instrukcje, które będą wykonane, jeśli warunek ma wartość fałsz

 
if(warunek)
  instrukcja1
else
  instrukcja2
 

W instrukcji warunkowej to co występuje po if lub else może być pojedynczą instrukcją. Jeżeli chcemy wstawić tam więcej instrukcji musimy zgrupować je w blok ujęty w nawiasy wąsiaste.

 
if(warunek)
{
  instrukcja1
  intrukcja2
  ...
}
else
{
  instrukcja3
  instrukcja4
  ...
}
 

Przykład - instrukcja warunkowa if-else (Pokaż/ukryj kod)

#include <iostream>
using namespace std;
 
int main()
{
  int i;
  cout << "Prosze wprowadzic liczbe:" <<endl;
 
  // tak wczytujemy ze standardowego wejscia
  cin >> i;
 
  if( i>=0 and i<=10 )
  {
    cout << "Wprowadzona liczba " << i << " jest z przedzialu [0,10]" << endl;
  } else
  {
    cout << "Wprowadzona liczba " << i << " jest spoza przedzialu [0,10]" << endl;
  }
}
 
 

Czasami zapis wyrażenia można znacznie uprościć stosując operator warunkowy.
Jest on postaci

warunek ? wyrazenie1 : wyrazenie2 ;

• Jeżeli warunek ma wartość true zwracana jest wartość wyrażenia wyrazenie1, w przeciwnym wypadku zwacany jest wartość wyrażenia wyrazenie2.
• Wartości wyrażeń wyrazenie1 i wyrazenie2 powinny być tego samego typu (tak naprawde wystarczy, że istnieje niejawna konwersja do wspólnego typu).
• Jeżeli chcemy wykonać więcej niż jedna instrukcję aby wyliczyć wartość wyrażenia, możemy zamieścić listę instrukcji oddzielonych przecinkami. Wtedy wartością zwracaną jest wartość otrzymana z ewaluacji ostatniej instrukcji.

 int liczbaDniWLutym = czyPrzestepny(rok) ? 29 : 28;

  double delta = b*b - 4*a*c;
 
  // liczba rozwiazan rownania a*x^2 + b*x + c = 0
  int liczbaRozwiazan = (delta>0) ? 2 : ((delta==0) ? 1 : 0 );

Pętle to instrukcje używane, gdy zachodzi potrzeba wielokrotnego wykonywania tego samego fragmentu kodu, najczęściej dla różnych danych wejściowych.

Podstawowa pętla while ma składnię

 
  while(warunek) instrukcja;
 

Instrukcja wykonywana w pętli może być instrukcją złożoną (blokiem instrukcji).

W pętli while najpierw testowany jest warunek, a instrukcja jest wykonywana tylko wtedy, gdy warunek jest spełniony. Może się więc zdarzyć, że instrukcja nie zostanie nigdy wykonana.

Przykład użycia pętli while (Pokaż/ukryj kod)

#include <iostream>
using namespace std;
 
int main()
{
  int i = 12976512; // przykladowa liczba, rozlozymy ja na czynniki pierwsze
  int kopia = i;
 
  int j=2;
  while(j<=kopia)
  {
    if( kopia % j == 0)
    {
      cout << "Dzielnikiem " << i << " jest " << j << endl;
      kopia = kopia/j;
    } 
    else 
    {
      j++;
    }
  }
}
 
 

Pętla do-while jest bardzo podobna. W przypadku pętli do-while instrukcja wykona się co najmniej raz, później sprawdzany jest warunek.

 
  do 
    instrukcja
  while(warunek);
 

Przykład użycia pętli do-while (Pokaż/ukryj kod)

#include <iostream>
using namespace std;
 
int main()
{
  int liczba=1234;
  int podstawaSystemu = 7;
  int potega = 1;
 
  // liczymy taka potege podstawy systemu,
  // dla ktorej potega jest mniejsza od liczby
  while(potega <= liczba/podstawaSystemu)
  {
    potega = potega * podstawaSystemu;
  }
 
  do
  {
    // kolejna cyfra to wynik dzelenia liczby przez najwieksza potege 
    // podstawy systemu, nie wieksza od liczby
    int cyfra = liczba / potega;
    cout << cyfra;
 
    liczba = liczba - cyfra*potega;
    potega = potega/podstawaSystemu;
  }while(potega>0);
}
 
 

Pętla for jest najczęściej wykorzystywana, gdy z góry wiadomo ile przebiegów pętli ma się wykonać. Składnia pętli for to:

 
for(inicjalizacja; test; inkrementacja)
  instrukcja
 
// przykład
for(i=0; i<20; i=i+2)
{
  cout << i << endl;
}
 

Przykład - użycie pętli for. (Pokaż/ukryj kod)

#include <iostream>
using namespace std;
 
int main()
{
  int i;
 
  int silnia = 1;
  for(i=1;i<13;i++)
  {
    silnia = silnia * i;
    cout << i << "! = " << silnia << endl;
  }
}
 
 

Instrukcja switch to instrukcja warunkowa. Wykorzystujemy ją najczęściej gdy potrzebujemy wykonać różne instrukcje dla różnych w zależności od wartości pewnej zmiennej całkowitej.

Składnia instrukcji switch to:

 
  switch(wyrazenie_calkowitoliczbowe)
  {
    case w1 : instrukcja1
    case w2 : instrukcja2
    .....
    case wN : instrukcjaN
    default: instrukcja
  }
 

• Wartości w1, w2, ... muszą być całkowitoliczbowe i znane w czasie kompilacji.
• Najpierw obliczana jest wartość wyrażenia całkowitoliczbowego. Jeśli wartość ta jest równa wK, to sterowanie programu przeniesione jest do pierwszej instrukcjaK
• jeśli obliczone wyrażenie całkowitoliczbowe jest różne od wszystkich wK, to sterowanie jest przeniesione do instrukcji następującej po default
• Przypadki wK mogą być umieszczone w dowolnej kolejności. Należy jednak pamiętać, że jeśli wyrażenie całkowitoliczbowe będzie równe wK, to zostaną również wykonane wszystkie instrukcje następujące po instrukcjaK
• wartości wK nie mogą się powtarzać.
• można umieścić sekcję default w dowolnym miejscu lub całkiem opuścić. Jest on opcjonalny.

Instrukcja continue może być użyta tylko wewnątrz pętli. Powoduje ona:

• przerwanie wykonywania bieżącej iteracji pętli
• w przypadku pętli while i do-while powoduje skok do testowania warunku
• w przypadku pętli for powoduje skok do instrukcji inkrementacji, a następnie testowania warunku

Przykład użycia instrukcji continue (Pokaż/ukryj kod)

#include <iostream>
using namespace std;
 
int main()
{
// program wypisze wszystkie podzielniki tych dwoch liczb
  int liczba1 = 2*3*4*6*8*10*12;
  int liczba2 = 2*3*4*6*7*12;
 
  // wybieramy mniejsza z nich
  int mniejsza;
  if(liczba1 < liczba2)
    mniejsza = liczba1;
  else
    mniejsza = liczba2;
 
  // bedziemy sprawdzac podzielnosc w petli
  for(int i=1;i<=mniejsza;i++)
  {
    // jesli i nie dzieli pierwszej liczby, to nie ma po co sprawdzac drugiej, 
    // przerywamy za pomoca continue
    if(liczba1 % i != 0) 
      continue;
 
    // tutaj juz nie potrzebujemy continue, ale mozna uzyc
    if(liczba2 % i != 0)
      continue;
 
    // skoro program jest w tym miejscu, to znaczy, ze byla podzielnosc przez obie liczby
    cout << "liczba " << i << " dzieli " << liczba1 << " i " << liczba2 <<  endl;
  }
}

Instrukcja break może być użyta wewnątrz pętli lub wewnątrz instrukcji switch. Powoduje ona przerwanie wykonywania pętli lub instrukcji switch i skok do pierwszej instrukcji za pętlą lub switch.

Instrukcja switch jest najczęściej używana w połączeniu z break.

Przykład użycia instrukcji switch (Pokaż/ukryj kod)

#include <iostream>
using namespace std;
 
int main()
{
  int i;
  cout << "Wybierz opcje:" << endl; 
  cout << "1. Komputery" << endl;
  cout << "2. Aparaty fotograficzne" << endl;
  cout << "3. Konsole" << endl;
 
  cin >> i;
 
  switch(i)
  {
    case 1: cout << "jestes w menu komputery"; break;
    case 2: cout << "jestes w menu aparaty fotograficzne"; break;
    case 3: cout << "jestes w menu konsole"; break;
    default: cout << "niepoprawny wybor";
  }
}

Każda instrukcja może być poprzedzona etykietą.

 
etykieta: instrukcja
 

Etykietą może być dowolny identyfikator. Służą one do oznaczania miejsc w programie.

Instrukcja goto to instrukcja skoku. Powoduje ona przeniesienie wykonywania programu do miejsca oznaczonego etykietą. Nadużywanie instrukcji goto świadczy o bardzo złym stylu programowania. Są jednak sytuacje (raczej wyjątkowe), gdzie instrukcja goto może być użyteczna. Jest to wyjście z bardzo zagnieżdżonej pętli.

Składnia instrukcji goto to:

 
goto etykieta;
 

Przykład - użycie goto (Pokaż/ukryj kod)

/*
  Program demonstruje uzycie goto.
  Jest to zupelnie nieuzasadnione uzycie goto.
*/
 
#include <iostream>
using namespace std;
 
int main()
{
  cout << "Podaj liczbe wieksza od 10: ";
  int i;
 
poczatek:
  cin >> i;
  if(i<=10)
  {
    cout << "Podales libcze mniejsza od 10!. Sprobuj ponownie: ";
    goto poczatek;
  }
 
  cout << "Koniec programu" << endl;
}
 

Przykład - wyjście z pętli za pomocą goto (Pokaż/ukryj kod)

/*
  Przyklad uzasadnionego uzycia instrukcji goto.
  Posluzy ona do wyjscia z zagniezdzonej petli.
 
  Program sprawdza, czy pewne wyrazenie jest dodatnie 
  dla wszystkich trojek (i,j,k) z pewnego zakresu
  w przypadku napotkania wartosci ujemnej, program przerywa petle
*/
 
#include <iostream>
using namespace std;
 
int main()
{
 
  int i, j, k, wyrazenie;
 
  bool znalezionoUjemny = false;
 
  for(i=-5;i<=5;i++)
  {
    for(j=-5;j<=5;j++)
    {
      for(k=-5;k<=5;k++)
      {
        wyrazenie = i*i + i*j + j*k + i*k + k*k + j*j - 1;
        if(wyrazenie <= 0)
        {
          znalezionoUjemny = true;
          goto koniec;
        }
      }
    }
  }
 
koniec:
  if(znalezionoUjemny)
  {
    cout << "Dla i=" << i 
           << ", j=" << j
           << ", k=" << k
           << " wyrazenie ma wartosc: " << wyrazenie << endl; 
  }else
  {
    cout << "Podane wyrazenie jest zawsze dodatnie";
  }
}
 
 

Często program musi przechowywać i przetwarzać wiele elementów takiego samego typu. Mogą to być np. klienci firmy, numery telefonów, itp. Jest wiele (często całkiem skomplikowanych) sposobów przechowywania takich zbiorów danych. Jednym z najprostszych jest użycie tablic.

Tablicę możemy interpretować jako zbiór ponumerowanych obiektów tego samego typu. Mają one wspólną nazwę - jest to nazwa tablicy - a każdy element tego zbioru jest jednoznacznie wyznaczany za pomocą swojego numeru.

Instrukcja

int silnia[12];

• oznacza definicję tablicy złożonej z 12 elementów
• elementami tej tablicy będą liczby całkowite typu int

Dostęp do kolejnych elementów tablicy uzyskujemy za pomocą nazwy tablicy i numeru elementu. W poniższym przykładzie czwartemu elementowi tablicy silnia przypiszemy wartość 6. Pamiętajmy, że elementy są indeksowane od zera, zatem silnia[3] jest czwartym elementem tablicy.

silnia[0] = 1; // pierwszy element tablicy
silnia[3] = 6;

Ważne uwagi:

• Kompilator języka C/C++ nie sprawdza, czy podajemy poprawny numer elementu tablicy (np. ujemny)
• podanie niepoprawnego numeru elementu tablicy będziemy nazywać wyjściem poza tablicę
• wyjście poza tablicę jest przyczyną wielu błędów, często trudnych do wykrycia. Może się zdarzyć, że program kompiluje się i wykonuje bez błędów, ale zwraca niepoprawne wyniki.

int tablica[10]; // definicja tablicy
tablica[10] = 7; // BLAD!!! 
                 // modyfikujemy 11 element tablicy

Przykład - przekroczenie zakresu tablicy (Pokaż/ukryj kod)

#include <iostream>
 
int main(){
	int tab[10];
	int rozmiar = 10;
 
	tab[10] = 30;
	std::cout << "\n rozmiar tablicy = " << rozmiar << std::endl;
 
	return 0;
}
 

Przykład - wyliczanie symbolu Newtona (Pokaż/ukryj kod)

#include <iostream>
using namespace std;
 
int main()
{
  int n,k;
  int silnia[13];
 
  // ustalamy 0! = 1
  silnia[0] = 1;
 
  // wyliczamy pozostale wartosci
  for(k=1;k<13;k++)
  {
    silnia[k] = silnia[k-1]*k;
  }
 
  // liczymy symbol Newtona n! / (k! * (n-k)!)
 
  do
  {
    cout << "Podaj n i k (nie wieksze niz 12): ";
    cin >> n >> k;
    cout << "Symbol Newtona dla n=" << n << ", k=" << k 
 
		<< " to " << silnia[n]/silnia[k]/silnia[n-k] << endl;
 
    cout << "Czy kontynuowac (0-nie, niezero-tak)?";
    cin >> n;
 
  }while(n!=0); // mozna po prostu while(n)
 
  // co sie stanie, jesli uzytkownik poda niepoprawne wartosci n i k?
}
 

Jeśli tablica jest zadeklarowana jako zmienna globalna, to zostanie ona uzupełniona zerami jeszcze przed rozpoczęciem wykonywania programu.

Tablice zadeklarowane lokalnie mają losowe wartości. Nie można zakładać, że tablica jest wypełniona zerami. Tablicę, zarówno lokalną jak i globalną, można zainicjalizować w momencie deklaracji.

int wzrost[5]={178,191,165,180,170};

Powyższa instrukcja oznacza definicję tablicy o nazwie wzrost oraz inicjalizację wszystkich elementów tablicy podanymi w nawiasach wąsiastych wartościami.

Uwagi:

• wartości użyte do inicjalizacji nie muszą być znane w czasie kompilacji - zobacz przykład poniżej
• wartości inicjalizujących może być mniej niż elementów tablicy. Pozostałe wartości zostaną uzupełnione zerami. W poniższym przykładzie będzie zainicjalizowane wiek[3]=0 oraz wiek[4]=0

  int wiek[5]={5,7,10};

• jeśli wartości inicjalizujących jest więcej niż rozmiar tablicy, to kompilator zgłosi błąd.

  int wiek[5]={6,7,3,1,4,5,3}; // BLAD!!! za duzo elementow

• jeśli tablica jest inicjalizowana, to w definicji można pominąć jej wielkość. Kompilator wygeneruje tablicę o wielkości równej ilości elementów na liście inicjalizacyjnej.

  int wiek[]={5,7,10};

  Powyżej kompilator wygeneruje kod tworzący tablicę 3-elementową.

Przykład - inicjalizacja tablic. (Pokaż/ukryj kod)

#include <iostream>
using namespace std;
 
int main()
{
 
  // inicjalizacja wszystkich elementow tablicy
  int wzrost[5] = {178,191,165,180,170};
  cout << "wzrost[3] = " << wzrost[3] << endl;
 
 
  // Inicjalizacja wszystkich elementow tablicy wartoscia wprowadzona przez uzytkownika.
  // Wartosc ta nie moze byc znana w czasie kompilacji programu.
  int i;
  cout << "Podaj i";
  cin >> i;
  int t[2] = {i,i};
  cout << "t[0] = " <<  t[0] << endl;
 
  // automatyczne uzupelnianie zerami elementow tablicy
  int wiek[5] = {6,5,7};
  cout << "wiek[3] = " << wiek[3] << endl;
 
  // BLAD!!! zbyt dluga lista inicjalizacyjna
  // int blad[3] = {1,2,3,4};
 
  // wielkosc tablicy zostanie ustalona na 6
  int tablica[] = {1,2,3,4,5,6};
  cout << "tablica[5] = " << tablica[5] << endl;
}
 

Język C/C++ dostarcza typów wbudowanych, które służą do przechowywania znaków (liter, symboli, itp). Są to typy:

• char - jednobajtowa zmienna, która przechowuje kod ASCII znaku (standard C mówi tylko, że ma to być nie mniej niż 8 bitów)
• wchar_t - (wide character, 16 lub 32 bity) jako typ wbudowany tylko w C++ (i to od niedawna). Jest to typ pozwalający na przechowywanie rozszerzonego zestawu znaków (unicode).

Znaki możemy inicjalizować wartością liczbową (kodem ASCII) bądź też podając znak w apostrofach - zostanie on przekonwertowany na odpowiadający mu kod ASCII.

char z=65; // kod ASCII litery A
char w='A';

Niektóre znaki są bardzo często wykorzystywane, chociaż nie odpowiada im żaden znak na klawiaturze. Znaki te możemy wprowadzić do kodu źródłowego podając jawnie kod ASCII takiego znaku, lub też (zalecane) używając znaków specjalnych. Wybrane znaki specjalne:

• \t - oznacza znak tabulacji
• \n - oznacza znak końca linii
• \\ - oznacza lewy ukośnik (backslash) \
• \0 - zero, koniec napisu (będzie na następnym slajdzie)

Przykład - użycie znaków. (Pokaż/ukryj kod)

#include <iostream>
using namespace std;
 
int main()
{
  // znaki specjalne
 
  char znaki[] = {'a','\t','l','\t','a','\n','o','l','a'};
  char odpowiedz;
 
  do{
    for(int i=0;i<9;i++)
      cout << znaki[i];
 
    cout << endl << "Czy wypisac poownie (T/N)?" << endl;
    cin >> odpowiedz;
  }while(odpowiedz == 't' or odpowiedz=='T');
 
}
 

Przykład - kody ASCII. (Pokaż/ukryj kod)

#include <iostream>
using namespace std;
 
int main()
{
  for(int i=0;i<256;i++)
  {
    char z = i;
    cout << "kod\t" << i << ", znak:\t" << z << endl;    
  }
}
 

Napisy w języku C/C++ to po prostu tablice znaków. Przyjęto umowę, że koniec napisu wskazuje znak o kodzie zero (nie mylić ze znakiem zero, który ma kod 48).

Jest to bardzo użyteczna konwencja, gdyż wielkość tablicy wcale nie musi odpowiadać długości napisu. Typowa sytuacja to taka, w której deklarujemy tablicę o pewnej wielkości (bufor), po czym zapisujemy do niego tekst, np. wprowadzony przez użytkownika. Na ogół tekst jest znacznie krótszy od wielkości bufora.

char napis[] = {'D','a','n','i','e','l','\0'};

Napisy podawane w cudzysłowach

Podawanie napisów tak jak powyżej, chociaż formalnie poprawne, jest bardzo uciążliwe. Język C/C++ pozwala na wprowadzanie napisów przy pomocy znaków cudzysłowu. Każdy ciąg znaków pomiędzy znakami cudzysłowu jest napisem z automatycznie dodanym kończącym zerem.

Powyższa deklaracja tablicy napis jest funkcjonalnie równoważna z

char napis[] = "Daniel";

Znaki specjalne w cudzysłowach

Wprowadzając napis za pomocą znaków cudzysłowu możemy użyć w nim znaków specjalnych, na przykład

char napis[] = "Wykladowca:\n\tDaniel Wilczak";

Wydrukowanie tego napisu (np. za pomocą strumienia cout) da w wyniku

Wykladowca:
        Daniel Wilczak

char napis[] = "Daniel";
napis = "Roman"; //BLAD

Przykład - użycie napisów (Pokaż/ukryj kod)

#include <iostream>
using namespace std;
 
int main()
{
  char napis[] = "Wykladowca:\n\tDaniel Wilczak"; 
  cout << napis << "\n\n";
 
  char imie[64]; // bufor, o wiele za duzy
  cout << "Podaj swoje imie: ";
  cin >> imie;
  cout << "Witaj " << imie;
 
}
 

Często jest potrzeba przechowywania podobnych danych indeksowanych (numerowanych) nie jedną liczbą, a wieloma. Możemy to zilustrować za pomocą arkusza kalkulacyjnego - aby odnieść się do komórki w arkuszu musimy podać numer wiersza i kolumny.

W języku C/C++ tablica dwuwymiarowa to po prostu tablica tablic, czyli elementami jednej tablicy są inne tablice. W przypadku arkusza kalkulacyjnego:

• każdy wiersz jest tablicą komórek
• arkusz to tablica wierszy (czyli tablica tablic komórek)

Formalnie można tworzyć tablice indeksowane jeszcze większą ilością liczb (tablice tablic tablic, itp). Deklaracja tablicy dwuwymiarowej może wyglądać następująco

int arkusz[20][50];

Powyżej zadeklarowaliśmy 20-elementową tablicę, której elementami są tablice 50-elementowe (możemy sobie wyobrazić arkusz wielkości 20 na 50). Elementy takiej tablicy można odczytać lub zmienić podając dwa indeksy w nawiasach kwadratowych:

arkusz[4][5] = 7;

Inicjalizacja tablic wielowymiarowych

Tablice wielowymiarowe możemy inicjalizować za pomocą list inicjalizacyjnych. Musimy oczywiście odpowiednio pogrupować te dane za pomocą nawiasów wąsiastych.

int t[2][4] = {{1,2,3,4},{5,6,7,8}};
int k[3][4] = {{2,4},{3,7,8}};
int z[3][4] = {{2,4,0,0},{3,7,8,0},{0,0,0,0}};

Druga i trzecia deklaracja są sobie równoważne funkcjonalnie. W przypadku podania wielkości tablic, każda z nich zostanie uzupełniona zerami, jeśli danych w liście inicjalizacyjnej jest za mało.

W inicjalizowanej tablicy wielowymiarowej można pominąć jej pierwszy (i tylko pierwszy) rozmiar. Kompilator sam ustali wielkość tablicy na podstawie ilości elementów w liście inicjalizacyjnej. Poniższe dwie deklaracje dają taki sam efekt.

int t[][4] = {{1,2,3,4},{5,6,7,8}};
int z[2][4] = {{1,2,3,4},{5,6,7,8}};

Przykład - tablica tablic (Pokaż/ukryj kod)

#include <iostream>
using namespace std;
 
int main()
{
  int i,j;
 
  // deklarujemy dwuwymiarowa tablice
  // pierwszy indeks okresla numer studenta
  // drugi indeks okresla numer cwiczen z programowania
  // w tablicy mozna przechowywac obecnosc wszystkich studentow w grupie
 
  bool obecnosc[4][5] = { 
      {true,true,false,true,false},
      {false,true,false,true,false},
      {true,true,true,true,false},
      {true,true,false,true,false}
    };
 
  //wypisujemy tablice obecnosci na ekran
  cout << "Cwiczenia nr \t 1 \t 2 \t 3 \t 4 \t 5" << endl;  
  for(int nrStudenta=0; nrStudenta < 5; nrStudenta++) 
  {
    cout << "Student nr " << nrStudenta; 
    for(int nrCwiczen=0; nrCwiczen < 5; nrCwiczen++)
      cout << "\t" << (obecnosc[nrStudenta][nrCwiczen] ? "   " : " X ") ;
    cout << endl;
  }
 
  // tablica k bedzie uzupelniona zerami
  int k[3][4] = {{2,4},{3,7,8}}; 
  int z[3][4] = {{2,4,0,0},{3,7,8,0},{0,0,0,0}}; 
 
  // sprawdzamy, czy tablice maja takie same elementy
  bool saRowne = true;
  for(i=0;i<3;i++)
  {
    for(j=0;j<4;j++)
      if(k[i][j] != z[i][j])
      {
        cout << "\n\n Elementy tablic sa rozne! To nie powinno sie zdarzyc!!!\n";
        saRowne = false;
      }
  }
 
  if(saRowne)
    cout << "\n\n Tablice maja takie same elementy\n";
}
 

Typowym przykładem użycia tablicy tablic jest tablica napisów. Napis, to tablica znaków. Jeśli na przykład chcemy stworzyć tablicę imion pracowników firmy, to będzie to właśnie tablica tablic znaków.

char imiona[30][32];

Powyżej zadeklarowaliśmy tablicę, w której można zapamiętać 30 napisów (na przykład imion). Możemy ją od razu zainicjalizować

char imiona[30][32] = {"Piotr","Ewa","Marta","Adam"};

Pozostałe elementy tablicy zostaną uzupełnione zerami, co w przypadku napisów oznacza napisy puste.

Przykład - tablica napisów. (Pokaż/ukryj kod)

#include <iostream>
using namespace std;
 
int main()
{
  // stworzymy tablice 
  char imiona[5][32] = {"Adam", "Ewa","Marta","Piotr"};
  char nazwiska[][32] = {"Nowak", "Kowalska","Bosak","Adamczyk","Nieznany"};
 
  for(int i=0;i<5;i++)
    cout << imiona[i] << " " << nazwiska[i] << endl;
}
 

Gdybyśmy chcieli jednocześnie przechowywać nazwiska pracowników firmy, to możemy stworzyć oddzielną tablicę lub stworzyć tablicę trójwymiarową

char imiona[30][32];
char nazwiska[30][32];
 
// możemy też stworzyć tablicę trójwymiarową
// 30 osob, kazda ma 2 napisy (imie, nazwisko) po 32 znaki
char osoby[30][2][32];

Przykład - baza danych osób. (Pokaż/ukryj kod)

#include <iostream>
using namespace std;
 
int main()
{
  // stworzymy tablice adresow osob
  // z kazda osoba skojarzymy 4 dane:
  // imie, nawisko, miejscowosc, adres szczegolowy
  // na kazda dana zarezerwujemy 256 znakow (marnotrawstwo:)
 
  char baza[][4][256] = {
    {"Adam","Nowak","Krakow","Zamkowa 7"},
    {"Olga","Matuszak","Lublin","Torfowa 3"},
    {"Piotr","Zientarz","Tarnow","Zawila 1"},
    {"Adam","Kowalski","Nowy Sacz","Sloneczna 21"},    
    {"Piotr","Dorsz","Limanowa","Zarzecze 4"}    
  };
 
  cout << "Wyszukiwarka osob o podanym imieniu. Podaj imie:\n";
  char bufor[128];
  cin >> bufor;
 
  for(int i=0;i<5;i++)
  {
    int k=0;
    bool znalezione = true;
    // sprawdzaymy, czy podane imie jest takie samo jak w bazie
    // pamietajmy, ze napisy koncza sie zerem
    // dlatego porownujemy tablice tak dlugo, az napotkamy zero
    while(bufor[k]!=0 and znalezione)
    {
      if(bufor[k]!= baza[i][0][k])
        znalezione = false;
      k++;
    }
    if(znalezione)
    {
      // piszemy imie
      cout << baza[i][0] << " ";
      //piszemy nazwisko
      cout << baza[i][1] << " ";
      // piszemy miejscowosc
      cout << baza[i][2] << " ";
      //piszemy adres
      cout << baza[i][3] << endl;
    }
  }
}
 

Biblioteka standardowa cstring zawiera funkcje ułatwiające manipulację tablicami znaków.

Wybrane funkcje :

Przykład - napisy z wykorzystaniem cstring. (Pokaż/ukryj kod)

#include <iostream>
#include <cstring>
using namespace std;
 
int main()
{
  char imie[30], nazwisko[30];
  cout << "Podaj imie: ";
  cin >> imie;
  cout << "Podaj nazwisko: ";
  cin >> nazwisko;
 
  size_t rozmiar = strlen(imie) + 1 + strlen(nazwisko) + 1;
  char osoba[rozmiar]; 
 
  strcpy(osoba, imie);
  strcat(osoba, " ");
  strcat(osoba, nazwisko);
 
  cout << "Witaj " << osoba;
}
 

Chyba większość programów korzysta z napisów. Operacja na napisach za pomocą tablic znakowych jest wprawdzie wydajna (szybka), ale bardzo uciążliwa. Kod jest podatny na błędy, czasem trudne do wykrycia.

Biblioteka standardowa języka C++ dostarcza typu string. Nie jest to typ wbudowany!

Aby korzystać z typu string należy w programie dołączyć odpowiedni plik nagłówkowy.

#include <iostream>
#include <string> // tutaj dołączamy klasę string
using namespace std;
 
int main()
{
  string imie;
  cout << "Przedstaw sie";
  cin >> imie;
  cout << "Witaj " << imie;
}

Przykład - napisy z wykorzystaniem typu string. (Pokaż/ukryj kod)

#include <iostream>
#include <string>
using namespace std;
 
int main()
{
  string imie, nazwisko;
  cout << "Podaj imie: ";
  cin >> imie;
  cout << "Podaj nazwisko: ";
  cin >> nazwisko;
 
  string osoba = imie + " " + nazwisko; // + oznacza polaczenie napisow
 
  cout << "Witaj " << osoba;
}
 

• Wskaźniki to obiekty, które mogą pokazywać na inne obiekty.
• Zmienna wskaźnikowa to zmienna, przeznaczona do przechowywania wskaźników.
• Wskaźnik przechowuje adres pamięci, pod którym może znajdować się inny obiekt.

Wskaźnik jest typem pochodnym od jakiegoś innego typu. Jeśli T jest typem, to T* jest typem, który może przechowywać adresy obiektów typu T

// deklaracja wskaźnika,
// który może przechowywać adresy zmiennych typu int
int* p; 
 
double* d = 0;
char* s;
 

Wskaźniki puste:

Wskaźnik zawiera pewien adres pamięci - jest to liczba. Przyjęto umowę, że adres 0 oznacza adres pusty - czyli wskaźnika aktualnie nie pokazuje na żaden obiekt.

Operator adresu służy do pobierania adresu zmiennej. Wartość taką możemy przypisać do wskaźnika

int p=10;
int* wsk = &p; // & pobierze adres zmiennej p
cout << wsk;   // na ekranie zobaczymy adres zmiennej p

Operator wyłuskania ma odwrotne działanie. Służy on do odniesienia się do obiektu pokazywanego przez wskaźnik

int p = 10;
int q = 20;
int* wsk = &p;
 
cout << *wsk; // wydrukujemy p, czyli 10
wsk = &q;     // przestawiamy wskaźnik na zmienną q
cout << *wsk; // wydrukujemy q, czyli 20

Przykład - operatory adresu i wyłuskania. (Pokaż/ukryj kod)

#include <iostream>
using namespace std;
 
int main()
{
  int p = 10;
  int* wsk = &p;
 
  cout << "adres zmiennej p to " << wsk << endl;
  cout << "adres wskaznika wsk to " << &wsk << endl;
 
  int q = 20;
  // przestawiamy wskaznik
  wsk = &q;
  cout << "Adres zmiennej q to " << wsk << endl;
  cout << "wartosc zmiennej q to " << q << endl;
 
  //operator wyluskania
  *wsk = 30;
  cout << "teraz zmienna q ma wartosc " << q << endl;
}
 

Położenie symbolu * przy deklaracji wskaźnika nie ma większego znaczenia. Można użyć każdej z opcji:

int* p;
int* p;
int * p;
int*p;

Można myśleć, że int* jest nowym typem. Nie jest to jednak prawda. Zapis

int* p, q;

deklaruje zmienną wskaźnikową p oraz zwykłą zmienną q typu int. Aby zadeklarować dwie zmienne wskaźnikowe w jednej instrukcji należy obie zmienne poprzedzić symbolem *

int *p, *q;

W takiej sytuacji jest bardziej czytelne, jeśli przykleimy symbol * do nazw zmiennych.

Arytmetyka wskaźników daje równie wielkie możliwości jakie są niebezpieczeństwa związane z jej niepoprawnym używaniem.

Wskaźniki przechowują adresy obiektów. Kompilator wie, jakiego typu jest obiekt pokazywany przez wskaźnik i ile pamięci taki obiekt zajmuje. Pozwala to na wyliczenie jaki jest adres następnego, czy poprzedniego obiektu w pamięci.

Niech T będzie pewnym typem. Jeśli do wskaźnika T* p dodamy liczbę k, to wskaźnik ten przesuwa się o k*sizeof(T) bajtów. Na przykład, po wykonaniu:

int n;
int* p = &n;
p++;

wskaźnik p pokazuje adres tuż za zmienną n. Zatem zapis p++ w odniesieniu do wskaźnika należy interpretować jako "przesuń się o rozmiar jednego int" a nie o jeden bajt.

Tablice są przechowywane w ciągłym obszarze pamięci tak jak to przedstawiono poniżej.

Tablica, to tak naprawdę adres pierwszego elementu tej tablicy. Jest to stały wskaźnik, czyli taki, którego nie można przesuwać. Zawsze będzie pokazywał na pierwszy element tablicy.

Skoro tablica jest stałym wskaźnikiem, to można stosować dla niej arytmetykę wskaźników

int t[] ={0,1,2,3,4,5};
cout << t[2] << endl;
cout << *(t+2) << endl;

Ostatnią linię przykładu należy rozumieć tak: przesuń adres pierwszego elementu tablicy o dwa rozmiary obiektu int, a następnie wypisz liczbę, która tam się znajduje.

Przykład - tablica jako wskaźnik (Pokaż/ukryj kod)

#include <iostream>
using namespace std;
 
int main()
{
  int t[] = {0,1,2,3,4,5};
  cout << "Adres poczatku tablicy: " << t << endl;
 
  // Wypiszemy tablice na ekran za pomoca wskaznika
  int* p = t;
 
  while(p<t+5)
  {
    cout << "p=" << p << ", *p=" << *p << endl;
    ++p;
  }
 
  // niekonwencjonalny zapis, NIE POLECAM
  cout << "Wypisanie 3[t]: "<< 3[t] << endl;
}
 

Bardzo często pisząc program nie wiemy, jak dużo obiektów będziemy potrzebowali utworzyć. Na przykład pisząc program dla banku nie możemy zakładać, że bank może obsłużyć co najwyżej 10000 kont. A może 1000000?

Wskaźniki pozwalają na dostęp do dowolnego obszaru pamięci - mogą pokazywać na obiekty, których istnienie nie było znane w czasie kompilacji. W trakcie wykonywania programu możemy zażądać od systemu operacyjnego przydziału pewnej ilości pamięci. Jeśli w systemie jest jeszcze dostępna wolna pamięć, zostanie ona zarezerwowana a jej adres będzie zostanie przekazany do procesu, który zgłosił żądanie przydziału pamięci.

Takie obiekty będziemy nazywać dynamicznymi. Mogą być one powoływane w dowolnym momencie i usuwane z pamięci w każdym innym miejscu programu. Dostęp do takich obiektów mamy tylko za pomocą wskaźników i referencji (o tym za chwilę).

Do alokacji pamięci na stercie można użyć operatora new (to jest z C++).

int* obiekt = new int;
int* tablica = new int[50];
int* p= new int[i];

• pierwsza linia przykładu to żądanie zarezerwowania pamięci dla jednego obiektu typu int. Jego adres zostanie zapamiętany w zmiennej wskaźnikowej obiekt
• Druga linia programu przykładu to żądanie zarezerwowania pamięci dla tablicy 50 obiektów typu int
• W trzeciej linii przykładu również żądamy przydziału pamięci - tym razem jej wielkość nie jest znana w czasie kompilacji. Aktualna wartość zmiennej i (typu int) określa, ile pamięci potrzebujemy.

Usuwanie obiektów:

Obiekty zarezerwowane za pomocą new należy oddać do dyspozycji systemu operacyjnego przed zakończeniem programu (w dowolnym momencie, jeśli już przestają nam być potrzebne). Służy do tego operator delete

delete obiekt;
delete []tablica; // nie podajemy rozmiaru usuwanej tablicy!
delete []p;

Referencje pojawiły się w C++. Referencję możemy traktować jako inną nazwę na już istniejący obiekt. O wielkiej przydatności referencji przekonamy się już niedługo podczas omawiania struktur i funkcji. Na razie zapoznamy się ze składnią.

• Jeśli T jest pewnym typem, to T& określa referencję do typu T
• Zmienną referencyjną, albo krótko referencję, musimy zainicjalizować w momencie jej deklaracji (są od tego wyjątki, np. składowe klas i struktur, które są referencjami inicjalizujemy na liście inicjalizacyjnej).

int n=10;
int& ref = n;
ref = 20;
cout << n; // wypisze 20

Jak to działa?

Referencja to tak naprawdę stały wskaźnik. Składnia referencji zabrania wykonywania operacji znanych dla wskaźników: referencji nie można ustawić na inny obiekt, nie jest dostępna arytmetyka referencji. Po kompilacji (w kodzie maszynowym) referencje i wskaźniki niczym się nie różnią.

Korzystając z referencji świadomie rezygnujemy z pewnych możliwości oferowanych nam przez wskaźniki. W zamian dostajemy:

• łatwiejszą notację - nie musimy używać operatora wyłuskania do odwoływania się do obiektu
• większe bezpieczeństwo - brak arytmetyki dla referencji znacznie utrudnia popełnienie błędów związanych z niepoprawnym odwołaniem do pamięci

Przykład - referencje. (Pokaż/ukryj kod)

#include <iostream>
using namespace std;
 
int main()
{
  int p = 10;
  int& ref = p;
  int* wsk = &p;
 
  // w tym momencie zmienna p mozemy czytac 
  // i modyfikowac na 3 sposoby
 
  // za pomoca identyfikatora p
  cout << "p=" << p << endl;
 
  // za pomoca referencji
  ref = 20;
 
  // za pomoca wskaznika
  cout << "*wsk=" << *wsk << endl;
}
 

• Deklaracja zmiennej informuje kompilator, że dany identyfikator będzie używany dla obiektów podanego typu.
• Definicja jest poleceniem utworzenia w pamięci komputera obietku stosownego typu powiązanego z daną nazwą.
• Pojęcie deklaracji i definicji stosuje się do wszystkich nazw stosowanych w programie
• Pisząc w C/C++

  int wzrost;

  jednocześnie
  • dokonujemy deklaracji zmiennej: informujemy kompilator, że identyfikator wzrost będzie nazwą dla zmiennej typu int
  • definiujemy zmienna rezerwując dla niej pamięć.
• Istnieją w C++ sposoby deklarowania zmiennych bez ich definiowania, ale najczęściej łączymy deklarację z definicją.
• W C/C++ wszystkie zmienne muszą być zadeklarowane przed ich pierwszym użyciem.

W wykładzie wprowadzającym (o zmiennych lokalnych i globalnych) wprowadziliśmy dwa podstawowe terminy związane ze zmiennymi - zakres ważności oraz czas życia zmiennej.

• czas życia zmiennej - jest to czas, w którym komórki pamięci są zarezerwowane dla tej zmiennej i nie zostaną przydzielone innej zmiennej
• zakres ważności zmiennej - jest to zbiór tych instrukcji programu, w których zmienna jest dostępna za pomocą identyfikatora.

W tym rozdziale podamy bardziej szczegółową klasyfikację (chociaż ciągle niekompletną!) i informacje odnośnie czasu życia i zakresu ważności zmiennych. Wiedza taka pozwala poprawnie używać różnych typów zmiennych w czasie tworzenia programów oraz uniknąć trudnych do wykrycia błędów logicznych w programach.

Zmienne globalne, to zmienne zadeklarowane poza jakimkolwiek blokiem programu.

int g; //zmienna globalna
 
int main(){
}

Zmienne globalne

• są inicjalizowane wartością domyślną dla danego typu,
• tworzone jeszcze przed rozpoczęciem programu, a niszczone po zakończeniu działania programu.
• czas życia zmiennej globalnej to okres od utworzenia procesu przez system operacyjny, do jego zakończenia
• zakres ważności zmiennej globalnej to wszystkie bloki programu (o ile nie nastąpi jej zasłonięcie)
• nie wiemy w jakiej kolejności będą tworzone zmienne globalne

• to zmienne zadeklarowane wewnątrz dowolnego bloku { ... }
• czas życia takiej zmiennej to czas wykonywania instrukcji bloku, w którym taka zmienna została zadeklarowana. Kompilator po napotkaniu bloku generuje kod, który alokuje pamięć dla wszystkich zmiennych lokalnych tego bloku. Polega to na przesunięciu wskaźnika stosu o wielkość niezbędną do pomieszczenia na stosie wszystkich zmiennych lokalnych.
• zakres widoczności zmiennej, to instrukcje od momentu deklaracji, do końca bloku, w którym zmienna została zadeklarowana. Mamy jednak wyjątek - zmienna może zostać zasłonięta. O tym będzie za chwilę.

{               // 1
  ....
  int a;        // 2
  {             // 3
    ....
    int b;      // 4
  }             // 5
}               // 6

W przykładzie powyżej

• czas życia zmiennej a to czas wykonywania instrukcji 1-6
• czas życia zmiennej b to czas wykonywania instrukcji 3-5
• zakres widoczności zmiennej a to blok instrukcji 2-6
• zakres widoczności zmiennej b to blok instrukcji 4-5

Zmienna zadeklarowana wewnątrz bloku może być poprzedzona słowem kluczowym static. W ten sposób deklarujemy zmienne lokalne statyczne.

{
  static int a = 10;
  ...
}

Różnią się one od zwykłych zmiennych czasem życia, mianowicie:

• zakres ważności zmiennej lokalnej statycznej jest taki, jak zwykłej zmiennej lokalnej.
• czas życia zmiennej jest lokalnej statycznej taki, jak dla zmiennych globalnych.
• zmienne lokalne statyczne można inicjalizować, ale odbędzie się to tylko raz - w momencie ładowania programu do pamięci.

Po co używać zmiennych lokalnych statycznych?

• Zmienne lokalne statyczne przechowują swoją wartość nawet po opuszczeniu bloku, w którym są zadeklarowane. Zachowują się więc jak zmienne globalne.
• Z drugiej strony nie pozwalają one na dostęp do takiej zmiennej za pomocą jej identyfikatora w innych blokach programu. Oznacza to ochronę tej zmiennej przed jej niepoprawnym (często przypadkowym) użyciem w innych fragmentach programu. Zwykła zmienna globalna jest widoczna wszędzie!

Przykład - użycie zmiennej lokalnej statycznej. (Pokaż/ukryj kod)

#include <iostream>
using namespace std;
 
int main()
{
  while(true)
  {
    static int statycznyLicznik = 0;
    int licznik = 0;
    statycznyLicznik++;
    licznik++;
    cout << "Wartosc statycznego licznika = " << statycznyLicznik << endl;
    cout << "Wartosc zwyklego licznika = " << licznik << endl;
    if(statycznyLicznik > 5) break;
  }
}
 

Bardzo ważnym rodzajem obiektów są obiekty tworzone na stercie. W tym przypadku to programista sam decyduje o zakresie ważności i czasie życia obiektu.

Obiekty takie tworzymy (na przykład) przy pomocy operatorów new oraz new[]a usuwamy z pamięci przy pomocy operatorów delete oraz delete[]. W języku C alokację pamięci na stercie wykonuje się za pomocą funkcji bibliotecznych, np. malloc, realloc, itp.

{
  int* wsk = new int;
  ....
  delete wsk;
}

• W podanym przykładzie mamy dwa obiekty
• pierwszy z nich to wskaźnik wsk. Jest to zwykła zmienna lokalna.
• drugi obiekt, to ten utworzony na stercie. Nie ma on swojego identyfikatora, a dostęp do niego mamy za pomocą zmiennej wskaźnikowej.
• Czas życia obiektu utworzonego na stercie, to czas od momentu jego utworzenia przez system operacyjny po użyciu new, do czasu jego usunięcia przez system operacyjny po wykonaniu delete
• zakres ważności zmiennej zależy od konkretnego programu. Zmienna jest ważna dopóty, dopóki jest chociaż jedna zamienna (wskaźnik, referencja), za pomocą której mamy dostęp do tego obiektu

Literał jest bezpośrednim zapisem wartości dla jakiegoś typu.
Każdy typ wbudowany ma odpowiedni zestaw literałów.

int j=10;
 
int main()
{
  ....
  int i;
  for(i=0;i<10;i++)
  {
    int j = 5; // zasłaniamy zmienną globalną j
 
    ....
 
    ::j = 13; // można użyć zasłoniętej zmiennej globalnej
              // przy pomocy operatora zakresu
  }
}

#include <iostream>
using namespace std;
 
int j = 10;
 
int main()
{
  int j = 5;
  cout << "Zmienna lokalna j=" << j << endl;
  cout << "Zmienna globalna j=" << ::j << endl;
 
  // zamiana 
  j = 1000;
  ::j = 5000;
 
  cout << "Zmienna lokalna j=" << j << endl;
  cout << "Zmienna globalna j=" << ::j << endl;  
}
 

int main()
{
  ....
  int i, k=10;
  int* wsk = &k; 
  for(i=0;i<10;i++)
  {
    .... 
    int k = 5; // zasłaniamy zmienną lokalną k
 
    ....
 
    *wsk = 13; // zasłonięty obiekt jest dostępny 
               // przy pomocy wskaźnika lub referencji
  }
}

#include <iostream>
using namespace std;
 
int main()
{
  int k=10;
  int* wsk = &k;
  int& ref = k;
 
  // jakis blok
  {
    int k= 3; // zaslaniamy zmienna lokalna k
 
    cout << "Zmienna lokalna w bloku k=" << k << endl;
    cout << "Zaslonieta zmienna, dostep przez wskaznik *wsk=" << *wsk << endl;  
    cout << "Zaslonieta zmienna, dostep przez referencje ref=" << ref << endl;
 
    // BLAD kompilacji
    // brak zmiennej globalnej o takiej nazwie
    // cout << ::k << endl;
  }
}
 

TypZwracany nazwaFunkcji(TypArgumentu1, ... ,TypArgumentuN);
 
//przykłady
void wypiszElementyTablicy(string t[], int ilosc);
double poleProstokata(double bokX, double bokY);

TypZwracany nazwaFunkcji(TypArgumentu1, ... ,TypArgumentuN)
{
 // tutaj znajduje się kod funkcji
}
 
//przykład
double poleProstokata(double bokX, double bokY)
{
  return bokX * bokY;
}

#include <iostream>
using namespace std;
 
// tylko deklaracja funkcji
double poleProstokata(double bokX, double bokY);
 
int main()
{
  cout << "Podaj dwa boki prostokata: ";
  double x,y;
  cin >> x >> y;
 
  // kompilator nie zna jeszcze definicji funkcji poleProstokata
  // jednak poprawnie skompiluje funkcje main, gdyz funkcja 
  // poleProstokata zostala wczesniej zadeklarowana
  cout << "Pole postokata o bokach " << x << ", " << y << " to " << poleProstokata(x,y) << endl;
}
 
// tutaj umieszczamy definicje funkcji.
// Moglibysmy umiescic ta definicje na samym poczatku, przed funkcja main.
// To tylko przyklad pokazujacy, ze mozna rozdzielic deklaracje i definicje.
// W praktyce robi sie to BAAAAAARDZO CZESTO.
 
double poleProstokata(double bokX, double bokY)
{
  return bokX * bokY;
}
 
 

double poleProstokata(double, double);

double pole = poleProstokata(3,x);

#include <iostream>
using namespace std;
 
void funkcja(int a)
{
  cout << "Wartosc zmiennej w funkcji to a=" << a << endl;
  a++;
  cout << "Po zmodyfikowaniu wartosc zmiennej w funkcji to a=" << a << endl;
}
 
int main()
{
  int a = 10;
  cout << "Wartosc zmiennej w funkcji main a=" << a << endl;
  funkcja(a);
  cout << "Wartosc zmiennej w funkcji main po wywolaniu funkcji to a=" << a << endl;  
}
 

void funkcja(int* argument);

#include <iostream>
using namespace std;
 
void funkcja(int* w)
{
  cout << "Adres wskaznika w w funkcji to " << &w << endl; 
  cout << "Wskaznik w to " << w << endl;
  cout << "Wartosc zmiennej w funkcji to a=" << (*w) << endl;
  (*w)++;
  cout << "Po zmodyfikowaniu wartosc zmiennej w funkcji to a=" << (*w) << endl;
}
 
int main()
{
  int a = 10;
  cout << "Wartosc zmiennej w funkcji main a=" << a << endl;
  cout << "Adres zmiennej a w main to " << &a << endl;
  int* w = &a;
  cout << "adres wskaznika w main to " << &w << endl;
  funkcja(w); // uzywamy operatora & do pobrania adresu obiektu
  cout << "Wartosc zmiennej w funkcji main po wywolaniu funkcji to a=" << a << endl;  
}
 

void funkcja(int& argument);

#include <iostream>
using namespace std;
 
void funkcja(int& a)
{
  cout << "Wartosc zmiennej w funkcji to a=" << a << endl;
  a++;
  cout << "Po zmodyfikowaniu wartosc zmiennej w funkcji to a=" << a << endl;
}
 
int main()
{
  int a = 10;
  cout << "Wartosc zmiennej w funkcji main a=" << a << endl;
  funkcja(a);
  cout << "Wartosc zmiennej w funkcji main po wywolaniu funkcji to a=" << a << endl;  
}
 

void f(int t[5]);

void f(int t[]);
void f(int* t); // to samo co wyżej
 
int tablica[10];
f(tablica);

#include <iostream>
#include <string>
using namespace std;
 
void wczytaj(string t[], int n)
{
  for(int i=0;i<n;i++)
  {
    cout << "Podaj " << i <<"-ty element: ";
    cin >> t[i];
  }
}
 
void wypisz(string imie[], string nazwisko[], int n)
{
  for(int i=0;i<n;i++)
    cout << imie[i] << " " << nazwisko[i] << endl;
}
 
int main()
{
  string imie[3];
  string nazwisko[3];
 
  cout << "Podaj kolejno imiona\n";
  wczytaj(imie,3);
  cout << "Podaj kolejno nazwiska\n";
  wczytaj(nazwisko,3);
 
  wypisz(imie,nazwisko,3);
  return 0;
}
 

void f(const int& x, const int* y, const int z)
{
  x += 5;  // BŁĄD kompilacji, x jest stałą referencją
  *y += 5; // BŁĄD kompilacji, y jest wskaźnikiem do stałej
  z += 5;  // BŁĄD kompilacji, z jest stałą
  y += 5; // przesunięcie wskaźnika jest poprawne
}

#include <iostream>
#include <cmath>
using namespace std;
 
// funkcja liczy ilosc pierwiastkow rownania liniowego 
//    b*x + c = 0
// funkcja nie liczy samych pierwiastkow!
// umawiamy sie, ze wargosc -1 oznacza nieskonczenie wiele rozwiazan
int iloscRozwiazanRownaniaLiniowego(double b, double c)
{
  // jesli b!=0 to jest dokladnie jedno rozwiazanie
  if(b!=0)
    return 1;
 
  // nie potrzebujemy else!
  // jesli wykonywane sa instrukcje ponizej to znaczy,
  // ze nie nastapilo wyjscie z funkcji za pomoca return
  // zatem wiemy, ze b jest zerem
 
  // Dla b==0 rownanie jest albo sprzeczne, 
  // albo ma nieskonczenie wiele pierwiastkow.  
  if(c!=0)
    return 0; // rownanie sprzeczne, brak rozwiazan
 
  return -1; // -1 oznacza nieskonczenie wiele rozwiazan
}
 
 
// funkcja liczy ilosc pierwiastkow rzeczywistych rownania kwadratowego
//    a*x^2 + b*x + c = 0
// nie liczy samych pierwiastkow!
int iloscPierwiastkowRownaniaKwadratowego(double a, double b, double c)
{
// najpierw sprawdzamy, czy a==0. Oznaczalby to rownanie liniowe, 
// i wtedy korzystamy z poprzedniej funkcji dla rownan liniowych.
  if(a==0)
    return iloscRozwiazanRownaniaLiniowego(b,c);
 
  // nie potrzebujemy else!
  // wiemy, ze a nie jest zerem.
  double delta = b*b - 4*a*c;
 
  // jesli delta>0 to sa 2 pierwiastki
  if(delta > 0)
    return 2;
 
  // nie potrzebujemy else!
  // jesli wykonywane sa instrukcje ponizej to znaczy,
  // ze nie nastapilo wyjscie z funkcji za pomoca return
  // czyli wiemy, ze delta<=0
  if(delta < 0)
    return 0;
 
  // ponownie nie potrzebujemy else
  // pozostal przypadek delta == 0, wtedy jest jeden pierwiastek
  return 1;
}
 
int main()
{
  cout << "Podaj trzy wspolczynniki rownania kwadratowego: ";
  double a,b,c;
  cin >> a >> b >> c;
  int ilosc = iloscPierwiastkowRownaniaKwadratowego(a,b,c);
  if(ilosc>=0)
    cout << "liczba rozwiazan rownania: " << ilosc << endl;
  else
    cout << "Rownanie ma nieskonczenie wiele rozwiazan\n";
 
  return 0;
}
 

 
int* f(){
  int* result;
  ......
  return result;
}
 
const int& h(int& x){
  ...
  return x;
}

int& f()
{
  int k;
  ....
  return k; // BŁĄD! zwracamy referencję do zmiennej lokalnej
}

#include <iostream>
using namespace std;
 
 
// funkcja pomocnicza - liczy ilosc liter w napisie
// wskaznik do stalej - liczac ilosc liter nie chcemy modyfikowac napisu
int dlugoscNapisu(const char* napis)
{
  int wynik=0;
  while(napis[wynik]!=0)
    wynik++;
  return wynik;
}
 
// funkcja pomocnicza - kopiuje napis w podane miejsce
// skad to wskaznik do stalej
// kopiujac nie chcemy modyfikowac oryginalu
// dokad musi byc zwyklym wskaznikiem, tam wlasnie chcemy modyfikowac
void kopiuj(const char* skad, char* dokad)
{
  while(*skad!=0)
  {
    *dokad = *skad;
    ++dokad;
    ++skad;
  }
}
 
// funkcja laczaca dwa napisy,
// w wyniku otrzymujemy nowy napis
// argumentami sa dwa wskazniki do stalych napisow
// nie chcemy modyfikowac napisow, ktore laczymy
char* polacz(const char* napis1, const char* napis2)
{
  int dlugoscNapisu1 = dlugoscNapisu(napis1);
  int dlugoscNapisu2 = dlugoscNapisu(napis2);
 
  // alokujemy pamiec na stercie dla nowego polaczonego napisu
  // dodatkowe 1 na koncu jest potrzebne na konczace zero
  char* polaczony = new char[dlugoscNapisu1 + dlugoscNapisu2 +1];
 
  kopiuj(napis1,polaczony);
  kopiuj(napis2,polaczony+dlugoscNapisu1);
 
  // dodajemy konczace zero
  polaczony[dlugoscNapisu1 + dlugoscNapisu2] = 0;
 
  // zwracamy adres utworzonej na stercie tablicy
  // teraz zawiera ona polaczone napisy
  return polaczony;
}
 
int main()
{
  char imie[] = "Daniel ";
  char nazwisko[] ="Wilczak";
 
  char* imieINazwisko = polacz(imie,nazwisko);
  cout << imieINazwisko << endl;
 
  // zwalniamy pamiec, ktora zaalokowalismy na stercie
  // w innej funkcji!
  delete[] imieINazwisko; 
  return 0;
}
 

int funckja(int x, int y)
{
  if(warunekKoncaRekursji)
  {
    return wartoscPoczatkowaRekursji;
  }
 
  // rób coś
  .... 
 
  // wywołaj rekurencyjnie
  funkcja(a,b);
 
  // dowolną ilość razy
  funkcja(c,d);
 
}

#include <iostream>
using namespace std;
 
volatile int liczbaWywolan = 0;
 
long symbolNewtona(long n, long k)
{
  ++liczbaWywolan;
  cout << "*";
  // warunek przerwania rekursji
  if(n==0 or k==0 or n==k)
    return 1;
 
  return symbolNewtona(n-1,k) + symbolNewtona(n-1,k-1);
}
 
int main()
{
  long n = 10;
  long k = 3;
 
  (cout << "symbol newtona policzony rekurencyjnie: " << symbolNewtona(n,k) )
       << "\n\nliczba wywolan : " << liczbaWywolan << endl;
 
  // sprawdzenie - liczymy w p�tli
  long r=1;
  int i;
  for(i=k+1;i<=n;i++)
    r *= i;
  for(i=2;i<=n-k;i++)
    r /= i;
 
  cout << "\nsymbol newtona policzony w petli: " << r << endl;
}
 

inline double Farenheit2Celsius(double f)
{
  return (f-32)/9*5;
}

void sortuj(int t[], int rozmiarTablicy)
{
  ...
  // tutaj algorytm sortowania liczb całkowitych
}
 
void sortuj(string t[], int rozmiarTablicy)
{
  ...
  // tutaj algorytm sortowania napisów
}

#include <iostream>
using namespace std;
 
// pierwsza wersja funkcji wypisz
void wypisz(int tablica[], int iloscElementow)
{
  int i;
  for(i=0;i<iloscElementow-1;++i)
    cout << tablica[i] << ",";
  cout << tablica[i] << endl;
}
 
// druga wersja funkcji wypisz
void wypisz(float tablica[], int iloscElementow)
{
  int i;
  for(i=0;i<iloscElementow-1;++i)
    cout << tablica[i] << ",";
  cout << tablica[i] << endl;
}
 
// pierwsza wersja funkcji sortuj
void sortuj(int tablica[], int iloscElementow)
{
  for(int i=0;i<iloscElementow-1;i++)
  {
    for(int j=i+1;j<iloscElementow;j++)
    {
      if(tablica[i]>tablica[j])
      {
        int temp = tablica[i];
        tablica[i] = tablica[j];
        tablica[j] = temp;
      }
    }
  }
}
 
// druga wersja funkcji sortuj
void sortuj(float tablica[], int iloscElementow)
{
  for(int i=0;i<iloscElementow-1;i++)
  {
    for(int j=i+1;j<iloscElementow;j++)
    {
      if(tablica[i]>tablica[j])
      {
        int temp = tablica[i];
        tablica[i] = tablica[j];
        tablica[j] = temp;
      }
    }
  }
}
 
 
// ilustracja uzycia funkcji przeladowanych
int main()
{
  int i[] = {7,5,-1,4,5,6,1,-9,1,-4};
  float f[] = {-1,2,9,1,-5,-7,5,3,-2,6};
 
  wypisz(i,10);
  sortuj(i,10);
  wypisz(i,10);
 
  wypisz(f,10);
  sortuj(f,10);
  wypisz(f,10);
 
  return 0;
}
 

void f(int* t);
void f(int z[]);
 
void g(int x);
void g(const int z);

float max(int a, float b)
{
  if(a>b)
    return a;
  return b;
}
 
float max(float a, int b)
{
  if(a>b)
    return a;
  return b;
}
 
int main()
{
  int x = 10;
  int y = 10;
 
//  int m = max(x,y); // BLAD niejednoznacznosci
 
  int m = max( (float)x,y ); // bez bledu, jawnie podalismy konwersje
  return m;
}

void wypisz(int t[], int dlugosc, char separator=',');
 
void wypisz(int t[], int dlugosc, char separator)
{
  ....
  // ciało funkcji
}

void wypisz(int t[], int dlugosc, char separator);
void wypisz(int t[], int dlugosc);

#include <iostream>
using namespace std;
 
void wypisz(int t[], int dlugosc, char separator=',', char separatorKoncowy='\n')
{
  int i;
  for(i=0;i<dlugosc-1;i++)
    cout << t[i] << separator;
  cout << t[i] << separatorKoncowy;
}
 
int main()
{
  int tablica [] ={0,1,2,3,4,5,6,7,8,9};
 
  // korzystamy z obu wartosci domniemanych
  wypisz(tablica,10);
 
  // korzystamy z jednej (ostatniej) wartosci domniemanej
  wypisz(tablica,10,' ');
 
  // nie korzystamy z wartosci domniemanych
  wypisz(tablica,10,'<','.');
  return 0;
}
 
 

int funkcja(int a, float b, char* typ,...);

#include <iostream>
#include <cstdarg>
using namespace std;
 
void typy(const char typ[] ...)
{
  int     i = 0, integ;
  char    c, *strin;
  double  doubl;
 
  va_list ap;
 
  va_start(ap,typ);
 
  while ( (c = typ[i++]) != '\0')
  {
    switch (c)
    {
      case 'i':
      case 'I':
        integ = va_arg(ap,int);
        cout << "Liczba int   : " << integ << endl;
        break;
      case 'd':
      case 'D':
        doubl = va_arg(ap,double);
        cout << "Liczba double: " << doubl << endl;
        break;
      case 'n':
      case 'N':
        strin = va_arg(ap,char*);
        cout << "Napis        : " << strin << endl;
        break;
      default:
        cout << "Nielegalny kod typu!!!  " << endl;
        goto KONIEC;
    }
  }
 
  KONIEC:
  cout << endl;
 
  va_end(ap);
}
 
int main()
{
  typy("NxN", "Jan", 0, "Maria");
  typy("innD", 17, "Jan", "Maria", 1.);
  typy("iDdniI", 17, 19.5, 1.5, "OK", -1, 8);
}
 
 

 
 int licznik = 0;
 int f(){
   return ++licznik;
 }
 int h(int a, int b){
   cout << a << " " << b;
 }
 ...
 h(f(), f());

#include <iostream>
using namespace std;
 
void f(){}
 
int main()
{
  f();
  cout << "Adres funkcji f: " << (void*)f << endl;
  cout << "Adres funkcji main: " << (void*)main << endl;
  return 0;
}
 

int (*f)(int, float);
int (*t[5])(int, float);
void g( int (*)(double) );

int (*f)(int ile, float dlugosc);
int (*t[5])(int kierunek, float szybkosc);
void g( int (*wskf)(double x) );

#include <iostream>
using namespace std;
 
// funkcja pomocnicza
void wypisz(int tablica[], int iloscElementow)
{
  int i;
  for(i=0;i<iloscElementow-1;++i)
    cout << tablica[i] << ",";
  cout << tablica[i] << endl;
}
 
// funkcja sortujaca
// ostatnim argumentem jest wskaznik do funkcji
// ktora realizuje porownywanie
void sortuj(int tablica[], int iloscElementow, bool (*porownaj)(int,int) )
{
  for(int i=0;i<iloscElementow-1;i++)
  {
    for(int j=i+1;j<iloscElementow;j++)
    {
      if( porownaj(tablica[i],tablica[j]) ) // uzywamy wskaznika do funkcji
      {
        int temp = tablica[i];
        tablica[i] = tablica[j];
        tablica[j] = temp;
      }
    }
  }
}
 
// przykladowe funkcje porownujace
bool mniejsze(int a, int b)
{
  return a<b;
}
 
bool wieksze(int a, int b)
{
  return a>b;
}
 
bool mniejszaWartoscBezwzgledna(int a, int b)
{
  int c = a;
  int d = b;
  if(c<0) c = -c;
  if(d<0) d = -d;
 
  if(c==d) 
    return a>b;
 
  return c>d;
}
 
int main()
{
  int i[] = {7,5,-1,4,5,6,1,-9,1,-4};
  wypisz(i,10);
  sortuj(i,10,mniejsze);
  wypisz(i,10);
  cout << endl;
 
  int j[] = {7,5,-1,4,5,6,1,-9,1,-4};
  wypisz(j,10);
  sortuj(j,10,wieksze);
  wypisz(j,10);
  cout << endl;
 
  int k[] = {7,5,-1,4,5,6,1,-9,1,-4};
  wypisz(k,10);
  sortuj(k,10,mniejszaWartoscBezwzgledna);
  wypisz(k,10);
  cout << endl;
 
  return 0;
}
 

typedef unsigned long long ullong;
 
ullong n=10;

typedef bool (*WskaznikDoFuncji)(int,int);
 
void funkcja(WskaznikDoFunkcji f)
{
  ... 
  bool r = f(a,b);
}
 
WskaznikDoFunkcji g(WskaznikDoFunkcji f)
{
  ...
  bool r = f(a,b);
  return f;
}
 

#include <iostream>
using namespace std;
 
typedef bool (*LiniowyPorzadek) (int, int);
 
// funkcja pomocnicza
void wypisz(int tablica[], int iloscElementow)
{
  int i;
  for(i=0;i<iloscElementow-1;++i)
    cout << tablica[i] << ",";
  cout << tablica[i] << endl;
}
 
// pierwsza sortujaca
// ostatnim argumentem jest wskaznik do funkcji
// ktora realizuje porownywanie
void sortuj(int tablica[], int iloscElementow, LiniowyPorzadek porownaj)
{
  for(int i=0;i<iloscElementow-1;i++)
  {
    for(int j=i+1;j<iloscElementow;j++)
    {
      if( porownaj(tablica[i],tablica[j]) ) // uzywamy wskaznika do funkcji
      {
        int temp = tablica[i];
        tablica[i] = tablica[j];
        tablica[j] = temp;
      }
    }
  }
}
 
// przykladowe funkcje porownujace
bool mniejsze(int a, int b)
{
  return a<b;
}
 
bool wieksze(int a, int b)
{
  return a>b;
}
 
bool mniejszaWartoscBezwzgledna(int a, int b)
{
  int c = a;
  int d = b;
  if(c<0) c=-c;
  if(d<0) d=-d;
  if(c==d) return a > b;
  return c>d;
}
 
int main()
{
  int i[] = {7,5,-1,4,5,6,1,-9,1,-4};
  wypisz(i,10);
  sortuj(i,10,mniejsze);
  wypisz(i,10);
  cout << endl;
 
  int j[] = {7,5,-1,4,5,6,1,-9,1,-4};
  wypisz(j,10);
  sortuj(j,10,wieksze);
  wypisz(j,10);
  cout << endl;
 
  int k[] = {7,5,-1,4,5,6,1,-9,1,-4};
  wypisz(k,10);
  sortuj(k,10,mniejszaWartoscBezwzgledna);
  wypisz(k,10);
  cout << endl;
 
  return 0;
}
 

enum DzienTygodnia{nie,pon,wto,sro,czw,pia,sob};

DzienTygodnia dzienWyplaty=pia;

enum controlKeys{tab=8,enter=13};

char osoby[30][2][32];

struct [OpcjonalnaNazwaStruktury]
{
  // deklaracje zmiennych, z których składa się struktura
} [opcjonalnieListaDeklarowanychZmiennych];

struct Pracownik
{
  string imie;
  string nazwisko;
  string miejscowosc;
  string adres;
 
  string stanowisko;
  float pensjaPodstawowa;
};

Pracownik p;
Pracownik pracownicyFirmy[30];

cout << sizeof(Pracownik);

#include <iostream>
using namespace std;
 
struct Pracownik { 
  char imie[32]; 
  char nazwisko[64]; 
  char miejscowosc[64]; 
  char adres[128]; 
 
  char stanowisko[128]; 
  float pensjaPodstawowa; 
}; 
 
int main()
{
  Pracownik p;
  cout << sizeof(p) << endl;
  cout << sizeof(Pracownik) << endl;
}
 

Pracownik p;
p.pensja = 7654.99;

#include <iostream>
#include <string>
using namespace std;
 
struct Pracownik
{
  string imie;
  string nazwisko;
 
  float pensja;
 
} pracownicy[30]; 
// definiujemy strukture Pracownik
// jednoczesnie zadeklarowalismy tablice 30-elementowa
 
int main()
{
  char odpowiedz;
  int biezacy = 0;
 
  do
  {
    cout << "Wprowadzamy dane o pracownikach\n";
 
    cout << "podaj imie:";
    cin >> pracownicy[biezacy].imie;
 
    cout << "podaj nazwisko:";
    cin >> pracownicy[biezacy].nazwisko;
 
 
    cout << "podaj pensje:";
    cin >> pracownicy[biezacy].pensja;
 
    cout << "Wprowadzona osoba nr " << biezacy << " to:\n";
    cout << pracownicy[biezacy].imie 
         << " " << pracownicy[biezacy].nazwisko
         << ", pensja: " << pracownicy[biezacy].pensja
         << endl;
 
    biezacy++;
    if(biezacy >= 30) 
      break;
 
    cout << "Wprowadzamy dalej (T/N)?";
    cin >> odpowiedz;
  }while(odpowiedz=='t' or odpowiedz=='T');
  return 0;
}