C++/Wersja do druku

Programowanie w C++

Aktualna, edytowalna wersja tego podręcznika jest dostępna w Wikibooks, bibliotece wolnych podręczników pod adresem
http://pl.wikibooks.org/wiki/C%2B%2B

Całość tekstu jest objęta licencją CC-BY-SA 3.0 i jednocześnie GNU FDL 1.2.

Udziela się zezwolenia do kopiowania, rozpowszechniania lub modyfikacji tego dokumentu zgodnie z zasadami Licencji Creative Commons Uznanie autorstwa-Na tych samych warunkach 3.0 Unported lub dowolnej późniejszej wersji licencji opublikowanej przez Creative Commons, która zawiera te same elementy co niniejsza licencja. Treść licencji dostępna jest pod adresem http://creativecommons.org/licenses/by-sa/3.0/legalcode.

Udziela się zezwolenia do kopiowania, rozpowszechniania lub modyfikacji tego dokumentu zgodnie z zasadami Licencji GNU Wolnej Dokumentacji w wersji 1.2 lub dowolnej późniejszej, opublikowanej przez Free Software Foundation; nie zawiera Sekcji Niezmiennych, bez Tekstu na Przedniej Okładce i bez Tekstu na Tylnej Okładce. Kopia licencji załączona jest w sekcji zatytułowanej "GNU Free Documentation License".

Spis treści

Wstęp

1. O języku C++
   Opis i historia
2. O podręczniku
   Autorzy, źródła, jak czytać ten podręcznik

Część 1: Podstawowe mechanizmy C++

1. Przestrzenie nazw
   Wprowadzenie pojęcia przestrzeni nazw, przestrzeń nazw std
2. Zmienne
   Nowe sposoby deklaracji, kontrola typów w C++, nowe sposoby rzutowania
3. Referencje
   Porównanie ze wskaźnikami, zastosowanie do przekazywania argumentów do funkcji
4. Funkcje inline
   Krótki opis funkcji inline
5. Przeciążanie funkcji
   Po co i jak można przeciążać funkcje i jak tego nie da się robić
6. Zarządzanie pamięcią
   Jak w C++ dynamicznie zarządzać pamięcią z użyciem operatorów new i delete
7. Strumienie
   Obsługa strumieni wejścia i wyjścia, czytanie i pisanie do plików, obiekty std::istream i std::ostream

Część 2: Podstawy programowania obiektowego

1. Czym jest obiekt
   Wprowadzenie pojęcia klasy i obiektu, autorekursja, kontrola dostępu
2. Konstruktor i destruktor
   Konstruktor, konstruktor kopiujący, destruktor
3. Dziedziczenie
   Dziedziczenie prywatne, publiczne i chronione
4. Składniki statyczne
   Atrybuty i metody statyczne

Część 3: Zaawansowane programowanie obiektowe

1. Funkcje wirtualne
   Funkcje wirtualne i abstrakcyjne, wyjaśnienie polimorfizmu i dynamic_cast
2. Programowanie zorientowane obiektowo
   Wyjaśnienie idei programowania zorientowanego obiektowo
3. Obiekty stałe
   Jak tworzyć, możliwe niebezpieczeństwa, słowo kluczowe mutable
4. Przeciążanie operatorów
   Wprowadzenie przykładu klasy z kompletnym przeciążeniem operatorów
5. Konwersje obiektów
   Przeciążenie operatorów konwersji, konstruktor jako sposób konwersji, konstruktory typu explicit
6. Klasy i typy zagnieżdżone
   Tworzenie klas i typów zagnieżdżonych
7. Dziedziczenie wielokrotne
   Dziedziczenie wielokrotne, dziedziczenie wirtualne oraz problemy z nimi związane

Część 4: Zaawansowane konstrukcje językowe

1. Obsługa wyjątków
   Obsługa wyjątków w C++, funkcje unexpected() i terminate()
2. Szablony funkcji
   Szablony funkcji
3. Szablony klas
   Szablony klas, programowanie uogólnione
4. Wskaźniki do elementów składowych
   Wykorzystnie wskaźników do elementów składowych klas

Dodatek A: Biblioteka STL

1. Filozofia STL
   Jak skonstruowana jest biblioteka STL
2. String
   Korzystanie z łańcuchów znaków
3. Vector
   Korzystanie z wektorów
4. List & Slist
   Listy jedno- i dwukierunkowe
5. Set
   Korzystanie ze zbiorów
6. Map
   Korzystanie z odwzorowań
7. Stack
   Korzystanie ze stosu
8. Iteratory
   Korzystanie z iteratorów
9. Algorytmy w STL
   Jak działają algorytmy w STL
10. Inne klasy STL
    Krótkie omówienie pozostałych klas

Dodatek B

1. Przykłady
   Przykłady kodu z komentarzem
2. Ćwiczenia
   Zadania kontrolne
3. Różnice między C a C++
   Najważniejsze różnice między C a C++

Pozostałe

1. Indeks
   Indeks najważniejszych terminów
2. Zasoby
   Książki, linki do innych kursów i dokumentacji
3. Dla autorów
   Wskazówki dla osób pragnących pomóc w rozwoju podręcznika
4. Wersja do druku
   Całość książki na jednej stronie, gotowa do druku
5. Licencja
   Pełny tekst GNU Free Documentation license

Wstęp

O języku C++

C++ jest językiem wieloparadygmatowym, mającym korzenie w popularnym języku C. Na jego rozwój oddziaływało wiele języków, z których należy przede wszystkim wspomnieć Simulę i Adę. Programiści cenią go za połączenie bezkompromisowej wydajności programów wynikowych z zaawansowanymi mechanizmami umożliwiającymi programowanie na wysokim poziomie abstrakcji i kontrolę zależności między komponentami w wielkich projektach.

C++ stara się zachować kompatybilność z językiem C, ale jednocześnie udostępnia szeroki wachlarz nowych mechanizmów, m.in: programowanie obiektowe z wielokrotnym dziedziczeniem i kontrolą dostępu, dynamiczną kontrolę typów i precyzyjne rzutowanie, programowanie generyczne (uogólnione) dzięki wykorzystaniu szablonów, przeciążanie funkcji i operatorów, obsługę sytuacji wyjątkowych i zarządzanie przestrzeniami nazw. Od ostatnio powstałych konkurentów, takich jak Java i C#, wyróżnia się traktowaniem typów zdefiniowanych przez użytkownika na równi z typami wbudowanymi. Niestety, to bogactwo możliwości skutkuje rozbudowaną składnią języka, stanowiąc problem nawet dla kompilatorów (żaden popularny kompilator nie jest w pełni zgodny z obowiązującym standardem języka; stan na 2010 rok).

Nazwa C++ została zaproponowana przez Ricka Mascitti i wywodzi się z faktu, że w C wyrażenie zmienna++ oznacza inkrementację, czyli zwiększenie o jeden.

Autorem i twórcą języka C++ jest duński programista Bjarne Stroustrup, pierwsza wersja pojawiła się w 1979.

O podręczniku

O podręczniku

Podręcznik ten jest tworzonym na Wikibooks kursem języka C++. Początkowo pomyślany jako samodzielna jednostka, po dyskusji utracił część treści na rzecz podręcznika C i odtąd ma być jego w pewnym sensie przedłużeniem, bez powielania występujących tam podstaw.

Tworzenie podręcznika

Niniejszy kurs cały czas jest w fazie rozwojowej. Jako otwarty podręcznik może być edytowany przez każdego i każdy wkład będzie mile widziany. Przed wprowadzaniem poważniejszych zmian warto jednak przeczytać rozdział Dla autorów.

Autorzy

Znaczący wkład w powstanie podręcznika mają:

• Derbeth
• Felix

Bibliografia

• ISO/IEC 14882:2003 Programming Languages – C++

Jak czytać ten podręcznik

Język C++ powstał jako wzbogacenie języka C o cechy obiektowe. Ten podręcznik został podobnie pomyślany: nie jako osobna całość, ale logiczne przedłużenie podręcznika C. Co prawda, oba kursy są niezależne, ale pisząc ten podręcznik staraliśmy się nie powtarzać informacji, które były już zawarte w poprzedniej książce. Nie znajdzie tu się więc objaśnienie, czym jest kompilator, jak działa i który kompilator wybrać, czym jest funkcja i zmienna oraz podobne podstawowe informacje. Czytelnikowi zostawiamy swobodę w tym, jak podejdzie do tego podręcznika, ale zalecamy jeden z przedstawionych dalej trzech sposobów.

Pierwszy z nich to dokładne przestudiowanie kursu C a następnie zaczęcie od pierwszej części tego podręcznika, gdzie pokazujemy, co C++ zmienia w składni i co oferuje nowego. Idąc dalej, czytelnik dojdzie do programowania obiektowego. Taki sposób jest co prawda bardziej pracochłonny i wymaga większego wysiłku, ale systematyczne podejście do nauki języka powinno zaowocować dobrym uporządkowaniem informacji i większym zrozumieniem filozofii obu języków.

Możliwa jest też droga dla osób bardziej niecierpliwych. Należy wtedy szybko przejrzeć kilka początkowych rozdziałów podręcznika C, ominąć część pierwszą tego kursu i od razu zacząć od programowania obiektowego, w razie kłopotów zaglądając do Indeksu. Może to być dobra metoda dla osób zaznajomionych już z programowaniem, choć w C++ czyha na nieuważnych wiele pułapek, które trzeba nauczyć się omijać.

Trzecia możliwość to zapoznanie się z językiem c++ w kursie internetowym, zapewniam że jeżeli wpiszemy w Google hasło "kurs C++" wyświetli się nam bardzo dużo propozycji. Po skończeniu ów kursu przypomnimy sobie podstawy języka w tej książce a następnie zapoznamy się z bardziej zaawansowanymi komendami.

Część 1
Podstawy języka

Przestrzenie nazw

Słowem wstępu

Jeśli użyjemy dowolnej wyszukiwarki internetowej, to powinniśmy bez problemu znaleźć prosty, szablonowy kod napisany w C++, który wyświetla napis „Hello World!”, w tłumaczeniu na polski „Witaj Świecie!”. Spójrzmy na niego:

#include <iostream>
using namespace std;
 
int main ()
{
   cout << "Hello World!" << endl;
   return 0;
}

Zaleca się używanie znaku nowej linii (\n) zamiast manipulatora wyjścia "endl". Chyba że jest to uzasadnione: endl wymusza opróżnienie bufora, ale na przykład przy wielokrotnym zapisie na dysk może to obciążyć jego pracę.

Osoby, które już znają C, na pewno się domyślą, co mniej więcej się dzieje w tym kodzie. Najpierw, pokrótce omówimy, co ten program właściwie robi.

Za pomocą #include <iostream> dołączyliśmy plik nagłówkowy do obslugi strumieni I/O, dzięki czemu możemy wypisywać dane na ekran (ściślej: na standardowe wyjście). Dodatkowo istnieje plik nagłówkowy iostream.h. Jest to jednak nagłówek niestandardowy, pomagający zachować wsteczną zgodność.

int main( ) {...} służy zdefiniowaniu funkcji głównej, która jest zawsze uruchomiana podczas startu naszego programu.

Wyrażenie cout << umożliwia nam wypisywanie pewnych informacji. W naszym przypadku wypisaliśmy napis „Hello World!”, a następnie „przedłużyliśmy” to polecenie za pomocą operatora <<, i użyliśmy endl, który m.in. dodaje znak nowej linii.

Za pomocą return 0 informujemy system, że program może zakończyć działanie bez zgłaszania błędów.

Na koniec zostawiliśmy linię z kodem using namespace std. Aby wyjaśnić jej znaczenie, musimy omówić czym są przestrzenie nazw.

Przestrzenie nazw

Podczas pracy nad dużymi projektami, w których używa się wielu bibliotek z licznymi deklaracjami, możemy w końcu natknąć się na problem konfliktu nazw - gdy kilka obiektów, typów czy funkcji ma tę samą nazwę. Rozwiązaniem może być np. zamknięcie nazw w "zakresach", w celu oddzielenia ich. Z pomocą przychodzi nam mechanizm przestrzeni nazw.

Przestrzeń nazw jest zatem zbiorem obiektów, która ogranicza dostęp do nich - oprócz nazwy obiektu niezbędne jest też wspomnienie, z której przestrzeni nazw chcemy go użyć, obchodząc tym samym problem konfliktu nazw.

Spójrzmy na kolejny program, zmienioną wersję poprzedniego:

#include <iostream>
 
int main ()
{
   std::cout << "Hello World!" << std::endl;
   return 0;
}

Widzimy tu wyrażenie std:: pojawiające się przed cout i endl. Zapis ten oznacza, że wspomniane obiekty chcemy zaczerpnąć z przestrzeni std, a przy okazji nie obchodzi nas, czy są jakieś inne obiekty o takich nazwach. Jeśli jednak pominiemy wzmiankę o std::, pojawi się informacja o błędzie.

W przestrzeni nazw std znajdziemy mnóstwo, a wręcz cały arsenał różnych narzędzi, począwszy od pewnych bardzo przydatnych funkcji, np. sortowania, wyszukiwania, a kończywszy na tak zwanych pojemnikach (kolekcjach), które pozwalają nam w łatwy sposób przechowywać pewne wartości. Oczywiście, aby mieć dostęp do tych narzędzi, musimy dołączyć odpowiedni plik nagłówkowy, używając do tego dyrektywy #include.

Przykład pierwszy ze wstępu pokazał nam, że nie musimy za każdym razem odwoływać się do przestrzeni nazw, kiedy chcemy użyć znajdujących się w niej rzeczy. Używając using namespace PrzestrzenNazw, podpowiadamy kompilatorowi, w którym miejscu może szukać używanych przez nas obiektów i funkcji, abyśmy mogli swobodnie używać wszystkiego co się znajduje w danej przestrzeni nazw, tzn. bez dodatkowej wzmianki jak np. std::.

Oczywiście nie musimy naraz "udostępniać" wszystkiego, co jest w danej przestrzeni nazw, możemy wykorzystać także pewne wybrane elementy. Używamy do tego operacji using PrzestrzenNazw::element. Zobaczmy przykład użycia tej operacji:

#include <iostream>
 
using std::endl;
 
int main ()
{
   std::cout << "Hello World!" << endl;
   return 0;
}

Za pomocą using std::endl poinformowaliśmy kompilator, że będziemy mogli używać w kodzie endl i będziemy mieli na myśli właśnie to pochodzące z przestrzeni std. Nie wykonaliśmy tej operacji na elemencie cout (nie wstawiliśmy instrukcji using std::cout), więc musieliśmy go dalej poprzedzić nazwą przestrzeni.

W dalszej części podręcznika będzie używany zapis z przedrostkiem std::.

Tworzenie własnej przestrzeni nazw

Przestrzeń nazw tworzymy za pomocą słowa kluczowego namespace, ograniczając jej zawartość klamrami. Możemy na przykład stworzyć przestrzeń nazw HelloWorld zawierającą funkcję hello( ):

#include <iostream>
 
namespace HelloWorld
{
   void hello ()
   {
      std::cout << "Hello World!" << std::endl;
   }
}
 
int main ()
{
   HelloWorld::hello ();
   return 0;
}

Oczywiście, gdybyśmy wstawili using HelloWorld::hello lub ogólnie using namespace HelloWorld przed funkcją main (a nawet wewnątrz tej funkcji), nie musielibyśmy odwoływać się jawnie do HelloWorld, wystarczyłoby samo hello( ).

Co ciekawe, nie musimy zamieszczać zawartości naszej przestrzeni nazw w jednym, ciągłym bloku. Możemy rozbić to na kilka części:

namespace Matematyka
{
   int dodaj (int a, int b)
   {
       return a+b;
   }
 
   int odejmij (int a, int b)
   {
       return a-b;
   }
}
 
namespace Matematyka
{
   int pomnoz (int a, int b)
   {
       return a*b;
   }
 
   int podziel (int a, int b)
   {
       return a/b;
   }
}

Wówczas wewnątrz przestrzeni nazw Matematyka znajdziemy wszystkie stworzone przez nas funkcje.

Tworząc funkcję w przestrzeni nazw możemy wstawić samą deklarację, a potem w innym miejscu podać pełną definicję tej funkcji. Możemy na co najmniej dwa sposoby podać definicję pewnej funkcji - wewnątrz przestrzeni nazw lub poza nią, pisząc typ_zwracany PrzestrzenNazw::nazwa_funkcji( ), na przykład:

#include <iostream>
 
namespace Matematyka
{
   int dodaj (int a, int b);
   int odejmij (int a, int b);
}
 
using namespace std;
 
int main ()
{ 
   cout << Matematyka::dodaj (10, 20) << endl;
   return 0;
}
 
namespace Matematyka
{
   int dodaj (int a, int b)
   {
       return a+b;
   }
 
   int odejmij (int a, int b)
   {
       return a-b;
   }
}

Jak wspomniano wcześniej, ostatnie dwie definicje funkcji moglibyśmy zapisać także w ten sposób:

int Matematyka::dodaj (int a, int b)
{...}
 
int Matematyka::odejmij (int a, int b)
{...}

Przestrzeń nazw std

Wróćmy ponownie do standardowej przestrzeni nazw, jaką jest std. Dzięki plikowi nagłówkowemu iostream możemy operować na standardowym wejściu i wyjściu. Zobaczmy jak wczytywać pewne wartości do zmiennych, używając do tego cin:

#include <iostream>
 
int main ()
{
   int a, b;
   std::cout << "Podaj dwie liczby a i b" << std::endl;
 
   // wypisujemy komunikat i czekamy na wpisanie liczby a
   std::cout << "podaj a: ";
   std::cin >> a;
 
   // wypisujemy komunikat na wyjście i czekamy na wpisanie liczby b
   std::cout << "podaj b: ";
   std::cin >> b;
 
   // wypisujemy sumę tych dwóch liczb
   std::cout << "a+b= " << a+b << std::endl;
   return 0;
}

Dzięki std::cin >> możemy wczytać pewną wartość do zmiennej. Zmienna ta nie musi być liczbą, może być też np. napisem. W C++ tekst (łańcuch znaków) będziemy często przechowywali w obiektach typu string (który także znajduje się w std). Do jego obsługi będziemy musieli dołączyć do projektu bibliotekę <string>. Spójrzmy na przykład:

#include <iostream>
#include <string>
 
using std::cout;
using std::cin;
using std::endl;
 
int main ()
{
   std::string imie;
   std::string email;
   std::string informacja;
 
   // wczytujemy imię
   cout << "Podaj swoje imie: "; 
   cin >> imie;
 
   // wczytujemy email
   cout << "Podaj swój email: ";
   cin >> email;
 
   informacja = imie + " (" + email + ")";  // suma (konkatenacja) napisów
   cout << "Witaj " << informacja << endl;
 
   informacja += " czyta ten napis";
   cout << informacja << endl;
   return 0;
}

Zauważmy, jak prosto się korzysta zmienną typu string (dla wtajemniczonych jest to pewna klasa). Jeśli chcemy dodać dwa napisy, wystarczy wykorzystać operator +. Możemy także wykorzystywać operator +=, jeśli chcemy dokleić do tekstu dodatkowy napis.

Podając swoje imię jako Zdzichu, a e-mail jako zdzichu@zdzichowo.mars, zobaczymy wynik:

Podaj swoje imie: Zdzichu
Podaj swój email: zdzichu@zdzichowo.mars
Witaj Zdzichu (zdzichu@zdzichowo.mars)
Zdzichu (zdzichu@zdzichowo.mars) czyta ten napis

Więcej o stringach można przeczytać w dodatku opisującym bibliotekę STL.

Korzystanie z biblioteki standardowej C

Ponieważ język C++ jest (w pewnym uproszczeniu) rozwinięciem C, w dalszym ciągu można korzystać z biblioteki standardowej C (tzw. libc). Ze względu na zachowanie wstecznej kompatybilności, umożliwiono korzystanie z niej tak jak wcześniej w C.

#include <string.h>
 
int main (int argc, char **argv)
{
   if (argc < 2)
      return -1;
   return strcmp (argv[0], argv[1]);
}

Jednak dostępna jest też wersja libc przygotowana specjalnie dla C++. Pliki nagłówkowe są w niej inaczej nazywane, wszystkie funkcje znajdują się dodatkowo w przestrzeni nazw std. Tak więc powyższy program napisany w sposób właściwy dla C++ mógłby wyglądać następująco:

#include <cstring>  // zamiast <string.h>
 
int main (int argc, char **argv)
{
   if (argc < 2)
      return -1;
   return std::strcmp( argv[0], argv[1]);
}

Zauważmy, że:

1. dołączany plik nagłówkowy ma dodaną na początku literę c
2. dostęp do funkcji jest możliwy przez pośrednictwo przestrzeni nazw std

Reguła ta dotyczy wszystkich plików, z których składa się biblioteka standardowa C.

W swoich programach lepiej jest używać wersji przygotowanej dla C++: #include <cxxxxx>. Po pierwsze, dzięki przestrzeniom nazw unikniemy kolizji nazw z własnymi funkcjami. Po drugie, wersja ta ma wbudowaną obsługę wyjątków. Po trzecie, czasami libc przygotowana dla C wywołuje ostrzeżenia lub błędy kompilacji w kompilatorach C++.

Można też w C++ używać klasycznych nazw (z C) (stdio.h, stdlib.h, string.h, ...), ale czasami libc przygotowana dla C wywołuje ostrzeżenia lub błędy kompilacji.

Zmienne

Zanim przystąpisz do czytania tego rozdziału upewnij się, że opanowałeś już wiedzę z podręcznika C. Jest tu wykorzystywanych wiele odniesień i pojęć z tego języka.

Deklarowanie zmiennych

W języku C zmienne deklarowało się na początku bloku kodu (zwykle przed pierwszą instrukcją). W przeciwieństwie do C++ nie można było natomiast deklarować zmiennych np. w nagłówku pętli for. Poniższy przykład bez problemu powinien zadziałać w kompilatorach języka C++, natomiast starsze kompilatory C mogą go uznać za błędny:

int main ()
{
   for (int i = 0; i <= 10; ++i)
   {
      // instrukcje...
   }
}

W C++ deklaracje zmiennych mogą znajdować się w dowolnym miejscu kodu w funkcji, nie obowiązuje już zasada z C nakazująca ich deklarowanie przed właściwym kodem funkcji:

#include <iostream>
using namespace std;
 
int main ()
{
   int i;
   cin >> i;
   int j = i*i;
   cout << j;
   return 0;
}

Kontrola typów

W C++ w stosunku do C została zaostrzona kontrola typów. Teraz za każdym razem, gdy przekażemy funkcji zmienną o innym typie dostaniemy błąd od kompilatora. Główna zmiana dotyczy wskaźników na typ void*. W C były one zupełnie bezkarne i można było przydzielać wskaźniki void* do każdych innych, w C++ są na równi z innymi typami. Teoretycznie kod napisany w C powinien zostać bez problemu skompilowany w kompilatorze C++, lecz istnieje kilka rozbieżności, które czasami to uniemożliwiają. Jedna z nich dotyczy właśnie typu void*. Kod w C, bez problemu skompilowany w kompilatorze tegoż języka:

 int* wskaznik = malloc (sizeof(int));

nie zostanie skompilowany w kompilatorze C++, z powodu zaostrzonej kontroli typów. Aby sprawić, że ten kod będzie się kompilować musimy go odrobinę zmodyfikować:

 int* wskaznik = (int*) malloc (sizeof(int));

Problem został rozwiązany przy użyciu rzutowania. Co to takiego? Odpowiedź znajdziesz w dziale poniżej.

Rzutowanie

W języku C rzutowanie wyglądało w następujący sposób:

int zmienna_calkowita = (int)zmienna_rzeczywista;

W C++ nadal można używać takiego rzutowania, jest ono nazywane "rzutowaniem w stylu C". Oprócz tego C++ oferuje "rzutowanie w stylu funkcyjnym":

int zmienna_calkowita = int(zmienna_rzeczywista);

które działa dokładnie tak samo.

Oba zapisy mają jedną istotną wadę - ciężko wypatrzeć je w kodzie. Każde rzutowanie jest potencjalnym miejscem wystąpienia błędów. Jeśli byśmy chcieli przejrzeć kod źródłowy w poszukiwaniu wszystkich rzutowań, nie byłoby to łatwe, przez co usuwanie błędów z programu w stylu języka C jest utrudnione.

C++ wprowadza inny sposób zapisu, który od razu rzuca się w oczy. Dodatkowo rzutowanie podzielono na cztery typy:

static_cast 

proste rzutowanie

const_cast 

rzutowanie ze zmiennych z modyfikatorem const i volatile na zmienne bez tych modyfikatorów

reinterpret_cast 

niebezpieczne rzutowania, które zmieniają zupełnie sens interpretacji bitów w zmiennych

dynamic_cast 

rzutowanie wskaźników na obiekty

Ostatnie z tych rzutowań będzie opisane później, w rozdziale Funkcje wirtualne.

Powodem takiego podziału jest potrzeba zwiększenia bezpieczeństwa przez wyeliminowanie pomyłek. Jak to działa? Jeśli chcielibyśmy dokonać pewnego rodzaju rzutowania operatorem, który nie jest do niego przewidziany, kompilator zgłosi nam błąd. Dodatkowo, jeśli podejrzewamy, że jakiś błąd w działaniu programu wynika z rzutowania, najczęściej chodzi nam o rzutowanie konkretnego rodzaju, zatem podział rzutowań ułatwia znajdywanie takich błędów.

Nowych operatorów rzutowania używa się w następujący sposób:

int zmienna_całkowita = static_cast<int>(zmienna_rzeczywista);

podając w nawiasach ostrych typ, na który rzutujemy.

Omówimy teraz dłużej pierwsze trzy z nowych rzutowań.

Do zrobienia: dopisać dla każdego - jak używać, kiedy stosować, kiedy nie stosować, konsekwencje, przykład

Static_cast

---

Operator static_cast zapewnia wysoki poziom bezpieczeństwa, gdyż widząc static_cast kompilator używa całej swojej mądrości, żeby zagwarantować jak najsensowniejszy rezultat rzutowania, w razie potrzeby zmieniając reprezentację wartości poddanej rzutowaniu. Przykładowo przy rzutowaniu zmiennej typu int na float, bity wewnętrznej reprezentacji zostaną zmienione, tak aby reprezentowały tę samą wartość matematyczną, ale według formatu używanego dla float.

Static_cast służy w szczególności do:

• Konwersji podstawowych typów liczbowych, np. int na float.
• Konwersji zdefiniowanych przez użytkownika.
• Konwersji wskaźnika na obiekt klasy pochodnej na wskaźnik na obiekt klasy podstawowej (tak zwane rzutowanie do góry hierarchii dziedziczenia).
• Konwersji wskaźnika na obiekt klasy podstawowej na wskaźnik na obiekt klasy pochodnej (tak zwane rzutowanie w dół hierarchii).

Są też inne zastosowania, np. rzutowanie zmiennej za pomocą wyrażenia static_cast<void>(nazwa_zmiennej), które na niektórych kompilatorach pozwala uniknąć ostrzeżenia o nieużywaniu tej zmiennej.

Nie przejmuj się, jeżeli trzy ostatnie punkty powyższej listy są niezrozumiałe. Staną się zrozumiałe po przeczytaniu rozdziału o dziedziczeniu i definiowaniu konwersji typów. Ważny jest morał z przytoczenia tych zastosowań, a mianowicie fakt, że static_cast służy do najczęściej wykorzystywanych, zdefiniowanych przez standard języka i bezpiecznych rzutowań. Czwarty punkt na powyższej liście przypomina jednak o tym, że nie zawsze rzutowanie static_cast jest bezpieczne w czasie wykonania programu.

Wyjaśnienie dla zaawansowanych:

Jeśli wykonamy rzutowanie w dół na typ, który nie jest zgodny z rzeczywistym (dynamicznym) typem obiektu, rezultatem może być wysypanie się programu.

Do czego static_cast nie służy:

• Do rzutowania wskaźników na różne typy, jeśli nie ma specjalnie zdefiniowanej konwersji między tymi wskaźnikami. Przykładowo nie skompiluje się static_cast<int*>(i), jeśli zmienna i jest typu unsigned int* Nie uda się też rzutowanie ze wskaźnika na typ stały (z modyfikatorem const) na wskaźnik na typ niestały.
• Do dynamicznego sprawdzania, czy rzutowanie mogłoby się powieść (czy ma sens). Nie miałoby to sensu, bo dla static_cast sposób rzutowania jest ustalany w czasie kompilacji. Zresztą nie ma żadnej informacji o błędzie, którą można by było sprawdzić.

Przykłady poprawnego użycia static_cast:

#include <iostream>
 
int main ()
{
   int liczba = 5, liczba2 = 2;
   std::cout << "5/2 int(bez rzutowania): " << liczba/liczba2 << std::endl;
   std::cout << "5/2 float(static_cast): " 
      << static_cast<float>(liczba)/static_cast<float>(liczba2) << std::endl;
   return 0;
}

Przykłady niepoprawnego użycia static_cast:

#include <iostream>
 
int main ()
{
   std::string str = "ciag";
   std::cout << "string --> char: " << static_cast<char>(str) << std::endl;
   return 0;
}

Inne Cechy static_cast

Standard języka stwierdza również, że wyrażenia, które nie dokonują żadnej konwersji mogą być również opisane operatorem static_cast, np. int i = static_cast<int>(8);. Takie static_cast może być bezpiecznie usunięte z kodu, należy jednak uważać na usuwanie go z kodu generycznego, korzystającego z szablonów.

W powyższym wstępie i przykładach wszędzie, gdzie jest mowa o wskaźnikach, można by również mówić o referencjach. Obowiązują je te same reguły.

Należy pamiętać, że działanie rzutowania static_cast zależy tylko od takich informacji o typach, które są dostępne czasie kompilacji. Stąd słowo "static" w "static_cast". Kompilator nie dodaje "z własnej inicjatywy" kodu binarnego, więc static_cast można używać również w tzw. wąskich gardłach programu. Poprzednie zdanie celowo używa wyrażenia w cudzysłowie, bo jakiś kod oczywiście jest dodawany przez kompilator. Zazwyczaj jest to jednak tylko zmiana reprezentacji liczby lub wywołanie zdefiniowanej przez użytkownika (czyli z naszej inicjatywy) funkcji konwertującej.

reinterpret_cast

#include <iostream>
using namespace std;
 
int main(void)
{
    typedef unsigned long long ULL;
    typedef unsigned int UI;
 
    ULL a = 137438953600;
    //Liczba a w pamięci komputera:
    //00000000000000000000000000100000
    //00000000000000000000000010000000
 
    ULL* wsk_a_ll = &a;
    //ULL* wsk_a_int = static_cast<UI*>(&a); //błąd kompilatora - niedozwolone rzutowanie static_cast
    UI* wsk_a_int = reinterpret_cast<UI*>(&a);
 
    cout << *wsk_a_ll << "\n" << wsk_a_int[0] << " " << wsk_a_int[1] << "\n";
 
    return 0;
}

Wyjście programu:

137438953600
128 32

W powyższym przykładzie próbujemy udowodnić, że dowolny zaalokowany obszar pamięci możemy potraktować jako tablicę, a interpretacja danych zależy od tego, jaki jest typ wskaźnika, którym się posługujemy; tutaj kolejno (long long *) oraz (int *).

Stosowane jest rzutowanie typu "reinterpret_cast", ponieważ "static_cast" skutkuje błędem kompilacji. Samo rzutowanie jest niecodzienne i udowadnia, że "reinterpret_cast" należy używać jedynie w uzasadnionych okolicznościach.

Ćwiczenia

#include <iostream>
 
int main (int argc, char *argv[])
{
  int liczba, liczba2;
  std::cin >> liczba >> liczba2;
  double wynik = liczba / liczba2;
  std::cout << wynik << std::endl;
 
  return 0;
}

Po uruchomieniu powyższego programu i podaniu wejścia

5 2

Otrzymamy

2

Dlaczego jako wynik wyświetlana jest liczba 2 a nie 2.5? Rozwiąż problem przy użyciu rzutowania.

Referencje

Czym jest referencja?

Referencja w swym działaniu przypomina wskaźniki. Różnica polega jednak na tym, że do referencji można przypisać adres tylko raz, a jej dalsze używanie niczym się nie różni od używania zwykłej zmiennej. Operacje jakie wykona się na zmiennej referencyjnej, zostaną odzwierciedlone na zmiennej zwykłej, z której pobrano adres.

Można by pokusić się o stwierdzenie, że:

Referencja jest inną nazwą danej zmiennej.

Deklaracja referencji

Referencje deklaruje się jak zmienne z podaniem znaku &:

TypDanych & referencja

Taki zapis byłby możliwy w liście argumentów funkcji, jednak w ciele funkcji referencja musi być od razu zainicjalizowana. Zapisujemy do niej adres innej zmiennej (robi się to trochę inaczej niż w wypadku wskaźników):

TypDanych & referencja = innaZmienna;

Od tej pory można używać obu tych zmiennych zamiennie.
Poniższe przypisania dadzą więc ten sam efekt:

innaZmienna = 9;
referencja = 9;

Zobaczmy działanie referencji na konkretnym przykładzie:

int i=0;
int &ref_i=i;
cout << i;      // wypisuje 0
ref_i = 1;
cout << i;      // wypisuje 1
cout << ref_i;  // wypisuje 1

Porównajmy to z sytuacją, gdybyśmy użyli wskaźników:

int i=0;
int * wsk_i=&i;
cout << i;      // wypisuje 0
*wsk_i = 1;
cout << i;      // wypisuje 1
cout << *wsk_i; // wypisuje 1

Zauważmy, o ile wygodniejsze jest użycie referencji. Nie musimy ani pobierać adresu zmiennej (&i) by przypisać go do referencji ani też używać gwiazdki by dostać wskazywaną wartość.

Jeszcze jedną różnicą ze wskaźnikami jest ograniczenie, że referencji po przypisaniu nie można przestawić na inną zmienną. Referencja musi też być zainicjalizowana w momencie utworzenia:

int a,b;
int *wsk_a=&a, *wsk_b=&b;
int &ref_a=a, &ref_b=b;
int &ref_c; // kompilator nie zezwoli na to - referencja niezainicjalizowana
 
wsk_b = &a; // ok
ref_b = &a; // tak się nie da

Przykład przypomina też, że analogicznie jak w przypadku wskaźników znak & nie łączy się z typem tylko ze zmienną i przy deklarowaniu kilku referencji na raz trzeba wstawiać & przed każdą z nich:

int &ref_x = x, &ref_y = y;           // referencje
char *wsk_1, *wsk2; // wskazniki

Stałe referencje

Możliwe jest zadeklarowanie referencji do obiektów stałych - wtedy obiektu, do którego odnosi się referencja nie będzie można zmienić.

int i=0;
const int &ref_i=i;
cout << ref_i; // wypisze 0
ref_i = 1;     // kompilator nie pozwoli na to i zgłosi błąd

Powody, dla jakich możemy chcieć używać stałych referencji są analogiczne jak dla stałych wskaźników.

Przekazywanie argumentów przez referencję

Aby w C zmodyfikować parametr przekazywany do funkcji, musieliśmy używać wskaźników. C++ proponuje bezpieczniejszą i wygodniejszą w użyciu metodę - przekazywanie przez referencję.

Różnica między przekazywaniem przez referencję a przekazywaniem przez wskaźnik jest taka jaka miedzy referencjami i wskaźnikami, nie ma tu żadnej rewolucji. Przykład zastosowania pokazany jest poniżej:

void nie_zwieksz (int i)
{
   ++i; // tak naprawdę funkcja nie robi nic, bo zmieniona zostaje tylko lokalna kopia
}
void zwieksz_c (int *i)
{
   ++(*i); // ta funkcja jest napisana w stylu C
}
void zwieksz_cpp (int& i)
{
   ++i; // ta funkcja wykorzystuje możliwości C++
}
int main ()
{
   int a=0, b=0, c=0;
   nie_zwieksz (a);
   zwieksz_c (&b);
   zwieksz_cpp (c);
   cout << a << " " << b << " " << c; 
   // wypisze "0 1 1"
 
   return 0;
}

Funkcje inline

Funkcje inline jak można by się domyśleć z nazwy są funkcjami "w linii" w C++ znaczy to, że kompilator widząc że funkcja jest inline w miejsce jej wywołania nie wstawia jak w normalnym przypadku wskaźnika do tej funkcji w pamięci, lecz wpisuje jej kod w miejsce jej wystąpienia. Takie funkcje dalej jednak występują w pamięci komputera, dzięki czemu możemy tworzyć do nich wskaźniki i używać ich jak w przypadku zwykłych funkcji.

Użycie funkcji inline:

inline int dodaj (int, int);  //deklaracja
 
int main () 
{
   int a, b, c;
   c = dodaj (a,b);
   return 0;
}
 
inline int dodaj (int a,int b)  //definicja
{
   return a+b;
}

Rzeczywiste działanie:

int main () 
{
   int a, b, c;
   {
      c = a+b;  //podstawianie kodu funkcji
   }
   return 0;
}

Ma to zastosowanie, gdy zależy programiście na szybkości działania programu. Status inline zazwyczaj dodaje się krótkim funkcjom, nie mającym więcej niż kilkanaście linijek kodu. Czasami gdy kompilator uzna, że nasza funkcja jest zbyt długa lub wywołuje się rekurencyjnie ignoruje nasze inline. Gdy chcemy wymusić takie zachowanie to używamy np. __forceinline dla MS Visual C++. Funkcja składowa klasy zostaje natomiast automatycznie uznana za inline jeśli napiszemy jej kod bezpośrednio po jej deklaracji we wnętrzu klasy. Warto dodać że słowo inline jest słowem kluczowym w C++.

Teoretycznie makroinstrukcje języka C mają dość podobne działanie, lecz funkcje inline mają nad nimi kilka przewag:

czytelność 

makra języka C są znacznie mniej czytelne i są tak jakby "czarną owcą" w kodzie, gdyż są wplecione między różnorakie funkcje, które stanowią większość kodu, od których znacznie różnią się zapisem.

konwersja argumentów 

jako, że funkcja inline imituje zwykłą funkcję, posiada argumenty z kontrolą typów, dzięki czemu inni programiści mogą z nich łatwiej korzystać w stosunku do makroinstrukcji.

argumenty jako zmienne 

w przypadku makroinstrukcji argumenty nie są traktowane jako zmienne; to co przekażemy jako argument, jest po prostu kopiowane w miejsca użycia danego argumentu w kodzie makroinstrukcji. Funkcje inline posiadają argumenty, które są zmiennymi, co wyklucza wiele błędów.

Gdzie tu jest haczyk? Otóż jako, że kod funkcji jest wstawiany w miejsce wywołania, to jeśli wywołamy tę funkcję w 3 miejscach, dostaniemy 3 kopie kodu tejże funkcji. Jeśli przesadzimy i będziemy dodawać przedrostek inline do zbyt wielu funkcji (zwłaszcza tych dużych i często wywoływanych), plik wykonywalny może urosnąć do niebotycznych rozmiarów (co dodatkowo przedłuża czas jego uruchamiania).

Przeciążanie funkcji

W języku C++ możliwe jest utworzenie kilku różnych funkcji, które posiadają tę samą nazwę. Takie funkcje muszą różnić się od siebie ilością lub typem argumentów. Dzięki temu kompilator będzie wiedział dokładnie, którą funkcję należy wywołać. Takie funkcje nazywamy przeciążonymi (czasem również – przeładowanymi).

Przeciążanie (przeładowanie) funkcji to zabieg polegający na utworzeniu kilku funkcji o tej samej nazwie, nazywanych funkcjami przeciążonymi. Takie funkcje muszą różnić się liczbą lub typem argumentów przekazywanych do tej funkcji, dodatkowo mogą różnić się zwracanym typem.

Oto przykłady funkcji przeciążonych:

void funkcja (int);
void funkcja (std::string);
void funkcja (std::string, std::string);
// int funkcja (int);  //niedozwolone, funkcje różnią się tylko zwracanym typem
int funkcja (bool);  //dozwolone

Czasami kompilator może zabronić przeładowania, gdy uzna, że typy argumentów są zbyt podobne. Może tak się dziać na przykład w przypadku, gdy:

• użyjemy typu const T i T,
• użyjemy argumentów domyślnych.

void funkcja (int arg1, int arg2 = 0);
void funkcja (int arg1);  //to ta sama funkcja, zostanie zgłoszony błąd

Kompilator obsługuje przeciążanie przez dodanie do nazwy każdej z przeciążonych funkcji specjalnego identyfikatora, który związany jest z liczbą i typem argumentów - tak więc po etapie kompilacji wszystkie funkcje mają unikalne nazwy.

Zastosowanie

Przeciążenie funkcji stosuje się przy np. potęgowaniu:

int pot (int, int);
double pot (double, int);
void pot (int&, int);
 
int pot (int podstawa, int wykladnik)
{
   int wynik = 1;
   for (int i = 0; i < wykladnik; ++i)
      wynik = podstawa*wynik;
   return wynik;
}
 
// przeładowana funkcja I: zwraca inny typ danych i są inne parametry
double pot (double podstawa, int wykladnik)
{
   double wynik = 1;
   for (int i = 0; i < wykladnik; ++i)
      wynik = podstawa*wynik;
   return wynik;
}
 
// przeładowana funkcja II: nie zwraca danych tylko modyfikuje podstawę która jest podana przez referencję
void pot (int& podstawa, int wykladnik)
{
   int wynik = 1;
   for (int i = 0; i < wykladnik; ++i)
      wynik = podstawa*wynik;
   podstawa = wynik;
}

Argumenty domyślne

Pierwszym sposobem przeładowania są argumenty domyślne. Deklaracja funkcji wygląda tak:

int potega (int podstawa, int wykładnik = 2);

W tym przypadku, kiedy funkcje wywołamy poprzez potega(2), zostanie dodany parametr domyślny. Będzie to więc znaczyło to samo, co potega(2, 2).

Nie możemy już jednak przeciążyć tej funkcji poniższą:

int potega (int podstawa)
{
  return podstawa*podstawa;
}

W tym przypadku, gdy podamy jeden argument, kompilator nie będzie mógł określić o którą funkcję nam chodzi - dwuargumentową z jednym argumentem domyślnym, czy zwykłą jednoargumentową.

Typ argumentów

Czasem możemy chcieć, by funkcja zachowywała się zależnie od tego, jakie argumenty jej dano. Załóżmy, że piszemy własną bibliotekę do obsługi standardowego wyjścia stdout. Chcemy zrobić funkcję wypisującą różne typy danych, w tym typ łańcuchów C++.

void pisz (char);
void pisz (std::string);
void pisz (void);
 
void pisz (char a){
   printf ("%c", a);
}
void pisz (std::string a)
{
   printf ("%s", a.c_str());
}
void pisz ()
{
   printf ("\n");
}

Uwaga! Zwróćmy uwagę na wywołanie printf("%s", a.c_str()). Należy pamiętać, że pole %s oczekuje łańcucha znaków typu char*. Nie obsłuży zatem typu string, dlatego posługujemy się funkcją c_str() zwracającą napis jako tablicę char.

Szablony funkcji

W C++ dostępne są szablony. Wyobraź sobie sytuację: programista pisze funkcję obsługującą sporo typów danych. Możemy rozwiązać to przez kopiowanie funkcji w kodzie. jednak byłoby to dość uciążliwe. Możemy to zrobić krócej:

template <typename T>
T nazwaFunkcji (argumenty typu T)
{
   //do funkcji można przekazać dowolny typ danych
}

Zarządzanie pamięcią

W języku C++ do alokowania pamięci służy operator new a do zwalniania - delete. W C++ można również stosować funkcje malloc i free, jednak należy być ostrożnym. Najczęstszym błędem jest mieszanie operatorów new i delete z funkcjami malloc i free, np. zwalnianie pamięci zaalokowanej przez new przy pomocy free.

Rozważmy prosty przykład. Załóżmy, że chcemy stworzyć wektor 10 liczb typu całkowitego. Możemy to zrobić na dwa sposoby. W stylu znanym z języka C:

int *wektor = (int*) malloc (sizeof(int)*10);
free (wektor);

Albo w stylu C++:

int *wektor = new int[10];
delete [] wektor;

Od razu widać, że drugi zapis jest łatwiejszy i przyjemniejszy w użyciu. To jest podstawowa zaleta operatora new - krótszy zapis. Wystarczy wiedzieć jakiego typu ma być obiekt, który chcemy powołać do życia, nie martwiąc się o rozmiar alokowanego bloku pamięci. Za pomocą operatora new można również tworzyć tablice wielowymiarowe:

int **wektory = new int *[5];
for (int i = 0; i < 5; ++i)
   wektory[i] = new int [10];

W ten sposób stworzono tablicę dwuwymiarową którą statycznie zadeklarowalibyśmy jako:

int wektory[5][10];

Jednak w przeciwieństwie do int wektory[5][10], która jest tablicą dwuwymiarową, nasze int **wektory jest tablicą tablic i może być rozrzucone po całej pamięci.

Ilość elementów poszczególnych wymiarów nie musi być jednakowa. Można np zadeklarować tablicę taką:

int **wektory = new int *[2];
wektory[0] = new int [5];
wektory[1] = new int;

Przy takiej deklaracji pierwszy wiersz ma 5 elementów (tablica) a drugi to jeden element. Deklaracja tablic o większej ilości wymiarów przebiega podobnie:

int ***wektory;             // deklarujemy tablicę 3-wymiarową
wektory = new int **[5];    // pierwszy wymiar
wektory[0] = new int *[10]; // pierwszy element pierwszego wymiaru
wektory[1] = new int *[3];  // drugi element pierwszego wymiaru
....
wektory[0][0] = new int [3] // wymiar I = 0 -> wymiar II = 1 -> 3 elementy(tablica)
wektory[0][1] = new int [5] // wymiar I = 0 -> wymiar II = 3 -> 5 elementów(tablica)
wektory[1][0] = new int;    // wymiar I = 1 -> wymiar II = 2 -> 1 element
...

Stosując ten sposób, ogólnie można deklarować tablice n-wymiarowe bez większego problemu. Usuwanie tablic wielowymiarowych przebiega podobnie jak jednowymiarowych, z tą różnicą, że usuwanie zaczynamy od "najgłębszego" wymiaru:

delete  wektory[1][0];        // kasujemy pojedynczą zmienną
delete [] wektory[0][1];
delete [] wektory[0][0];
// II wymiar
delete [] wektory[0];
delete [] wektory[1];
// I wymiar
delete [] wektory;

Zwrócić uwagę trzeba na dwie rzeczy:

• delete [] używamy dla zmiennych tablicowych, a delete dla pojedynczych zmiennych
• Kolejność zwalniania wymiarów jest odwrotna niż ich tworzenia

Drugą zaletą jest fakt, że przy okazji alokacji pamięci możemy wywołać odpowiedni konstruktor inicjując wartości zmiennych obiektu, np.

Test *test = new Test(1,2);

zakładając, że obiekt Test posiada dwie zmienne typu całkowitego i zdefiniowany konstruktor Test(int,int).

Kolejną korzyścią jest możliwość przeciążania. Jednak to już jest temat na inny rozdział.

Część 2
Podstawy programowania obiektowego

Czym jest obiekt?

Aby odpowiedzieć na pytanie zadane w temacie, zadajmy sobie inne:

Co nazywamy obiektem w świecie rzeczywistym?

Otóż wszystko może być obiektem! Drzewa, zwierzęta, miasta, auta, ludzie...

W programowaniu również obiektem może być dowolny twór, o jakim pomyślimy. Tworząc "świat programu" można stworzyć obiekt, którego użycie będzie bardziej "namacalne" od szeregu parametrów, porozrzucanych w różnych zmiennych. To różni programowanie strukturalne od programowania obiektowego.

Projekt i twór – klasa i obiekt

Zanim stworzymy jakiś obiekt, trzeba ustalić czym ten obiekt będzie. W zależności od tego, czy chcemy stworzyć wirtualny samochód, czy samolot, należy określić dwie rzeczy:

• jakie właściwości będzie miał ten obiekt,
• jakie będzie miał metody działania.

W związku z tym, przed stworzeniem jakiegokolwiek obiektu należy przedstawić kompilatorowi jego projekt(wzorzec), czyli określić jego klasę.

Klasa to byt programistyczny określający jakie właściwości i metody będą miały obiekty, które zostaną utworzone na jej podstawie.

Jednak sam projekt nie sprawi jeszcze, że dostaniemy obiekty (to tak jakby po narysowaniu projektu domu chcieć zamieszkać na kartce papieru :-)). Trzeba jeszcze obiekt utworzyć, co oznacza po prostu deklarację obiektu na podstawie pewnej klasy:

NazwaKlasy MojObiekt;

Wygląda to jak deklaracja zwykłej zmiennej i tak jest w istocie – w C++ tworząc klasę definiuje się nowy typ danych. Podobnie jak w przypadku zmiennych, można utworzyć wiele obiektów danej klasy.

Definicja klasy

Ogólny szablon definiowania klas w C++ wygląda następująco:

 class NaszaNazwaKlasy {
       ... // pola i metody składowe klasy
     };

Po słowie kluczowym class następuje nazwa naszej klasy (prawidła jej nazywania są takie same jak dla zmiennych).
W nawiasach klamrowych umieszcza się definicje składowych klasy: pól i metod określając dla nich specyfikatory dostępu.
Należy pamiętać o średniku za klamerką zamykającą definicję klasy.

Oto przykładowa definicja klasy:

class NazwaKlasy {
       public: //pola i metody są publicznie dostępne
 
         //definiowanie pól
         int poleInt;
         float poleFloat;
 
         //deklarowanie metod
         int Metoda1();
         void Metoda2();
 
    }; //pamiętaj o średniku!

Użycie klasy

Sama definicja klasy nie wystarczy, aby uzyskać dostęp do jej składowych. Należy stworzyć obiekt. Można przyjąć, że obiekt to zmienna typu klasowego. Deklaracja obiektu:

NazwaKlasy Obiekt;

Dostęp do pól i metod uzyskuje się operatorem (.):

Obiekt.poleInt = 0;//przypisanie wartości polom
Obiekt.poleFloat = 9.04;
Obiekt.Metoda1();//wywołanie metody obiektu

W przypadku deklaracji wskaźnika do obiektu:

NazwaKlasy *ObiektWsk = new NazwaKlasy;

Analogicznie jak w przypadku wskaźników na struktury operatorem dostępu do pola/metody klasy poprzez wskaźnik do obiektu staje się ->:

ObiektWsk->poleInt = 0; //przypisanie wartości polom
ObiektWsk->poleFloat = 9.04;
ObiektWsk->Metoda1(); //wywołanie metody obiektu

Należy pamiętać o zniszczeniu obiektu przed zakończeniem działania programu (lub kiedy nie jest nam już potrzebny):

delete ObiektWsk;

Przykład

Stwórzmy klasę kostki do gry:

class Kostka{
      public:
       unsigned int wartosc;
       unsigned int maks;
       void Losuj();
     };

Po definicji klasy, zdefiniujmy jeszcze metodę Losuj() zadeklarowaną w tej klasie:

void Kostka::Losuj()
{
    wartosc = rand()%maks + 1;
}

Warto zwrócić uwagę w jaki sposób się to robi. Nazwą metody dowolnej klasy jest NazwaKlasy::NazwaMetody. Poza tym aby uzyskać dostęp do pól klasy, w której istnieje dana metoda nie stosuje się operatora wyłuskania.

Po tym można napisać resztę programu:

int main()
{
 Kostka kostkaSzescienna; //utworzenie obiektu
 kostkaSzescienna.maks = 6; //określenie maksymalnej ilosci oczek
 kostkaSzescienna.Losuj(); //losowanie
 cout << "Wylosowano:" << kostkaSzescienna.wartosc << endl;//wypisanie wyniku
 return 0;
}

Autorekursja

Wskaźnik this umożliwia jawne odwołanie się zarówno do atrybutów, jak i metod klasy. Poniższy program wymusza użycie wskaźnika this, gdyż nazwa pola jest taka sama jak nazwa argumentu metody wczytaj:

#include <iostream>
 
class KlasaThis {      
  int liczba;
public:
  void wczytaj(int liczba) {this->liczba=liczba;}
  void wypisz() {cout << liczba <<endl;}    
};
 
int main()
{
  KlasaThis ObiektThis;   
  ObiektThis.wczytaj(11);
  ObiektThis.wypisz(); 
 
  return 0;  
}

Kontrola dostępu

Istnieją trzy specyfikatory dostępu do składowych klasy:

• private (prywatny) - dostępne tylko z wnętrza danej klasy i klas/funkcji zaprzyjaźnionych.
• protected (chroniony) - dostępne z wnętrza danej klasy, klas/funkcji zaprzyjaźnionych i klas pochodnych.
• public (publiczny) - dostępne dla każdego.

Jeśli sekwencja deklaracji składowych klasy nie jest poprzedzona żadnym z powyższych specyfikatorów, to domyślnym specyfikatorem (dla kompilatora) będzie private.

Dzięki specyfikatorom dostępu inni programiści mają ułatwione korzystanie z utworzonej przez nas klasy, gdyż metody i pola, których nie powinni modyfikować, bo mogłoby to spowodować niepoprawne działanie obiektu, są oznaczone jako private lub protected i nie mogą z nich korzystać. Funkcje, które zapewniają pełną funkcjonalność klasy oznaczone są jako public i tylko do nich ma dostęp użytkownik klasy (do protected również, ale z ograniczeniami). Oto zmodyfikowany przykład z kostką, który zobrazuje cele kontroli dostępu:

class Kostka{
public :
       void Losuj();
       void Wypisz();
       int DajWartosc();
       void ZmienIloscScian(unsigned argMax);
protected:
       unsigned wartosc;
       unsigned max;
     };
 
int Kostka::DajWartosc()
{
return this->wartosc;
}
 
void Kostka::ZmienIloscScian(unsigned argMax)
{
  if(argMax> 20)
    max = 20;
  else
    max = argMax;
}

Zmodyfikowana klasa zezwala tylko na kostki maksymalnie dwudziestościenne. Ręczne modyfikacje zmiennej max są zabronione, można tego dokonać jedynie poprzez funkcję ZmienIloscScian, która zapobiega przydzieleniu większej ilości ścianek niż 20. Prywatny jest też atrybut wartość. Przecież nie chcemy aby była ona ustawiona inaczej niż przez losowanie! Dlatego możemy udostępnić jej wartość do odczytu poprzez metodę DajWartosc(), ale modyfikowana może być tylko na skutek działania metody Losuj().

Ćwiczenia

1. Napisz klasę reprezentującą człowieka. Musi on być opisany przy pomocy: imienia, nazwiska, płci, wieku, partnerki/partnera(jako wskaźnik).
2. Rozwiń klasę napisaną w 1. ćwiczeniu dodając ograniczenie, między partnerami nie może być większa niż 25% wieku starszej z nich.
3*. Jeśli zaznajomiłeś się z wektorami, dodaj kolejny parametr opisujący ludzi - zainteresowania, dodaj odpowiednią funkcję do dodawania nowych zainteresowań do listy oraz funkcję porównującą zainteresowania obu ludzi i zwracającą procent identycznych zainteresowań.

Kontrola dostępu

C++/Kontrola dostępu

Konstruktor i destruktor

Teoria

Wstęp

Pisząc klasy każdy kiedyś dotrze do momentu, w którym będzie odczuwał potrzebę napisania funkcji wykonującej jakieś niezbędne instrukcje na początku lub na końcu istnienia obiektu. W takim momencie programista powinien sięgnąć po dwa niezwykle przydatne narzędzia: konstruktory i destruktory.

Konstruktor

Konstruktor jest to funkcja w klasie, wywoływana w trakcie tworzenia każdego obiektu danej klasy. Funkcja może stać się konstruktorem gdy spełni poniższe warunki

• Ma identyczną nazwę jak nazwa klasy
• Nie zwraca żadnej wartości (nawet void)

Należy dodać że każda klasa ma swój konstruktor. Nawet jeżeli nie zadeklarujemy go jawnie zrobi to za nas kompilator (stworzy wtedy konstruktor bezparametrowy i pusty).

Mamy na przykład klasę Miesiac. Chcielibyśmy, aby każdy obiekt tej klasy tuż po utworzeniu wygenerował tablicę z nazwami dni tygodnia w zależności od miesiąca i roku. A może dało by się to zrobić w trakcie tworzenia klasy?
Przyjrzyj się poniższej klasie, oraz funkcji konstruktora:

   class Miesiac
   {
        public:
             int dni[31];
             int liczbaDni;
             string nazwa;
             Miesiac();//deklaracja konstruktora
   };
 
   Miesiac::Miesiac()//definicja konstruktora
   {
        // instrukcje tworzące 
   }

Konstruktor może też przyjmować argumenty. Jak?
To zależy od sposobu w jaki tworzymy obiekt:

• jako obiekt

   MojaKlasa obiekt(argumenty);

• jako wskaźnik do obiektu:

   MojaKlasa* wsk = new MojaKlasa(argumenty);

Teraz powyższa klasa miesiąca może być stworzona z uwzględnieniem numeru miesiąca i roku:

   class Miesiac
   {
        public:
             int dni[31];
             int liczbaDni;
             string nazwa;
             Miesiac(int numer,int rok);
   };
 
   Miesiac::Miesiac(int numer,int rok)
   {
        /* instrukcje tworzące */
   }

Aby utworzyć nowy obiekt tej klasy trzeba będzie napisać:

   Miesiac styczen2000(1,2000);

lub jako wskaźnik do obiektu:

   Miesiac* styczen2000 = new Miesiac(1,2000);

otrzymawszy w ten sposób kalendarz na styczeń.

Najczęstszą funkcją konstruktora jest inicjalizacja obiektu oraz alokacja pamięci dla dodatkowych zmiennych (w tym celu lepiej jest użyć instrukcji inicjujących, które poznasz już za chwilę).

Instrukcje inicjujące

Instrukcje inicjujące to instrukcje konstruktora spełniające specyficzne zadanie. Mianowicie mogą one zostać wywołane przez kompilator zaraz po utworzeniu klasy. Służą do inicjowania pól klasy, w tym stałych i referencji.

Jeśli nie zaimplementujemy instrukcji inicjujących, niczego nie będą one robiły.

Jeżeli chcemy zaimplementować instrukcje inicjujące, musimy po liście argumentów konstruktora, użyć dwukropka, podać nazwę pola, które chcemy zainicjować i jego wartość ujętą w nawiasy okrągłe.

 Rok()
 : miesiace(new Miesiac[12])
 , liczbaDni(7)
 /*
 zamiast średników stosuje się przecinki
 przy ostatniej instrukcji przecinka nie stosuje się
 */
 {}

Działa to podobnie jak użycie inicjowania w konstruktorze, jednak w przypadku instrukcji inicjujących pola będą zainicjowane w trakcie tworzenia klasy, a nie po utworzeniu jej obiektu.

Konstruktor kopiujący

Konstruktor kopiujący to konstruktor spełniający specyficzne zadanie. Mianowicie może on zostać wywoływany przez kompilator niejawnie jeżeli zachodzi potrzeba stworzenia drugiej instancji obiektu (np. podczas przekazywania obiektu do funkcji przez wartość).

Jeżeli nie zaimplementujemy konstruktora kopiującego, kompilator zrobi to automatycznie. Konstruktor taki będzie po prostu tworzył drugą instancję wszystkich pól obiektu. Możemy go jawnie wywołać np. tak:

 Miesiac miesiac(12,2005);
 Miesiac kopia(miesiac); //tu zostanie wywołany konstruktor kopiujący
 /* obiekt kopia będzie miał taką samą zawartość jak obiekt miesiąc */

Jeżeli chcemy sami zaimplementować konstruktor kopiujący musimy zadeklarować go jako konstruktor o jednym parametrze będącym referencją na obiekt tej samej klasy.

   class Miesiac
   {
        public:
             int numer;
             int rok;
             Miesiac(const Miesiac &miesiac)
             {
                  numer=miesiac.numer;
                  rok=miesiac.rok;
             }
   };

Porada Jeżeli dokonujemy w instrukcjach inicjujących alokacji pamięci, np: class Rok { protected: Miesiac *miesiace; public: Rok() : miesiace(new Miesiac[12]) {} virtual ~Rok() {delete[] miesiace;} }; to nie możemy się zdać na konstruktor kopiujący tworzony niejawnie. Jeżeli tak zrobimy, to w obiekcie stworzonym przez konstruktor kopiujący pole miesiace będzie wskazywać na ten sam fragment pamięci, co w obiekcie wzorcowym. Jeżeli nie jest to zamierzony efekt (a zwykle nie jest) musimy sami zaimplementować konstruktor kopiujący, np. tak: class Rok { protected: Miesiac *miesiace; public: Rok() : miesiace(new Miesiac[12]) {} Rok(const Rok &rok) { //musimy sami zaalokować pamięć na pole ''miesiace'' miesiace=new Miesiac[12]; //oraz przypisać temu polu odpowiednie wartości for (int i=0; i<12; ++i) miesiace[i]=Miesiac(rok.miesiace[i]); } virtual ~Rok() {delete[] miesiace;} };

Destruktor

Destruktor jest natomiast funkcją, którą wykonuje się w celu zwolnienia pamięci przydzielonej dodatkowym obiektom lub innych zasobów.

Zasady "przemiany" zwykłej funkcji do destruktora, są podobne do tych tyczących się konstruktora. Jedyna zmiana tyczy się nazwy funkcji: Musi się ona zaczynać od znaku tyldy - ~.

   class MojaKlasa
   {
        MojaKlasa();//to oczywiście jest konstruktor
        ~MojaKlasa();//a to - destruktor
   };

Najczęstszą funkcją destruktora jest zwolnienie pamięci (zwykle poprzez zniszczenie wszystkich pól używanych przez ten obiekt).

Porada Należy pamiętać, że jeżeli zamierzamy implementować dziedziczenie po klasie dla której piszemy destruktor to powinniśmy stworzyć destruktor wirtualny! class MojaKlasa { MojaKlasa(); virtual ~MojaKlasa();//to jest destruktor wirtualny }; Początkujący programiści często o tym zapominają, doprowadzając w ten sposób czasami do tzw. wycieków pamięci. Dobrą praktyką jest tworzenie tylko destruktorów wirtualnych (patrz Funkcje wirtualne).

Ćwiczenia

Ćwiczenie 1

Napisz definicje instrukcji inicjujących do poniższej klasy:

   class Vector
   {
        private:
             double x;
             double y;
        public:
             Vector();
             Vector(double, double);
   };

Klasa ma reprezentować wektor w przestrzeni dwuwymiarowej, a instrukcje inicjujące mają realizować inicjalizację tego wektora. Pierwsze instrukcje inicjujące powinny ustawiać wektor na wartość domyślną (0,0).

Ćwiczenie 2

Dopisz do kodu z poprzedniego ćwiczenia konstruktor kopiujący.

   Vector(const Vector&);

Po wykonaniu tego ćwiczenia zastanów się, czy napisanie konstruktora kopiującego było konieczne. Jeżeli nie jesteś pewien - napisz program który testuje działanie Twojego konstruktora kopiującego i sprawdź jak program działa bez niego. Wyjaśnij dlaczego konstruktor kopiujący nie jest potrzebny.

Ćwiczenie 3

Poniższa klasa miała implementować dowolnej wielkości tablicę obiektów klasy Vector z poprzednich ćwiczeń. Niestety okazało się że powoduje wycieki pamięci - programista zapomniał o napisaniu destruktora:

   class VectorsArray
   {
        public:
             Vector* vectors;
 
             VectorsArray(size_t);
             Vector GetVector(size_t);
             size_t GetSize();
             size_t size;
   };
 
   VectorsArray::VectorsArray(size_t argSize)
   : size(argSize)
   , vectors(new Vector[argSize])
   {
   }
   Vector VectorsArray::GetVector(size_t i)
   {
        return vectors[i];
   }
   size_t VectorsArray::GetSize()
   {
      return size;
   }

Do powyższej klasy dopisz definicję destruktora. Nie zapomnij o dealokacji pamięci!

Dziedziczenie

Wstęp - Co to jest dziedziczenie

Często podczas tworzenia klasy napotykamy na sytuację, w której klasa ta powiększa możliwości innej klasy, nierzadko precyzując jednocześnie jej funkcjonalność. Dziedziczenie daje nam możliwość wykorzystania nowych klas w oparciu o stare klasy. Nie należy jednak traktować dziedziczenia jedynie jako sposobu na współdzielenie kodu między klasami. Dzięki mechanizmowi rzutowania możliwe jest interpretowanie obiektu klasy tak, jakby był obiektem klasy z której się wywodzi. Umożliwia to skonstruowanie szeregu klas wywodzących się z tej samej klasy i korzystanie w przejrzysty i spójny sposób z ich wspólnych możliwości. Należy dodać, że dziedziczenie jest jednym z czterech elementów programowania obiektowego (obok abstrakcji, enkapsulacji i polimorfizmu).

Klasę z której dziedziczymy nazywamy klasą bazową, zaś klasę, która po niej dziedziczy nazywamy klasą pochodną. Klasa pochodna może korzystać z funkcjonalności klasy bazowej i z założenia powinna rozszerzać jej możliwości (poprzez dodanie nowych metod, lub modyfikację metod klasy bazowej).

Składnia

Składnia dziedziczenia jest bardzo prosta. Przy definicji klasy należy zaznaczyć po których klasach dziedziczymy. Należy tu zaznaczyć, że C++ umożliwia Wielodziedziczenie, czyli dziedziczenie po wielu klasach na raz. Jest ono opisane w rozdziale Dziedziczenie wielokrotne.

   class nazwa_klasy :[operator_widocznosci] nazwa_klasy_bazowej, [operator_widocznosci] nazwa_klasy_bazowej ...
   {
        definicja_klasy
   };

operator_widoczności może przyjmować jedną z trzech wartości: public, protected, private. Operator widoczności przy klasie, z której dziedziczymy pozwala ograniczyć widoczność elementów publicznych z klasy bazowej.

• public - oznacza, że dziedziczone elementy (np. zmienne lub funkcje) mają taką widoczność jak w klasie bazowej.

public $\Rightarrow$ public

protected $\Rightarrow$ protected

private $\Rightarrow$ brak dostępu w klasie pochodnej

• protected - oznacza, że elementy publiczne zmieniają się w chronione.

public $\Rightarrow$ protected

protected $\Rightarrow$ protected

private $\Rightarrow$ brak dostępu w klasie pochodnej

• private - oznacza, że wszystkie elementy klasy bazowej zmieniają się w prywatne.

public $\Rightarrow$ private

protected $\Rightarrow$ private

private $\Rightarrow$ brak dostępu w klasie pochodnej

• brak operatora - oznacza, że niejawnie (domyślnie) zostanie wybrany operator private..

public $\Rightarrow$ private

protected $\Rightarrow$ private

private $\Rightarrow$ brak dostępu w klasie pochodnej

Dostęp do elementów klasy bazowej można uzyskać jawnie w następujący sposób:

  [klasa_bazowa::...]klasa_bazowa::element

Zapis ten umożliwia dostęp do elementów klasy bazowej, które są "przykryte" przez elementy klasy nadrzędnej (mają takie same nazwy jak elementy klasy nadrzędnej). Jeżeli nie zaznaczymy jawnie o który element nam chodzi kompilator uzna że chodzi o element klasy nadrzędnej, o ile taki istnieje (przeszukiwanie będzie prowadzone w głąb aż kompilator znajdzie "najbliższy" element).

Przykład 1

Definicja i sposób wykorzystania dziedziczenia

Najczęstszym powodem korzystania z dziedziczenia podczas tworzenia klasy jest chęć sprecyzowania funkcjonalności jakiejś klasy wraz z implementacją tej funkcjonalności. Pozwala to na rozróżnianie obiektów klas i jednocześnie umożliwia stworzenie funkcji korzystających ze wspólnych cech tych klas. Załóżmy że piszemy program symulujący zachowanie zwierząt. Każde zwierze powinno móc jeść. Tworzymy odpowiednią klasę:

   class Zwierze
   {
        public:
             Zwierze();
             void jedz();
   };

Następnie okazuje się, że musimy zaimplementowac klasy Ptak i Ryba. Każdy ptak i ryba jest zwierzęciem. Oprócz tego ptak może latać, a ryba płynąć. Wykorzystanie dziedziczenia wydaje się tu naturalne.

   class Ptak : public Zwierze
   {
        public:
             Ptak();
             void lec();
   };
 
   class Ryba : public Zwierze
   {
        public:
             Ryba();
             void plyn();
   };

Co istotne tworząc takie klasy możemy wywołać ich metodę pochodzącą z klasy Zwierze:

   Ptak ptak;
   ptak.jedz(); //metoda z klasy Zwierze
   ptak.lec(); //metoda z klasy Ptak
 
   Ryba *ryba=new Ryba();
   ryba->jedz(); //metoda z klasy Zwierze
   ryba->plyn(); //metoda z klasy Ryba

Możemy też zrzutować obiekty klasy Ptak i Ryba na klasę Zwierze:

   Ptak *ptak=new Ptak();
   Zwierze *zwierze;
   zwierze=ptak;
   zwierze->jedz();
 
   Ryba ryba;
   ((Zwierze)ryba).jedz();

Jeżeli tego nie zrobimy, a rzutowanie jest potrzebne, kompilator sam wykona rzutowanie niejawne:

   Zwierze zwierzeta[2];
   zwierzeta[0]=Ryba(); //rzutowanie niejawne
   zwierzeta[1]=Ptak(); //rzutowanie niejawne
   for (int i=0; i<2; ++i)
        zwierzeta[i].jedz();

Elementy chronione - operator widoczności protected

Sekcja protected klasy jest ściśle związana z dziedziczeniem - elementy i metody klasy, które się w niej znajdują, mogą być swobodnie używane w klasie dziedzicznej ale poza klasą dziedziczną i klasą bazową nie są widoczne.

Elementy powiązane z dziedziczeniem

Chciałbym zwrócić uwagę na inne, bardzo istotne elementy dziedziczenia, które są opisane w następnych rozdziałach tego podręcznika, a które mogą być wręcz niezbędne w prawidłowym korzystaniu z dziedziczenia (przede wszystkim Funkcje wirtualne).

Funkcje wirtualne

Przykrywanie metod, czyli definiowanie metod w klasie pochodnej o nazwie i parametrach takich samych jak w klasie bazowej, ma zwykle na celu przystosowanie metody do nowej funkcjonalności klasy. Bardzo często wywołanie metody klasy bazowej może prowadzić wręcz do katastrofy, ponieważ nie bierze ona pod uwagę zmian miedzy klasą bazową a pochodną. Problem powstaje, kiedy nie wiemy jaka jest klasa nadrzędna obiektu, a chcielibyśmy żeby zawsze była wywoływana metoda klasy pochodnej. W tym celu język C++ posiada funkcje wirtualne. Są one opisane w rozdziale Funkcje wirtualne.

Wielodziedziczenie - czyli dziedziczenie wielokrotne

Język C++ umożliwia dziedziczenie po wielu klasach bazowych na raz. Proces ten jest opisany w rozdziale Dziedziczenie wielokrotne.

Przykład 2

 #include <iostream>
 
 class Zwierze
 {
    public:
       Zwierze()
       { }
 
       void jedz( )
       {
           for ( int i=0; i<10; ++i )
              std::cout << "Om Nom Nom Nom\n";
       }
 
       void pij( )
       {
           for ( int i=0; i<5; ++i )
              std::cout << "Chlip, chlip\n";
       }
 
       void spij( )
       {
           std::cout << "Chrr...\n";
       }
 };
 
 class Pies : public Zwierze
 {
    public:
      Pies()
      { }
 
      void szczekaj()
      {
         std::cout << "Hau! hau!...\n";
      }
 
      void warcz()
      {
         std::cout << "Wrrrrrr...\n";
      }
 };
 
 ...

Za pomocą

 ...
 class Pies : public Zwierze
 {
 ...

utworzyliśmy klasę Psa, która dziedziczy klasę Zwierze. Dziedziczenie umożliwia przekazanie zmiennych, metod itp. z jednej klasy do drugiej. Możemy funkcję main zapisać w ten sposób:

 ...
 int main()
 {
    Pies burek;
    burek.jedz();
    burek.pij();
    burek.warcz();
    burek.pij();
    burek.szczekaj();
    burek.spij();
    return 0;
 }

Składniki statyczne

Do zrobienia: Pola statyczne muszą być też zadeklarowane poza klasą jako globalne jeśli ciało metod piszemy poza klasą

Wstęp

Czasami zachodzi potrzeba dodania elementu, który jest zwiazany z klasą, ale nie z konkretną instancją tej klasy. Możemy wtedy stworzyć element statyczny. Element statyczny jest właśnie elementem, który jest powiązany z klasą, a nie z obiektem tej klasy, czyli np. statyczna metoda nie może się odwołać do niestatycznej zmiennej lub funkcji.

Składnia

Elementy statyczne poprzedza się podczas definicji słówkiem static. Statyczne mogą być zarówno funkcje, jak i pola należące do klasy.

   class Klasa
   {
        protected:
             static int iloscInstancji; // pole statyczne
        public:
             Klasa() 
             {
                  iloscInstancji++;
             }
             virtual ~Klasa() 
             {
                  iloscInstancji--;
             }
             static int IloscInstancji()
             {
                  return iloscInstancji;
             }
   };
 
   int Klasa::iloscInstancji=0;

Jak widać do obiektów statycznych z wewnątrz klasy możemy się odwołać tak samo jak do innych pól. Pole IloscInstancji w powyższym przykładzie nie jest jednak zwykłym polem - jest polem statycznym. Oznacza to, że powstanie tylko jedna instancja tego pola. W powyższym przykładzie iloscInstancji ma za zadanie zliczania ile powstało obiektów klasy Klasa.

W powyższym przykładzie ponadto istnieje metoda statyczna. Z takiej metody nie można się odwołać do niestatycznych elementów klasy. Zarówno do klasy statycznej jak do statycznego pola możemy się odwołać nawet jeżeli nie został stworzony żaden obiekt klasy Klasa.

Odwołanie się do metody statycznej IloscInstancji z programu wymaga następująco:

  int i=Klasa::IloscInstancji();

Gdyby zaś pole iloscInstancji było publiczne, a nie chronione, to moglibyśmy się do niego odwołać poprzez:

  int i=Klasa::iloscInstancji;

Ponieważ jednak w powyższym przykładzie pole iloscInstancji jest chronione możemy się do niego odwołać jedynie z klasy Klasa bądź z klas które po niej dziedziczą.

Oczywiscie metody statyczne nie mogą być wirtualne.

Część 3
Zawansowane programowanie
obiektowe

Funkcje wirtualne

Wstęp

Funkcje wirtualne to specjalne funkcje składowe, które przydają się szczególnie, gdy używamy obiektów posługując się wskaźnikami lub referencjami do nich. Dla zwykłych funkcji z identycznymi nazwami to, czy zostanie wywołana funkcja z klasy podstawowej, czy pochodnej, zależy od typu wskaźnika, a nie tego, na co faktycznie on wskazuje. Dysponując funkcjami wirtualnymi będziemy mogli użyć prawdziwego polimorfizmu - używać metod klasy pochodnej wszędzie tam, gdzie spodziewana jest klasa podstawowa. W ten sposób będziemy mogli korzystać z metod klasy pochodnej korzystając ze wskaźnika, którego typ odnosi się do klasy podstawowej. W tej chwili może się to wydawać niepraktyczne, lecz za chwilę przekonasz się, że funkcje wirtualne niosą naprawdę sporo nowych możliwości.

Opis

Na początek rozpatrzymy przykład, który pokaże, dlaczego zwykłe, niewirtualne funkcje składowe nie zdają egzaminu gdy posługujemy się wskaźnikiem, który może wskazywać i na obiekt klasy podstawowej i na obiekt dowolnej z jej klas pochodnych.

Mając klasę bazową wyprowadzamy od niej klasę pochodną:

class Baza
{
public:
   void pisz()
   {
      std::cout << "Tu funkcja pisz z klasy Baza" << std::endl;
   }
};
 
class Baza2 : public Baza
{
public:
   void pisz()
   {
      std::cout << "Tu funkcja pisz z klasy Baza2" << std::endl;
   }
};

Jeżeli teraz w funkcji main stworzymy wskaźnik do obiektu typu Baza, to możemy ten wskaźnik ustawiać na dowolne obiekty tego typu. Można też ustawić go na obiekt typu pochodnego, czyli Baza2:

int main()
{
 
   Baza  *wsk;
   Baza   objB;
   Baza2  objB2;
 
   wsk = &objB;
   wsk -> pisz();
 
// Teraz ustawiamy wskaźnik wsk na obiekt typu pochodnego
 
   wsk = &objB2;
   wsk -> pisz();
   return 0;
}

Po skompilowaniu na ekranie zobaczymy dwa wypisy: "Tu funkcja pisz z klasy Baza". Stało się tak dlatego, że wskaźnik jest do typu Baza. Gdy ustawiliśmy wskaźnik na obiekt typu pochodnego (wolno nam), a następnie wywołaliśmy funkcję składową, to kompilator "na ślepo" sięgnął po funkcję pisz z klasy bazowej (bo wskaźnik wskazuje na klasę bazową).

Można jednak określić żeby kompilator nie sięgał po funkcję z klasy bazowej, ale sam się zorientował na co wskaźnik pokazuje. Do tego służy przydomek virtual, a funkcja składowa nim oznaczona nazywa się wirtualną. Różnica polega tylko na dodaniu słowa kluczowego virtual, co wygląda tak:

class Baza
{
public:
   virtual void pisz()
   {
      std::cout << "Tu funkcja pisz z klasy baza" << std::endl;
   }
};
 
class Baza2 : public Baza
{
public:
   virtual void pisz()
   {
      std::cout << "Tu funkcja pisz z klasy Baza2" << std::endl;
   }
};

Konsekwencje

Gdy funkcja jest oznaczona jako wirtualna, kompilator nie przypisuje na stałe wywołania funkcji z tej klasy, na którą pokazuje wskaźnik, już podczas kompilacji. Pozostawia decyzję co do wyboru właściwej wersji funkcji aż do momentu wykonania programu - jest to tzw. późne wiązanie. Wtedy program skorzysta z krótkiej informacji zapisanej w obiekcie a określającej klasę, do jakiej należy dany obiekt. Dopiero po odczytaniu informacji o klasie danego obiektu wybierana jest właściwa metoda.

Jeśli klasa ma choć jedną funkcję wirtualną, to do każdego jej obiektu dopisywany jest identyfikator tej klasy a do wywołania funkcji dopisywany jest kod, który ten identyfikator czyta i odnajduje odpowiednią funkcję. Gdy klasa funkcji wirtualnych nie posiada, takie informacje nie są dodawane, bo nie są potrzebne.

Zauważmy też, że nie zawsze decyzja o wyborze funkcji jest dokonywana dopiero na etapie wykonania. Gdy do obiektów odnosimy się przez zmienną, a nie przez wskaźnik lub referencję to kompilator już na etapie kompilacji wie, jaki jest typ (klasa) danej zmiennej (bo do zmiennej w przeciwieństwie do wskaźnika lub referencji nie można przypisać klasy pochodnej). Tak więc wirtualność nie gra roli gdy nie używamy wskaźników; kompilator generuje wtedy taki sam kod, jakby wszystkie funkcje były niewirtualne. Przy wskaźnikach musi orientować się czytając informację o klasie obiektu, na który wskazuje wskaźnik, bo moglibyśmy np. losować, czy do wskaźnika przypiszemy klasę bazową czy jej pochodną - wtedy przy każdym uruchomieniu programu byłaby wywoływana inna funkcja.

Jak widać, za wirtualność się płaci - zarówno drobnym narzutem pamięciowym na każdy obiekt (identyfikator klasy), jak i drobnym narzutem czasowym (odnajdywanie przy każdym wywołaniu odpowiedniej klasy i jej funkcji składowej). Jednak zyskujemy możliwośc płynnego rozwoju naszego programu przez zastępowanie klas ich podklasami, co bez wirtualności jest niewykonalne. Przy możliwościach obecnych komputerów koszt wirtualności jest zaniedbywalny, ale wciąż warto przemyśleć, czy potrzebujemy wirtualności dla wszystkich funkcji.

Przykład

Poniższy program zawiera deklaracje 3 klas: Figura, Kwadrat i Kolo. W klasie Figura została zadeklarowana metoda wirtualna (słowo kluczowe virtual) virtual float pole(). Każda z klas pochodnych od klasy Figura ma zaimplementowane swoje metody float pole(). Następnie (w funkcji main) znajdują się deklaracje obiektów każdej z klas i wskaźnika mogącego pokazywać na obiekty klasy bazowej Figura.

 #include <iostream>
 
 const float pi = 3.14159;
 class Figura 
 {
   public:
     virtual float pole() const 
     {
       return -1.0;
     }
 };
 
 class Kwadrat : public Figura 
 {
   public:
     Kwadrat( const float bok ) : a( bok ) {}
 
     float pole() const 
     {
       return a * a;
     }
   private:
     float a; // bok kwadratu
 };
 
 class Kolo : public Figura 
 {
   public:
     Kolo( const float promien ) : r( promien ) {}
 
     float pole() const 
     {
       return pi * r * r;
     }
   private:
     float r; // promien kola
 };
 
 void wyswietlPole( Figura& figura ) 
 {
   std::cout << figura.pole() << std::endl;
   return;
 }
 
 int main() 
 {
   // deklaracje obiektow:
   Figura jakasFigura;
   Kwadrat jakisKwadrat( 5 );
   Kolo jakiesKolo( 3 );
   Figura* wskJakasFigura = 0; // deklaracja wskaźnika
 
   // obiekty -------------------------------
   std::cout << jakasFigura.pole() << std::endl; // wynik: -1
   std::cout << jakisKwadrat.pole() << std::endl; // wynik: 25
   std::cout << jakiesKolo.pole() << std::endl; // wynik: 28.274...
 
   // wskazniki -----------------------------
   wskJakasFigura = &jakasFigura;
   std::cout << wskJakasFigura->pole() << std::endl; // wynik: -1
   wskJakasFigura = &jakisKwadrat;
   std::cout << wskJakasFigura->pole() << std::endl; // wynik: 25
   wskJakasFigura = &jakiesKolo;
   std::cout << wskJakasFigura->pole() << std::endl; // wynik: 28.274...
 
   // referencje -----------------------------
   wyswietlPole( jakasFigura ); // wynik: -1
   wyswietlPole( jakisKwadrat ); // wynik: 25
   wyswietlPole( jakiesKolo ); // wynik: 28.274...
 
   return 0;
 }

Wywołanie metod składowych dla każdego z obiektów powoduje wykonanie metody odpowiedniej dla klasy danego obiektu. Następnie wskaźnikowi wskJakasFigura zostaje przypisany adres obiektu jakasFigura i zostaje wywołana metoda float pole(). Wynikiem jest "-1" zgodnie z treścią metody float pole() w klasie Figura. Następnie przypisujemy wskaźnikowi adres obiektu klasy Kwadrat - możemy tak zrobić ponieważ klasa Kwadrat jest klasą pochodną od klasy Figura - jest to tzw. rzutowanie w górę. Wywołanie teraz metody float pole() dla wskaznika nie spowoduje wykonania metody zgodnej z typem wskaźnika - który jest typu Figura* lecz zgodnie z aktualnie wskazywanym obiektem, a więc wykonana zostanie metoda float pole() z klasy Kwadrat (gdyż ostatnie przypisanie wskaźnikowi wartości przypisywało mu adres obiektu klasy Kwadrat). Analogiczna sytuacja dzieje się gdy przypiszemy wskaźnikowi adres obiektu klasy Kolo. Następnie zostaje wykonana funkcja void wyswietlPole(Figura&) która przyjmuje jako parametr obiekt klasy Figura przez referencję. Tutaj również zostały wykonane odpowiednie metody dla obiektów klas pochodnych a nie metoda zgodna z obiektem jaki jest zadeklarowany jako parametr funkcji czyli float Figura::pole(). Takie działanie jest spowodowane przez przyjmowanie obiektu klasy Figura przez referencję. Gdyby obiekty były przyjmowane przez wartość (parametr bez &) zostałaby wykonana 3 krotnie metoda float Figura::pole() i 3 krotnie wyświetlona wartość -1.

Wyżej opisane działanie zostało spowodowane przez określenie metody w klasie bazowej jako wirtualnej. Gdyby zostało usunięte słowo kluczowe virtual w deklaracji metody w klasie bazowej, zostałyby wykonane metody zgodne z typem wskaźnika lub referencji, a więc za każdym razem zostałaby wykonana metoda float pole() z klasy Figura.

Przeciążanie operatorów

Przeładowanie (przeciążanie) operatorów polega na nadaniu im nowych funkcji.

Użycie

Nie możemy przeładowywać operatorów dla typów wbudowanych (int, char, float).

Przeciążanie polega na zdefiniowaniu tzw. funkcji operatorowej. Identyfikatorem funkcji operatorowej jest zawsze słowo kluczowe operator, bezpośrednio po którym następuje symbol operatora

typ_zwracany operator@ (argumenty)
{
// operacje 
}

np.: operator+, operator-, operator<< itd. Co najmniej jeden argument tej funkcji musi być obiektem danej klasy.

Przykład zastosowania

Mamy daną klasę Student

 class Student
 {  
   int nr_indeksu;
   float srednia_ocen; 
   public:
      Student(int nr=0, float sr=0) : nr_indeksu(nr), srednia_ocen(sr) {}
 };

i chcemy przeładować operator wyjścia <<

Robimy to w następujący sposób:

 class Student
 {   
    int nr_indeksu;
    float srednia_ocen; 
    public:
       Student(int nr=0, float sr=0) : nr_indeksu(nr), srednia_ocen(sr) {}
       friend ostream & operator<< (ostream &wyjscie, const Student &s);
 };
 
 ostream & operator<< (ostream &wyjscie, const Student &s)         
 {
   return wyjscie << "Nr indeksu: " <<s.nr_indeksu << endl << "Srednia ocen: " <<s.srednia_ocen<<endl;
 }

Aby zobaczyć, jak to działa, wystarczy że funkcja main() będzie miała następującą postać:

 int main() 
 {
 
   Student st, stu(10,5);
   cout << st; // wypisze nr indexu = 0, srednia ocen=0,
               // poniewaz st to wartosci konstruktora domyślnego :)
 
   cout << stu; // wypisze nr indexu = 10, srednia ocen=5
 
   return 0;
 }

W powyższym przykładzie wprowadzone zostało także nowe pojęcie - zaprzyjaźnianie (friend). Funkcję F() deklarujemy jako zaprzyjaźnioną z klasą X, jeśli chcemy, aby F() miała dostęp do prywatnych lub chronionych danych składowych klasy X.

Ale weźmy przykład nieco prostszy. Chcemy sprawdzić czy to jest ten sam student - przeciążamy operator:

 class Student
 {
    //...
    public:
       int operator==(const Student &q) {return nr_indeksu==q.nr_indeksu;}
       int operator==(const int &q) {return nr_indeksu==q;}
 };

I niby wszystko jest pięknie, ale tu zacznają się schody... My, jako twórcy klasy wiemy, że porównanie dotyczy tylko i wyłącznie numeru indeksu. Przy różnych średnich i tych samych indeksach dostaniemy wynik pozytywny. A nuż niech ktoś sobie ubzdura, że == odnosi się do wszystkich składowych...

Dalsze zamieszanie wprowadzą kolejne zaproponowane przeze mnie operatory.

 class Student
 {
    //...
    public:
      bool operator< ( Student const &q) const {return srednia < q.srednia;}
      bool operator< (int const &q) const {return srednia < q};
  // itd dla kolejnych operatorów.
 };

Samo w sobie nie jest groźne. Dopiero przy konfrontacji z poprzednim operatorem zaczyna wprowadzać zamieszanie. Wszystko jest dobrze kiedy pamiętamy, jakie operacje dane operatory wykonują. Ale pamiętajmy: pamięć ludzka jest ulotna i ktoś inny (albo my) może spędzić kilka dni zanim dojdzie do tego, dlaczego to działa nie tak jak powinno.

Ale powyższy przykład wygląda naprawdę blado w porównaniu z tym:

 class Student
 {
    //...
    public:
       int operator+ ( Student &q) {return (srednia + q.srednia +11) };
       int operator+ ( int &q) {return (srednia - q / 30) };
 };

Jak widzicie operator + wcale nas nie zmusza do wykonywania operacji dodawania. Możemy równie dobrze wewnątrz odejmować. A przy odejmowaniu porównywać. Lecz takie postępowanie nie jest intuicyjne. Takie postępowanie jest dozwolone jedynie w przypadkach, kiedy startujecie w konkursie na najbardziej nieczytelny kod.

Ale dość już straszenia. Teraz należy pokazać jak prawidłowo przeciążać operatory jednoargumentowe (++, --) oraz jak prawidłowo zwracać obiekt np. przy dodawaniu.

Oprócz operatorów arytmetycznych oraz działających na strumieniach można przeciążać również operatory logiczne.

Operatory "bool" i "!"

W języku C++ jest również możliwość przeciążania operatorów bool i !. Dzięki temu możemy w instrukcji warunkowej używać nazwy obiektu do testowania, czy spełnia on jakieś określone kryteria. Poniżej znajduje się prosty przykład, który to ilustruje:

#include <iostream>
using namespace std;
template <typename T, int el>
class Tablica
    {
       public:
         Tablica() : L_elementow(el) {}
         operator bool() const {return (L_elementow != 0);}
         bool operator!() const {return (L_elementow == 0);}
 
       private:
         T Tab[el];
         size_t L_elementow;
    };
 
int main()
{
  const n = 5;
  Tablica <short, n> tab;
 
  if(tab)
    cout << "Tablica nie jest pusta." << endl;
  if(!tab)
    cout << "Tablica jest pusta." << endl;
 
  Tablica <short, 0> tab2;
 
  if(tab2)
    cout << "Tablica nie jest pusta." << endl;
  if(!tab2)
    cout << "Tablica jest pusta." << endl;
 
  return 0;
}

W efekcie na ekranie otrzymamy dwa wpisy:

Tablica nie jest pusta.
Tablica jest pusta.

W pierwszym przypadku tablica zawierała niezerową liczbę elementów i prawdę zwrócił operator bool. W drugim natomiast liczba elementów wynosiła zero i prawdę zwrócił operator !.

Oczywiście ładniej by było, gdybyśmy sprawdzali rozmiar przy użyciu if-else, zamiast dwóch if-ów, ale chciałem pokazać wywołanie obu operatorów.

Operator "[]"

W niektórych przypadkach bardzo przydatny jest operator indeksu []. Można go przeciążyć oczywiście w dowolny sposób, ale chyba najbardziej intuicyjne jest przypisanie mu funkcji dostępu do konkretnego elementu np. w tablicy.

Posługując się przykładem klasy Tablica możemy dopisać do niej następujące dwa operatory:

  T & operator[](size_t el) {return Tab[el];}
  const T & operator[](size_t el) const {return Tab[el];}

oraz testową funkcję main

int main()
{
  const n = 5;
  TablicaInt <short, n> tab;
 
  for(int i = 0; i < n; ++i)
    {
      tab[i] = i;
      cout << tab[i] << endl;
    }
  return 0;
}

Operatory nie muszą wykonywać dokładnie tych samych czynności. Można sobie wyobrazić przykład w którym operator do zapisu zapisuje coś do tablicy, a w przypadku braku miejsca alokuje dodatkową pamięć. Operator stały nie będzie posiadał takiej funkcjonalności ponieważ nie może zmieniać obiektu na rzecz którego został wywołany. Zwróc uwage na słowo kluczowe const w definicji funkcji składowej klasy: " operator[] (int el) const ". Modifikator const stanowi część sygnatury funkcji. const zapewnia nam nie tylko właściwości funkcji skladowej const, ale również umożliwia przeładowanie (przeciażenie) operatora.

Operator "()"

Ten operator służy do tworzenia tzw. funktorów czyli klas które naśladują funkcje:

class Foo
{
public:
    int operator() (int a, int b) {
        return (a+b);
    }
};

Nie jest to może najmądrzejszy przykład gdyż jest dostępny do przeciążania operator "+" ale oddaje zasadę działania. Trzeba zaznaczyć że ten operator może zwracać dowolną wartość oraz przyjmować dowolną liczbę parametrów dowolnego typu. Niestety musi być zadeklarowany jako niestatyczna metoda klasy (gdyż inne operatory które mogą być statyczne zwracają obiekt (&Foo operator...), choć możliwość udawania przez klasę funkcji z pewnością to wynagrodzi.

New i delete

Są to operatory traktowane jako metody statyczne klas (niezależnie czy napiszemy słówko static czy nie), przykład:

class Foo {
  int i;
public:
    void * operator new(size_t rozmiar) { // słówka static nie muszę umieszczać, zrobi to za mnie kompilator
      return (new char[rozmiar]); // zawarte tutaj new skorzysta z GLOBALNEGO (dla wszystkiego tworzonego za jego pomocą) operatora new
    }
    void operator delete(void* wsk) {
      delete wsk;
    }
    Foo(int j = 0) : i(j) {}
    void* operator new[](size_t rozmiar) {
      return (new char[rozmiar]); // należy pamiętać aby nasz obiekt miał koniecznie konstruktor bezargumentowy
    }
    void operator delete[](void* wsk) {
      delete[] wsk;
    }
};

Kilka uwag: 1. Operatory new i new[], oraz delete i delete[] nie są przemienne, czyli jak zdefiniujemy własny new to new[] jest nadal domyślny. 2. Mimo zdefiniowania własnego operatora new i delete możemy nadal używać globalnych wersji:

Foo *f1 = new Foo(); // wywoła naszą wersję
Foo *f2 = ::new Foo(); // wywoła wersję globalną

Kiedy może się nam przydać własny operator new i delete? M. in. jak chcemy alokować za pierwszym razem większą pamięć a potem tylko zwracać wskaźnik do następnego jej fragmentu. Może być też przydatne gdy chcemy mieć kontrolę utworzenia jednej instancji obiektu.

---

W powyższym przykładzie pokazałem jak przeciążyć ten operator dla własnej klasy, natomiast jest jeszcze możliwość przeciążenia globalnego, czyli dla każdego obiektu w programie od jego uruchomienia do wyłączenia -odpowiedzialność jest więc wielka. Musimy się też liczyć z tym że w obrębie definicji nie możemy zrobić wszystkiego, czyli m.in. nie możemy używać strumieni cout (one korzystają z operatora new), oczywiście kompilator nie zaprotestuje natomiast podczas wykonania programu pojawi się problem. Przykład:

#include <cstdlib> // biblioteka zawierająca funkcje malloc() i free()
 
void* operator new(size_t rozmiar) {
  void* wsk = malloc(rozmiar);
  return wsk;
}
void operator delete(void* wsk) {
  free(wsk);
}
void* operator new[](size_t rozmiar) {
  return wsk;
}
void operator delete[](void* wsk) {
  free(wsk);
}

Autor "Symfonii C++", na której się opieram pisząc o new i delete, stanowczo odradza przeciążanie tego operatora globalnie

Operatory post- i pre- inkrementacji, oraz dekrementacji

Tutaj umieszczę same przykłady:

class Foo {
  int i;
public:
  Foo(int j): i(j) {}
 
  Foo & operator++() { // preinkrementacje, czyli najpierw  zwiększamy a potem zwracamy
    ++i;
    return *this;
  }
  Foo operator++(int) {  // specjalny zapis do postinkrementacji
    Foo kopia = (*this);
    ++i;
    return kopia; // zwracamy kopię, a nie oryginał
  }
};

Operatory dekrementacji analogicznie do inkrementacji. Należy mieć na uwadze, że przy własnych operatorach potrzebny jest "działający jak chcemy" operator= lub konstruktor kopiujący, jeśli go nie napiszemy kompilator wygeneruje go automatycznie, natomiast jeśli nasza klasa ma wewnątrz siebie wskaźniki tak w skopiowanym obiekcie będą one wskazywały na ten sam adres co wskaźniki oryginału

Dziedziczenie wielokrotne

Dziedziczenie wielokrotne stanowi właściwość niektórych obiektowych języków programowania w których klasa może dziedziczyć metody i pola z więcej niż jednej klasy bazowej.

Języki wspierające dziedziczenie wielokrotne to: Eiffel, C++, Python, Perl, Curl, Common Lisp (via CLOS).

Część 4
Zawansowane konstrukcje językowe

Obsługa wyjątków

Do zrobienia: co można rzucać: zarówno zwykły int jak i klasę, ale lepiej klasę wyjątki dostarczane przez bibliotekę standardową co dzieje się ze stosem przy rzucaniu wyjątku jak tworzyć klasy wyjątków (zbieranie wskaźników w rzucanym obiekcie żeby potem można było zwolnić pamięć)

Wstęp

Wyjątki pozwalają reagować na różne sytuacje wyjątkowe. Używa się ich tam gdzie istnieje ryzyko wystąpienia wyjątku.

Zarys wyjątków

Jeżeli w jakimś miejscu programu zajdzie nieoczekiwana sytuacja, programista piszący ten kod powinien zasygnalizować o tym. Dawniej polegało to na zwróceniu specyficznej wartości, co nie było zbyt szczęśliwym rozwiązaniem, bo sygnał musiał być taki jak wartość zwracana przez funkcję. W przypadku obsługi sytuacji wyjątkowej mówi się o obiekcie sytuacji wyjątkowej, co często zastępowane jest słowem "wyjątek". W C++ wyjątki się "rzuca", służy do tego instrukcja throw.

Szkielet obsługi wyjątków

Tam gdzie spodziewamy się wyjątku umieszczamy blok try, w którym umieszczamy "podejrzane" instrukcje. Za tym blokiem muszą (tzn. musi przynajmniej jedna) pojawić się bloki catch. Wygląda to tak:

      //jakaś zwykła funkcja, lub funkcja main
      try  // w instrukcjach poniżej może coś się nie udać
      {
         fun();
         fun2();   //podejrzane funkcje
      }
      catch(std::string obj)
      {
         //tu coś robimy, na przykład piszemy o błędzie
      }

W instrukcji catch umieszczamy typ jakim będzie wyjątek. Rzucić możemy wyjątek typu int, char, std::string i inne, dlatego tu określamy co nas interesuje. Nazwa tego obiektu nie jest konieczna, ale jeżeli chcemy znać wartość musimy ten obiekt nazwać. Bloków catch może być więcej, najczęściej tyle ile możliwych typów do złapania. Co ważne jeżeli rzucimy wyjątek konkretnego typu to "wpadnie" on do pierwszego dobrego catch nawet jeżeli inne nadają się lepiej (podobnie jak z instrukcjami if else). Dotyczy to zwłaszcza klas dziedziczonych. Przykładowo, jeżeli mamy klasę Pies, która dziedziczy z klasy Zwierze, to jeśli pierwszy pojawi się blok:

          catch(Zwierze obj)

to on zostanie użyty do obsługi wyjątku.

Zawsze dobrze jest się zabezpieczyć blokiem

          catch(...)

Taki blok łapie wszystko. Dlatego kompilator nie dopuści by wszystko łapiący catch był przed innymi instrukcjami catch.

Rzucanie wyjątku

Pisząc funkcję możemy stwierdzić że coś poszło nie tak i chcemy zasygnalizować wyjątek. Jak to zrobic przedstawia kod:

         double Dziel(double a, double b) //funkcja zwraca iloraz a / b
         {
             if(b == 0)    {
                 std::string wyjatek = "dzielenie przez zero!"; //przez zero się nie dzieli
                 throw wyjatek;  //rzucamy wyjątek
             }
             return a / b;
         }

Po instrukcji throw umieszczamy obiekt który chcemy rzucić (u nas jest to std::string). W tym miejscu działanie funkcji jest natychmiast przerywane i nasz łańcuch znaków wędruje do bloków catch.

Pełny program ilustrujący wyjątki:

        #include<iostream>
        using namespace std;
        double Dziel(double, double) throw(std::string);
        int main()
        {
            try
            {
                Dziel(10, 0);
            }
            catch(std::string w)
            {
                cout<<"Wyjatek: "<<w;
            }
            cin.get();
            return 0;
         }
         double Dziel(double a, double b) //funkcja zwraca iloraz a / b
        {
            if (b == 0) {std::string wyjatek = "dzielenie przez zero!";throw wyjatek;}
            return a / b;
        }

Jak widać, utworzony jest tylko jeden blok catch, a to dlatego że funkcja Dziel rzuca tylko wyjątki typu std::string. Dobrym zwyczajem jest pisanie obok deklaracji funkcji jakie wyjątki może ona rzucać:

       void fun(int) throw(std::string)

zapis ten oznacza że funkcja fun może zwrócić wyjątek typu std::string.

Szablony funkcji

Szablon funkcji

Szablon funkcji pozwala stworzyć wiele funkcji różniących się tylko typem argumentów przyjmowanych. Załóżmy, że chcielibyśmy napisać funkcję pisz, której jedynym argumentem byłaby zmienna, którą chcemy wypisać. Aby móc wypisywać wiele typów zmiennych możemy skorzystać z przeładowania (inna nazwa na przeciążenie) funkcji.

        void pisz(char a)
           {
               cout<<a;
           }
        void pisz(double a)
           {
               cout<<a;
           }
        void pisz(int a)
           {
               cout<<a;
           }

Można tak wiele razy przeładowywać funkcję pisz, ale można też wskazać kompilatorowi w jaki sposób może stworzyć nowe funkcje. Są to właśnie szablony.

Szablon naszej funkcji wyglądałby tak:

    template <typename T> void pisz(T a)
       {
          cout<<a;
       }

Pierwszą linijkę można też złamać po nawiasie '>':

       template <typename T>
       void pisz(T arg)

Pierwszym słowem jest template czyli szablon. Następnie w ostrych nawiasach umieszcza się słowo typename( zamiennie struct lub class)- które może oznaczać dowolny typ danych. Można także stosować słowo typedef przy zagnieżdżaniu szablonów, tak aby uniknąć nieprecyzyjności. Można także stosować nazwy typów, takich jak int czy char Nazwa użyta po słowach kluczowych zastępuje w deklaracji funkcji typ argumentu.

Nie można stosować szablonów dla metod wirtualnych.

Szablony klas

Czym są?

Szablony (wzorce) są czymś podobnym do makr, tyle że wykonywane są przez kompilator, a nie przez preprocesor. Cechują je pewne własności, których jednak nie ma preprocesor, np. można tworzyć rekurencyjne wywołania. Ale zobaczmy najpierw taką sytuację: chcemy utworzyć klasę o nazwie Punkt o trzech współrzędnych: x, y, z. Potrzebujemy trzy różne implementacje. Jedna ma działać na liczbach typu unsigned int, druga na liczbach typu int, a trzecia na float. Pierwsze, o czym pomyślimy, to napisać coś takiego (jeśli dostrzeżesz błąd, to się nie przejmuj). Mamy przykładową klasę:

 // ...
 class PunktUInt
 {
    public:
       PunktUInt( unsigned argX, unsigned argY, unsigned argZ )
       : x(argX), y(argY), z(argX)
       { }
 
       unsigned x, y, z;
 };
 // ...

I potem co? kopiujemy i zmieniamy unsigned na int:

 // ...
 class PunktInt
 {
    public:
       PunktInt( int argX, int argY, int argZ )
       : x(argX), y(argY), z(argZ)
       { }
 
       int x, y, z;
 };
 // ...

Następnie zamieniamy na float:

 // ...
 class PunktFloat
 {
    public:
       PunktFloat( float argX, float argY, float argZ )
       : x(argX), y(argY), z(argX)
       { }
 
       float x, y, z;
 };
 // ...

Uff! Wreszcie napisaliśmy - pomyślisz sobie. Jednak pisanie wymaga trochę wysiłku. No dobrze, teraz tworzymy funkcję main:

 int main(void)
 {
    PunktInt A(0,-10,0);
    PunktUInt B(0,10,5);
 
    std::cout << "A(" << A.x << "," << A.y << "," << A.z << ")" << std::endl;
    std::cout << "B(" << B.x << "," << B.y << "," << B.z << ")" << std::endl;
 }

I oto po naszych ciężkich staraniach otrzymujemy dość ciekawy i niespodziewany wynik:

A(0,-10,0)
B(0,10,0)

Ojej! - zapewne krzykniesz. Musiał gdzieś się tu zjawić błąd. Trzeba znaleźć go. Aha, mamy go:

 // ...
       PunktUInt( unsigned argX, unsigned argY, unsigned argZ )
       : x(argX), y(argY), '''z(argX)'''
 // ...

Zamiast z(argX) powinno być z(argZ). I trzeba teraz wszystko poprawiać, w tym także resztę funkcji... Dobrze, że to tylko tyle. Ale na szczęście C++ daje nam prostszy sposób.

Wyróżniamy różne możliwości szablonów:

Wykorzystywanie szablonów

Napiszmy teraz jeszcze raz nasz program. Tym razem z wykorzystaniem szablonów.

 // ...
 template <typename T>
 class Punkt
 {
    public:
       Punkt( T argX, T argY, T argZ )
       : x(argX), y(argY), z(argX)
       { }
 
       T x, y, z;
 };
 // ...

Za pomocą template<typename T> tworzymy nasz szablon. Parametrem jest typ, jaki chcemy użyć, tworzymy go poprzez <typename T>. Teraz, aby utworzyć nasze punkty możemy zapisać:

 Punkt<int> A(0,-10,0);
 Punkt<unsigned> A(0,10,5);

Czyli nasz main będzie wyglądał tak:

 int main(void)
 {
    Punkt<int> A(0,-10,0);
    Punkt<unsigned> B(0,10,5);
 
    std::cout << "A(" << A.x << "," << A.y << "," << A.z << ")" << std::endl;
    std::cout << "B(" << B.x << "," << B.y << "," << B.z << ")" << std::endl;
 }

Ale nie podoba nam się ta notacja, bo na przykład program za bardzo zaczyna nam przypominać HTML. Co mamy zrobić? Nic innego, jak tylko przed funkcją main skorzystać z typedef:

 typedef Punkt<int> PunktInt;
 typedef Punkt<unsigned> PunktUInt;
 typedef Punkt<float> PunktFloat;

I tyle. Main zamieni nam się wtedy w pierwotną formę:

 int main(void)
 {
    PunktInt A(0,-10,0);
    PunktUInt B(0,10,5);
 
    std::cout << "A(" << A.x << "," << A.y << "," << A.z << ")" << std::endl;
    std::cout << "B(" << B.x << "," << B.y << "," << B.z << ")" << std::endl;
 }

Powiesz:

No dobra, ale jak teraz uruchomię ten program to nadal mam ten sam, zły wynik.

I masz rację, bo zobaczysz:

A(0,-10,0)
B(0,10,0)

Powód jest ten sam co poprzedni.

       Punkt( T argX, T argY, T argZ )
       : x(argX), y(argY), '''z(argX)'''
       { }

Musimy zamienić z(argX) na z(argZ) i będzie wszystko w porządku. Tylko tyle. Nie wierzysz? Ale to jest prawda. To zobacz cały nasz program powinien wyglądać w ten sposób:

 #include <iostream>
 
 template <typename T>
 class Punkt
 {
    public:
       Punkt( T argX, T argY, T argZ )
       : x(argX), y(argY), z(argZ)
       { }
 
       T x, y, z;
 };
 
 typedef Punkt<int> PunktInt;
 typedef Punkt<unsigned> PunktUInt;
 typedef Punkt<float> PunktFloat;
 
 
 int main(void)
 {
    PunktInt A(0,-10,0);
    PunktUInt B(0,10,5);
 
    std::cout << "A(" << A.x << "," << A.y << "," << A.z << ")" << std::endl;
    std::cout << "B(" << B.x << "," << B.y << "," << B.z << ")" << std::endl;
 }

Szablony z wieloma parametrami

Szablon może także posiadać więcej niż jeden parametr. Na przykład chcielibyśmy napisać klasę Para, zawierającą dwa elementy pierwszy o nazwie pierwszy, a drugi o nazwie drugi, jednakże nie wiemy jakie mają one mieć typ. Możemy to zrobić w ten sposób:

 #include <iostream>
 #include <string>
 template <typename T1, typename T2>
 class Para
 {
    public:
       Para()
       { }
 
       Para( T1 a, T2 b )
       : pierwszy(a), drugi(b)
       { }
 
       T1 pierwszy;
       T2 drugi;
 };
 
 int main(void)
 {
     // tworzymy nasz obiekt
     Para<std::string,int> zmienna("Liczba",10);
 
     std::cout << zmienna.pierwszy << " " << zmienna.drugi << std::endl;
     return 0;
 }

Za pomocą template<typename T1, typename T2> utworzyliśmy szablon o dwóch parametrach.

Można też liczby

Szablonem może być także liczba. Zilustrujmy to przykładem:

 #include <iostream>
 #include <cstddef>
 template <typename T, std::size_t N>
 class Tablica
 {
     public:
 
        T &operator[]( std::size_t i )
        {
           return tabl[i];
        }
 
     private:
        T tabl[N];
 };
 
 int main(void)
 {
    Tablica<int,10> A;
 
    for ( int i=0; i<10; ++i )
    {
        A[i]=100+i;
    }
 
    for ( int i=0; i<10; ++i )
    {
       std::cout << "A[" << i << "]=" << A[i] << std::endl;
    }
    return 0;
 }

W powyższym przykładzie użyto typu std::size_t w nagłówku <cstddef>.

Wskażniki do elementów składowych

Dodatek A
Biblioteka STL

Filozofia

C++/Filozofia

String

String

Łańcuchy znaków w stylu języka C są częstą przyczyną błędów programu, a na dodatek ich używanie jest dosyć kłopotliwe. Nic wiec dziwnego, że biblioteka standardowa posiada zaimplementowaną uogólnioną klasę napisów zwaną string. Taka klasa daje jednolity, niezależny od systemu i bezpieczny interfejs do manipulowania napisami.

Aby móc korzystać z klasy string należy dołączyć plik nagłówkowy:

#include <string>

Tworzenie nowych obiektów tego typu wygląda następująco:

string napis1;
napis1 = "text";
 
//inicjowanie łańcucha znaków w miejscu jego tworzenia
//jawne wywołanie konstruktora
string napis2( "text" );
//operator przypisania
string napis3 = "text"; // string nie jest zakończony znakiem null, jak w przypadku C-stringa
 
cout << napis1 << endl
     << napis2 << endl
     << napis3 << endl;
 
string napis4(10,'X');
 
cout << napis4;

Uwaga:
Aby kompilator widział typ string, należy powiadomić go w jakiej przestrzeni nazw ten typ się znajduje:

using std::string;

lub ogólnie:

using namespace std;

Klasa string ma zdefiniowanych wiele operatorów, co ułatwia niektóre działania na napisach. Dla przykładu, dawniej aby skopiować napis z jednej zmiennej do drugiej, trzeba było używać dodatkowej funkcji strcpy(). W przypadku klasy string wystarczy operator przypisania '=' :

string a, b;
a = '1';
b = '2';
a = b;
cout << a;

Możemy z powodzeniem używać także operatorów: ==, !=, +, <, > oraz indeksowego []:

string a,b,c;
a = "gosia";
b = "iza";
c = "gosia";
 
// porównywanie napisów
if (a == c) cout << "a i c sa takie same\n";
 
if (a != b) cout << "a i b sa rozne\n" ;
 
// porządek leksykograficzny
cout << "napis a ("<<a<<") poprzedza napis b("<<b<<"): ";
if (a < b) cout << "prawda\n";
else cout << "nieprawda\n";
 
// łączenie łańcuchów
a = "mal"+ a;
 
cout << "napis a ("<<a<<") poprzedza napis b("<<b<<"): ";
if (a < b) cout << "prawda\n";
else cout << "nieprawda\n";
 
// modyfikacja
b[0] = '_';
 
cout << "zmieniony wyraz b: "<<b<<'\n';

Po czym w konsoli zobaczymy:

a i c sa takie same
a i b sa rozne
napis a (gosia) poprzedza napis b(iza): prawda
napis a (malgosia) poprzedza napis b(iza): nieprawda
zmieniony wyraz b: _za

Jak widać, manipulacje obiektami string są intuicyjne. Oprócz wygodnych w stosowaniu operatorów, klasa string posiada jeszcze więcej metod.

Metoda	Opis
empty()	Zwraca wartość true jeżeli napis jest pusty.
size(),length()	Zwraca ilość znaków w napisie.
at()	Zwraca znak o podanym położeniu, tak jak operator [], z tym że ta metoda jest bezpieczniejsza - wyrzuca wyjątek w przypadku wyjścia poza zakres stringa.
clear()	Usuwa wszystkie znaki z napisu.
erase(...)	Usuwa wybrane znaki.
find(...)	Znajduje podciąg w ciągu, są też bardziej rozbudowane funkcje tego typu.
swap(...)	Zamienia miejscami dwa stringi, a staje się b, a b staje się a.
substr(...)	Zwraca podciąg na podstawie indeksu początkowego i długości podciągu.
append(...)	Dodaje zadany napis na końcu istniejącego ciągu.
c_str()	Zwraca napis w stylu języka C (stały wskaźnik typu const char*).

Do zrobienia: omówić wymienione wyżej metody

Omówione dotychczas operatory i metody to tylko część dostępnych; wymienione zostały tylko te najczęściej używane. Teraz przedstawię różnice jakie występują między C a C++ w obsłudze napisów. Po lewej zmienne a i b są typu (const char *), a po prawej - (std::string).

C	C++
strcpy(a,b)	a = b
!strcmp(a,b)	a == b
strcat(a,b)	a += b
strlen(a)	a.size(), a.length()
strstr(a,b)	a.find(b)

Vector

Vector

Klasa vector reprezentuje obudowaną, zwykłą tablicę znaną z C, wyposażoną w kilka dodatkowych mechanizmów. Elementy wektora mogą być dowolnego typu.

Obiekt vector ma kilka odmian konstruktorów. Z reguły będziemy tworzyć wektor pusty.

vector <typ_elemetow> nazwa_tablicy;

Możemy też podać wielkość, co wcale nas nie ogranicza do tej wielkości, aby zarezerwować pamięć na kilka elementów od razu. Może to być zabieg optymalizacyjny.

 vector <int> tab(20);

Dodatkowo istnieje konstruktor przyjmujący liczbę elementów oraz wartość, jaką ma mieć każdy z nich.

 vector <string> tablica( 20, "przykladowy tekst" );

Ta tablica będzie miała dwadzieścia elementów, z czego wszystkie mają wartość: "przykladowy tekst".

Dodawanie elementów

Dodawanie elementów umożliwia metoda push_back(). Dodaje ona nowy element na koniec tablicy. Po dodaniu nowych elementów możemy się do nich odwoływać indeksowo [] lub metodą at(). Możemy też sprawdzić ile obecnie jest elementów metodą size(), a metoda empty() powie nam czy wektor nie jest pusty.

vector<int> tab;
cin >> n;
for( int i=0; i<n; ++i )
{
   int element;
   cin >> element;
   tab.push_back(element);
}

Jak działa powiększanie się tablicy vector?

Poniższy akapit dotyczy szczegółów technicznych, jeśli nie jesteś nimi zainteresowany, możesz go pominąć.

Metoda push_back() dodając nowy element do tablicy, dba o to, aby tablica była odpowiedniego rozmiaru. Za każdym razem, gdy brakuje miejsca, tablica jest powiększana - rezerwowana jest nowa, większa przestrzeń, stare elementy są kopiowane, aby do większej tablicy móc dodać dany element. Z reguły rezerwowana jest pamięć dwa razy większa od poprzedniej. W skrajnej sytuacji, może się zdarzyć, że zarezerwowana pamięć jest prawie dwa razy większa niż ilość elementów znajdujących się w niej!

Jeśli zależy nam na szybkości działania, powinniśmy zarezerwować przy pomocy odpowiedniego konstruktora pamięć na pewną ilość elementów. Przykładowo, jeśli wiemy że w tablicy będzie około 50 elementów, możemy konstruować wektor o wielkości 50, dzięki czemu unikniemy kilku kopiowań całej tablicy podczas dodawania elementów. Warto też szukać złotego środka, aby przypadkiem nie marnować pamięci. Na przykład, aby nie stworzyć wektora o rozmiarze 100, jeśli dodane do niego będą tylko 2 elementy.

Ręczne zarezerwowanie pamięci dla wektora jest możliwe dzięki metodzie reserve(size_t n), natomiast metoda capacity() zwróci nam wielkość aktualnie zarezerwowanego miejsca.

Ponieważ kopiowanie tablicy jest powolnym procesem, w przypadku tablicy dużych struktur, na przykład klas, warto zastanowić się nad utworzeniem tablicy wskaźników na te struktury.

Iteratory

Jak wiemy, do poruszania się po elementach zwykłej tablicy takiej jak int a[10] można używać wskaźnika. Podobnie, operacje na obiekcie vector można dokonać używając iteratorów działających podobnie jak wskaźniki. Więcej o iteratorach znajduje się w dalszych rozdziałach.

Metody

Lista metod klasy vector. Użyte słowo iterator zastępuje poprawne vector<T>::iterator, podmienione zostało dla zwiększenia czytelności.

Modyfikacja

prototyp	opis działania	złożoność czasowa
void swap(vector<T>& vec)	zamienia zawartości dwóch wektorów miejscami	stała
void push_back(const T obj)	dodaje na końcu wektora kopię przekazanego argumentu	stała, czasem liniowa*
void pop_back()	usuwa ostatni element z wektora	stała
void clear()	usuwa wszystkie elementy z wektora	liniowa (destruktory)
void assign(size_t n, const T obj)	czyści wektor i wypełnia go n kopiami argumentu obj	liniowa (jak clear) + liniowa względem wstawianych elementów
void assign(iterator poczatek, iterator koniec)	czyści wektor i wypełnia go elementami z innego wektora z przedziału <poczatek;koniec>	jw.
iterator insert(iterator pos, T obj)	wstawia element obj przed wskazywaną przez iterator pos pozycją i zwraca iterator do dostawionego elementu	liniowa (przenoszenie elementów między pos a ostatnim elementem tablicy)
void insert(iterator pos, size_t n, const T obj)	wstawia n kopii argumentu obj przed pozycją wskazywaną przez iterator pos	jw. + liniowa względem ilości dodanych elementów
void insert(iterator pos, iterator poczatek, iterator koniec)	wstawia przed pozycją wskazywaną przez iterator pos elementy między iteratorami początek i koniec (włącznie)	jw.**
iterator erase(iterator pos)	usuwa element wskazywany przez pos i zwraca iterator do następnego elementu	liniowa względem ilości elementów za usuwanym elementem
iterator erase(iterator poczatek, iterator koniec)	usuwa elementy z przedziału <poczatek;koniec> i zwraca iterator do elementu za nimi	liniowa względem ilości usuwanych elementów + przenoszenie elementów za końcem

* może występować kopiowanie wektora, gdy rozmiar jest zbyt mały
** w rzadkim przypadku (dla iteratorów najniższego typu w hierarchi: Input lub Output) złożoność bliższa kwadratowej (ilość wstawianych elementów razy ilość elementów od pozycji do końca tablicy)

Dostęp

prototyp	opis działania
T& front()	zwraca referencję do pierwszego elementu wektora
T& back()	zwraca referencję do ostatniego elementu wektora
iterator begin()	zwraca iterator do pierwszego elementu wektora (często mylone z front())
iterator end()	zwraca iterator ustawiony za ostatnim elementem wektora
iterator rbegin()	zwraca odwrócony iterator do pierwszego elementu
iterator rend()	zwraca odwrócony iterator do ostatniego elementu

Inne

prototyp	opis działania
size_t size()	zwraca obecną ilość elementów wektora.
size_t capacity()	zwraca ilość elementów, którą wektor jest w stanie pomieścić przed przeniesieniem go do większego obszaru pamięci.
size_t max_size()	zwraca ilość elementów, którą maksymalnie może pomieścić wektor
bool empty()	zwraca true jeśli wektor nie przechowuje żadnych zmiennych
void reserve(size_t n)	rezerwuje pamięć na n elementów, co zapobiega przenoszeniu wektora w pamięci przed osiągnięciem tej liczby
void resize(size_t n, T obj)	zmienia rozmiar wektora do n; jeśli jest większy od obecnego, dodawane są nowe elementy będące kopiami obj
void resize(size_t n)	zmienia rozmiar wektora do n; jeśli jest większy od obecnego, dodawane są nowe elementy o przypadkowych wartościach

Set

Opis

Zbiory są jednym z kontenerów biblioteki STL, których struktura oparta jest na drzewach. Elementy które są w nich przechowywane są posortowane, według pewnego klucza.

Zarówno typ wartosci tych elementów jak i typ wartości klucza są takie same. Drzewiasta struktura zapewnia szybkie wyszukiwanie, jednak są z tym związane także pewne mankamenty, mianowicie modyfikacja elementu jest możliwa tylko w taki sposób, że kasujemy stary element, a następnie wstawiamy w to miejsce nowy.

Korzystając z terminologii STL-a zbiory sa tzw. kontenerami asocjacyjnymi (o zmiennej długości, pozwalającymi na operowanie elementami przy użyciu kluczy).

Prosty przykład

Opis użytych tu iteratorów znajduje się w rozdziale Iteratory.

#include <iostream>
#include <string>
#include <set>
using namespace std;
 
int main()
{
   set<string> mapa;
   mapa.insert("Lublin");
   mapa.insert("Lódź");
   mapa.insert("Warszawa");
   mapa.insert("Kraków");
 
   set<string>::iterator result, it;
 
   // szuka elementu "Warszawa"
   result = mapa.find("Warszawa");
   if( result!=mapa.end() )
      cout << "Znalazłem! " << *result<< '\n';
 
   // wyświetlenie zawartości
   for( it=mapa.begin(); it!=mapa.end(); ++it)
      cout << *it<< '\n';
 
   return 0;
}

Map

Opis

Mapa to posortowany kontener asocjacyjny, czyli zbiornik o zmiennej długości gromadzący dane, które można dodawać i usuwać. Nie można jednak dodawać danych na konkretną pozycje, ponieważ kolejność ustalana jest wg danej klucz. Mapa jest również parowym zbiornikiem asocjacyjnym, czyli jej elementami są pary wartości klucz i dana. Pierwszej wartości key_type, czyli klucza mapy, nie można zmieniać, natomiast druga wartość danej jest przypisywalna (np.(*i).second=2). Mapa jest w końcu unikalnym kontenerem asocjacyjnym, co oznacza, że każde dwa elementy mają różny klucz.

Mapa zdefiniowana jest w standardowym nagłówku map oraz w niestandardowym, wstecznie kompatybilnym nagłówku map.h.

Przykład

#include<iostream>
#include<map>
using namespace std;
 
int main()
{
   map<const int, string> tydzien;
   tydzien[1] = "niedziela";
   tydzien[2] = "poniedzialek";
   tydzien[3] = "wtorek";
   tydzien[4] = "sroda";
   tydzien[5] = "czwartek";
   tydzien[6] = "piatek";
   tydzien[7] = "sobota";
 
   cout << "trzeci dzien tygodnia:  " << tydzien[3] << '\n';
 
   map<const int, string>::iterator cur;
 
   // zwrocenie elementu o kluczu 3
   cur = tydzien.find(3);
 
   // elementy o kluczach większych i mniejszych
   map<const int, string>::iterator prev = cur;
   map<const int, string>::iterator next = cur;    
   ++next;
   --prev;
 
   cout << "Wczesniejszy:  " << prev->second << '\n';
   cout << "Nastepny:  " << next->second << '\n';
}

Algorytmy w STL

Wstęp

Cóż znaczą biblioteki bez <algorithm>? Na pewno mniej, ponieważ każde modyfikacje na wektorach czy ciągach znaków są bardziej uciążliwe i wymagają od użytkownika dodatkowego wkładu pracy na napisanie algorytmu do wykonania określonego problemu. Weźmy pod uwagę przykładowo problem sortowania. Poniżej przedstawiona jest funkcja sortująca bąbelkowo n-elementową tablicę 1-wymiarową.

void sortowanie_babelkowe(int tab[], int n)
{
  for (int j=n-1; j>0; --j)
    for (int i=0; i<j; ++i)
      if (tab[i]>tab[i+1])
      {
        int temp=tab[i];
        tab[i]=tab[i+1];
        tab[i+1]=temp;
      }
}

Kod nie jest długi, ale wygodniej jest napisać:

   sort(tab,tab+n);

Lista funkcji zawartych w bibliotece <algorithm>

accumulate() adjacent_difference() adjacent_find() binary_search() copy() copy_backward() count() count_if() equal() equal_range() fill() fill_n() find() find_end() find_first_of() find_if() for_each() generate() generate_n() includes() inner_product() inplace_merge() is_heap() iter_swap()

lexicographical_compare() lower_bound() make_heap() max() max_element() merge() min() min_element() mismatch() next_permutation() nth_element() partial_sort() partial_sort_copy() partial_sum() partition() pop_heap() prev_permutation() push_heap() random_shuffle() remove() remove_copy() remove_copy_if() remove_if() replace()

replace_copy() replace_copy_if() replace_if() reverse() reverse_copy() rotate() rotate_copy() search() search_n() set_difference() set_intersection() set_symmetric_difference() set_union() sort() sort_heap() stable_partition() stable_sort() swap() swap_ranges() transform() unique() unique_copy() upper_bound()

Lista tematyczna

Operacje niemodyfikujące

• for_each — wykonuje operację na każdym elemencie ciągu
• count — liczy ilość wystąpień danej wartości w ciągu
• count_if — zlicza w ciągu ilość wystąpień wartości spełniających warunek
• equal — określa czy dwa zbiory elementów są takie same

Operacje niemodyfikujące - szukanie

• mismatch — znajduje pierwszą parę różnych elementów dwóch ciągów
• find — znajduje pierwsze wystąpienie wartości w ciągu
• find_if — znajduje w ciągu pierwsze wystąpienie wartości spełniającej warunek
• find_end — znajduje ostatnie wystąpienie ciągu jako podciągu
• find_first_of — znajduje jakikolwiek element ze zbioru w danym ciągu
• adjacent_find — znajduje sąsiadującą parę wartości
• search — znajduje pierwsze wystąpienie ciągu jako podciągu
• search_n — znajduje pierwsze wystąpienie ciągu n-tu wartości w ciągu

Operacje modyfikujące

• copy — kopiuje elementy jednego ciągu do drugiego
• copy_backward — kopiuje ciąg do drugiego ciągu, wstawiając elementy na jego koniec
• fill — zastępuje elementy ciągu podaną wartością
• fill_n — zastępuje n elementów ciągu podaną wartością
• generate — zastępuje elementy ciągu wartościami będącymi wynikiem funkcji
• generate_n — zastępuje n elementów ciągu wartościami będącymi wynikiem funkcji
• transform — wykonuje podaną funkcję dla argumentów ze zbioru i zapisuje wyniki w nowym ciągu
• remove — usuwa elementy o podanej wartości
• remove_if — usuwa elementy spełniające warunek
• remove_copy — kopiuje ciąg, usuwając elementy o podanej wartości
• remove_copy_if — kopiuje ciąg, usuwając elementy spełniające warunek
• replace — zastępuje elementy o danej wartości inną wartością
• replace_if — zastępuje elementy spełniające warunek
• replace_copy — kopiuje ciąg, zastępując elementy o danej wartości inną wartością
• replace_copy_if — kopiuje ciąg, zastępując elementy spełniające warunek

Operacje zmieniające kolejność

• partition — umieszcza elementy spełniające warunek przed tymi które go nie spełniają
• stable_partition — umieszcza elementy spełniające warunek przed tymi które go nie spełniają, zachowuje wzajemną kolejność
• random_shuffle — w losowy sposób zmienia kolejność elementów ciągu
• reverse — odwraca kolejność elementów w ciągu
• reverse_copy — kopiuje ciąg, odwracając kolejność elementów
• rotate — dokonuje rotacji elementów ciągu
• rotate_copy — kopiuje ciąg, przesuwając elementy (rotacja)
• unique — usuwa powtórzenia, w taki sposób że wśród sąsiadujących elementów nie ma dwóch takich samych
• unique_copy — kopiuje ciąg, w taki sposób że wśród sąsiadujących elementów nie ma dwóch takich samych
• swap — zamienia ze sobą dwa elementy
• swap_ranges — zamienia ze sobą dwa zbiory elementów
• iter_swap — zamienia ze sobą dwa elementy wskazywane przez iteratory

Operacje sortujące

• sort — sortuje ciąg rosnąco
• partial_sort — sortuje pierwsze N najmniejszych elementów w ciągu
• partial_sort_copy — tworzy kopię N najmniejszych elementów ciągu
• stable_sort — sortuje ciąg zachowując wzajemną kolejność dla równych elementów
• nth_element — ciąg jest podzielony na dwie nieposortowane części elementów mniejszych i większych od wybranego elementu

Operacje wyszukiwania binarnego

Operacje na posortowanych ciągach

• lower_bound — zwraca iterator do pierwszego elementu równego lub większego od podanego
• upper_bound — zwraca iterator do pierwszego elementu większego od podanego
• binary_search — stwierdza czy element występuje w ciągu
• equal_range — zwraca parę określającą przedział wewnątrz którego występuje dana wartość (lub ich ciąg).

Operacje na zbiorze

Operacje na posortowanych ciągach

• merge — łączy dwa posortowane ciągi
• inplace_merge — łączy dwie posortowane części ciągu
• includes — zwraca prawdę jeśli pierwszy ciąg jest podciągiem drugiego
• set_difference — tworzy różnicę dwóch zbiorów
• set_intersection — tworzy przecięcie dwóch zbiorów
• set_symmetric_difference — tworzy zbiór złożony z elementów występujących w tylko jednym z dwóch ciągów
• set_union — tworzy sumę zbiorów

Operacje na kopcu

• is_heap — zwraca prawdę jeśli ciąg tworzy kopiec
• make_heap — przekształca ciąg elementów tak aby tworzyły kopiec
• push_heap — dodaje element do kopca
• pop_heap — usuwa element ze szczytu kopca
• sort_heap — przekształca ciąg o strukturze kopca w ciąg posortowany

Operacje min max

• max — zwraca większy z dwoch elementów
• max_element — zwraca największy z elementów w ciągu
• min — zwraca mniejszy z elementów
• min_element — zwraca najmniejszy z elementów w ciągu
• lexicographical_compare — sprawdza czy jeden ciąg poprzedza leksykograficznie drugi ciąg
• next_permutation — przekształca ciąg elementów w leksykograficznie następną permutację
• prev_permutation — przekształca ciąg elementów w leksykograficznie poprzedzającą permutację

Operacje numeryczne

Zdefiniowane w nagłówku <numeric>

• accumulate — sumuje ciąg elementów
• inner_product — oblicza iloczyn skalarny na elementach dwóch ciągów
• adjacent_difference — oblicza różnice pomiędzy sąsiadującymi elementami w ciągu
• partial_sum — oblicza sumy częściowe ciągu elementów

Operacje niemodyfikujące

Poniższe przykłady wymagają dołączenia bibliotek i przestrzeni nazw

#include <iostream>
#include <vector>
#include <string>
using namespace std;

for_each()

for_each( iterator początek, iterator koniec, funkcja )

Działanie 

wykonuje operację na każdym elemencie ciągu.

Przykład 

poniższy program wywołuje dla każdego elementu dodanego do vectora funkcję echo.

void echo(short num)
{
   cout << num << endl;
}
 
int main()
{
   vector<short> vect;
 
   vect.push_back(5);
   vect.push_back(4);
   vect.push_back(3);
 
   for_each(vect.begin(), vect.end(), echo);
   return 0;
}

Na wyjściu pojawi się:

5
4
3

count()

count( iterator początek, iterator koniec, wartość )

Działanie 

liczy ilość wystąpień danej wartości w ciągu.

Przykład 

program przekształca tablicę liczb w wektor i zlicza ilość znajdujących się w nim dwójek.

int main()
{
   int tablica[] = { 2, 5, 7, 9, 2, 9, 2 };
   vector<int> v(tablica, tablica+7);
   cout << "Ilosc dwojek w tablicy: " << count( v.begin(), v.end(), 2 );
   return 0;
}

count_if()

count_if( iterator początek, iterator koniec, funkcja f )

Działanie 

liczy w ciągu ilość wystąpień wartości spełniających warunek

Przykład 

program przekształca tablicę liczb w wektor i zlicza ilość znajdujących się w nim liczb parzystych.

bool czyParzysta(int n){
  return (n%2 ? false : true);
}
 
int main(){
  int tablica[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
  vector<int> v(tablica, tablica+10);
  cout << "Ilosc parzystych: " << count_if(v.begin(), v.end(), czyParzysta); 
  return 0;
}

equal()

bool equal( iterator początek, iterator koniec, iterator początek_drugiego )
bool equal( iterator początek, iterator koniec, iterator początek_drugiego, funkcja_porownująca )

Działanie 

porównywany jest pierwszy zakres elementów (początek, koniec) z drugim zakresem (zaczynającym się w początek_drugiego).

Przykład

program porównuje łańcuch str z napis oraz z napis2. Porównanie ogranicza się do 2 znaków (długość str).

int main()
{
   string str= "bc";
   string napis= "abcde";
   string napis2= "bcde";
 
   if( equal(str.begin(), str.end(), napis.begin()) )
      cout << "Takie same\n";
   else
      cout << "Rozne\n";
 
   if( equal(str.begin(), str.end(), napis2.begin()) )
      cout << "Takie same";
   else
      cout << "Rozne";
   return 0;
}

Wynikiem jest kolejno Rozne oraz Takie same.

Operacje niemodyfikujące - szukanie

mismatch()

pair<> mismatch( iterator1 początek, iterator1 koniec, iterator2 początek_drugi )
pair<> mismatch( iterator1 początek, iterator1 koniec, iterator2 początek_drugi, funkcja )

znajduje pierwsze różne elementy dwóch ciągów

Wartość zwracana 

para znalezionych różniących się wartości, typu pair<iterator1, iterator2>

Działanie 

porównuje kolejne elementy w dwóch zbiory (pierwszy określony przez początek, koniec oraz drugi zaczynający się w początek_drugi). Zwraca pierwsze wystąpienie dwóch różnych elementów, lub parę <koniec, odpowiedni_koniec_drugi> jeśli nie znajdzie.

find()

iterator find( iterator początek, iterator koniec, wartość )

Działanie 

znajduje pierwsze wystąpienie wartości w ciągu i zwraca iterator do niej, lub jeśli nie zostanie znaleziona, zwraca iterator koniec.

Przykład 

program tworzy tablicę liczb 0, 10, 20, ..., 90 i sprawdza, czy znajdują się w nim liczby 30 i 33.

int main()
{
   vector<int> zbior;
   vector<int>::iterator wynik1, wynik2;
 
   for( int i = 0; i < 10; ++i )
      zbior.push_back(i*10);
 
   wynik1 = find(zbior.begin(), zbior.end(), 30);
   wynik2 = find(zbior.begin(), zbior.end(), 33);
   if( wynik1 != zbior.end() )
      cout << "Znaleziono 30.";
   if( wynik2 != zbior.end() )
      cout << "Znaleziono 33.";
}

Wynikiem jest: Znaleziono 30.

find_if()

iterator find_if( iterator początek, iterator koniec, funkcja  )

Działanie 

znajduje w ciągu pierwsze wystąpienie wartości spełniającej warunek

find_end()

iterator find_end( iterator początek, iterator koniec, iterator początek_szukany, iterator koniec_szukany )
iterator find_end( iterator początek, iterator koniec, iterator początek_szukany, iterator koniec_szukany, funkcja )

Działanie 

znajduje ostatnie wystąpienie ciągu (początek_szukany, koniec_szukany) jako podciągu w przedziale (początek, koniec). Można dostarczyć własną funkcję do porównywania elementów.

find_first_of()

iterator find_first_of( iterator początek, iterator koniec, iterator początek_zbiór, iterator koniec_zbiór)
iterator find_first_of( iterator początek, iterator koniec, iterator początek_zbiór, iterator koniec_zbiór, funkcja )

Działanie 

znajduje choć jeden element ze zbioru (początek_zbiór, koniec_zbiór) w podanym ciągu (początek, koniec). Można dostarczyć własną funkcję do porównywania elementów.

adjacent_find()

iterator adjacent_find( iterator początek, iterator koniec )
iterator adjacent_find( iterator początek, iterator koniec, funkcja )

Działanie 

porównuje kolejne wartości w obu ciągach, aż znajdzie parę tych samych - zwraca wówczas iterator do tej wartości, lub koniec jeśli nie ma pary identycznych wartości. Można dostarczyć własną funkcję do porównywania elementów.

search()

iterator search( iterator początek, iterator koniec, iterator początek_szukany, iterator koniec_szukany )
iterator search( iterator początek, iterator koniec, iterator początek_szukany, iterator koniec_szukany, funkcja )

Działanie 

znajduje pierwsze wystąpienie ciągu (początek_szukany, koniec_szukany) jako podciągu w przedziale (początek, koniec). Można dostarczyć własną funkcję do porównywania elementów.

search_n()

iterator search_n( iterator początek, iterator koniec, n, wartość )
iterator search_n( iterator początek, iterator koniec, n, wartość, funkcja )

Działanie 

znajduje pierwsze wystąpienie ciągu złożonego z n-tu wartości jako podciągu w przedziale (początek, koniec). Można dostarczyć własną funkcję do porównywania elementów.

Operacje modyfikujące

copy()

copy( iterator początek, iterator koniec, iterator początek_kopia )

Działanie 

kopiuje ciąg (początek, koniec) do drugiego ciągu

Przykład 

tworzy ciąg 10 liczb, po czym kopiuje je do drugiego (pustego) ciągu

int main()
{
   vector<int> ciag;
   for (int i = 0; i < 10; i++) 
      ciag.push_back(i);
 
   vector<int> kopia(10);
 
   copy( ciag.begin(), ciag.end(), kopia.begin() );
}

copy_backward()

copy_backward( iterator początek, iterator koniec, iterator koniec_kopia )

Działanie 

kopiuje ciąg (początek, koniec) do drugiego ciągu, tak aby kończyły się razem z jego końcem

Przykład 

tworzy ciąg 10 liczb, po czym kopiuje je do drugiego ciągu o długości 13 (elementy będą przesunięte, aby wyrównać do końca)

int main()
{
   vector<int> ciag;
   for( int i = 0; i < 10; i++ )
      ciag.push_back(i);
 
   vector<int> kopia(13);
 
   copy_backward( ciag.begin(), ciag.end(), kopia.end() );
 
   for( int i = 0; i < kopia.size(); i++)
      cout << kopia[i] << " ";
}

Wynikiem będzie 0 0 0 0 1 2 3 4 5 6 7 8 9.

fill()

fill( iterator początek, iterator koniec, wartość )

Działanie 

zastępuje elementy ciągu podaną wartością.

fill_n()

fill_n( iterator początek, n, wartość )

Działanie 

zastępuje n pierwszychh elementów ciągu podaną wartością.

generate()

generate( iterator początek, iterator koniec, funkcja )

Działanie 

zastępuje elementy ciągu wartościami będącymi wynikiem funkcji.

generate_n()

generate_n( iterator początek, n, funkcja )

Działanie 

zastępuje n elementów ciągu wartościami będącymi wynikiem funkcji

transform()

transform( iterator początek, iterator koniec, iterator nowy_początek, funkcja )
transform( iterator początek, iterator koniec, iterator początek_drugiego, iterator nowy_początek, funkcja_dwuargumentowa )

Działanie 

wykonuje podaną funkcję dla argumentów ze zbioru (początek, koniec) i zapisuje wyniki do zbioru zaczynającego się w nowy_początek. Druga wersja wykonuje funkcję dla pary argumentów, korzystając z drugiego zbioru (wskazywanego przez początek_drugiego).

Przykład 

program wykonuje funkcję sqrt dla każdego z 5 elementów ciągu, zapisując wyniki w nowym ciągu. Niezbędne było określenie którego przeładowania funkcji sqrt uzywamy.

int main()
{
   double tablica[5] = {2, 3, 9, 16, 25};
   vector<double> v(tablica, tablica+5);
   vector<double> wyniki(5);
 
   transform(v.begin(), v.end(), wyniki.begin(), (double (*) (double)) sqrt );
   for( int i=0; i<5; i++ )
      cout << wyniki[i] << '\n';
}

remove()

Działanie 

usuwa elementy o podanej wartości

remove_if()

Działanie 

usuwa elementy spełniające warunek

remove_copy()

Działanie 

kopiuje ciąg, usuwając elementy o podanej wartości

remove_copy_if()

Działanie 

kopiuje ciąg, usuwając elementy spełniające warunek

replace()

Działanie 

zastępuje elementy o danej wartości inną wartością

replace_if()

Działanie 

zastępuje elementy spełniające warunek

replace_copy()

Działanie 

kopiuje ciąg, zastępując elementy o danej wartości inną wartością

replace_copy_if()

Działanie 

kopiuje ciąg, zastępując elementy spełniające warunek

Operacje zmieniające kolejność

partition()

partition( iterator początek, iterator koniec, funkcja )

Działanie 

umieszcza elementy spełniające warunek przed tymi które go nie spełniają

stable_partition()

stable_partition( iterator początek, iterator koniec, funkcja )

Działanie 

umieszcza elementy spełniające warunek przed tymi które go nie spełniają, zachowuje wzajemną kolejność

random_shuffle()

random_shuffle( iterator początek, iterator koniec )
random_shuffle( iterator początek, iterator koniec, generator_liczb_pseudolosowych )

Działanie 

w losowy sposób zmienia kolejność elementów ciągu

reverse()

reverse( iterator początek, iterator koniec )

Działanie 

odwraca kolejność elementów w ciągu

reverse_copy()

reverse_copy( iterator początek, iterator koniec, iterator początek_kopia )

Działanie 

kopiuje ciąg do drugiego ciągu, odwracając kolejność elementów

rotate()

rotate( iterator początek, iterator nowy_początek, iterator koniec )

Działanie 

przesuwac elementy w taki sposób aby pierwszym elementem był nowy_początek; element go poprzedzający staje się ostatnim

rotate_copy()

rotate_copy( iterator początek, iterator nowy_początek, iterator koniec, iterator początek_kopia )

Działanie 

kopiuje ciąg do drugiego ciągu, przesuwając elementy w taki sposób aby pierwszym elementem był nowy_początek; element go poprzedzający staje się ostatnim

unique()

Działanie 

usuwa powtórzenia, w taki sposób że wśród sąsiadujących elementów nie ma dwóch takich samych

unique_copy()

iterator unique_copy( iterator początek, iterator koniec, iterator początek_kopia )
iterator unique_copy( iterator początek, iterator koniec, iterator początek_kopia, funkcja )

Działanie 

kopiuje ciąg do drugiego ciągu, w taki sposób że wśród sąsiadujących elementów nie ma dwóch takich samych

swap()

swap( element1, element2 )

Działanie 

zamienia ze sobą dwa elementy.

swap_ranges()

swap_ranges( iterator początek, iterator koniec, iterator początek_drugiego )

Działanie 

zamienia ze sobą dwa zbiory elementów: zbiór (początek, koniec) z drugim (o podanym początku).

iter_swap()

iter_swap( iterator element1, iterator element2 )

Działanie 

zamienia ze sobą dwa elementy wskazywane przez iteratory.

Operacje sortujące

sort()

void sort( RandomAccessIterator start, RandomAccessIterator end ) void sort( RandomAccessIterator start, RandomAccessIterator end, Compare cmp )

Działanie 

sortuje ciąg rosnąco

Jak używać:

#include<algorithm>
...
sort( iterator start, iterator koniec );

//albo

sort( iterator start, iterator koniec, cmp ); //cmp - funkcja porównująca
...

W pierwszym przypadku algorytm sort() ustawia elementy w zakresie [start,koniec) w porządku niemalejącym. Gdy wywołujemy sortowanie z trzema parametrami to sortowanie odbywa się względem funkcji porównującej, którą definiujemy.

Przykładowe kody źródłowe

vector<int> v;
 v.push_back( 23 );
 v.push_back( -1 );
 v.push_back( 9999 );
 v.push_back( 0 );
 v.push_back( 4 );              

 cout << "Przed sortowaniem: ";
 for( int i = 0; i < v.size(); ++i ) {
   cout << v[i] << " ";
 }
 cout << endl;            

 sort( v.begin(), v.end() );            

 cout << "Po sortowaniu: ";
 for( int i = 0; i < v.size(); ++i ) {
   cout << v[i] << " ";
 }
 cout << endl;   

Efektem działania tego programu będzie:

Przed sortowaniem: 23 -1 9999 0 4
Po sortowaniu: -1 0 4 23 9999

Inny przykład, tym razem z funkcją definiowaną przez programistę:

bool cmp( int a, int b ) {
   return a > b;
 }              

 ...            

 vector<int> v;
 for( int i = 0; i < 10; ++i ) {
   v.push_back(i);
 }              

 cout << "Przed: ";
 for( int i = 0; i < 10; ++i ) {
   cout << v[i] << " ";
 }
 cout << endl;            

 sort( v.begin(), v.end(), cmp );               

 cout << "Po: ";
 for( int i = 0; i < 10; ++i ) {
   cout << v[i] << " ";
 }
 cout << endl; 

Wyniki działania takiego programu będą następujące:

Przed: 0 1 2 3 4 5 6 7 8 9
Po: 9 8 7 6 5 4 3 2 1 0

partial_sort()

void partial_sort( random_access_iterator start, random_access_iterator middle, random_access_iterator end )
void partial_sort( random_access_iterator start, random_access_iterator middle, random_access_iterator end, StrictWeakOrdering cmp )

Działanie 

sortuje pierwsze N najmniejszych elementów w ciągu

partial_sort_copy()

random_access_iterator partial_sort_copy( input_iterator start, input_iterator end, random_access_iterator result_start, random_access_iterator result_end )
random_access_iterator partial_sort_copy( input_iterator start, input_iterator end, random_access_iterator result_start, random_access_iterator result_end, StrictWeakOrdering cmp )

Działanie 

tworzy kopię N najmniejszych elementów ciągu

stable_sort()

void stable_sort( random_access_iterator start, random_access_iterator end )
void stable_sort( random_access_iterator start, random_access_iterator end, StrictWeakOrdering cmp )

Działanie 

sortuje ciąg zachowując wzajemną kolejność dla równych elementów

nth_element()

void nth_element( random_access_iterator start, random_access_iterator nth, random_access_iterator end )
void nth_element( random_access_iterator start, random_access_iterator nth, random_access_iterator end, StrictWeakOrdering cmp )

Działanie 

ciąg jest podzielony na nieposortowane grupy elementów mniejszych i większych od wybranego elementu Nth (odpowiednio po lewej i prawej jego stronie)

Inne klasy w STL

Dodatek B

Przykłady programów w C++

  // Arithmetic - proste działania matematyczne
 #include <iostream>
 
 int main()
 {
    using namespace std;
 
    int Liczba1 = 0;
    int Liczba2 = 0;
    int Wynik = 0;
 
    // koniec linii to '\n'
    cout << "Podaj pierwsza liczbe calkowita\n";
    cin >> Liczba1;
 
    // czasem mozna linie konczyc uzywajac ::std::endl
    // ale nalezy pamietac, ze endl oczyszcza bufor
    // co wiaze sie ze spadkiem wydajnosci 
    // kiedy wykonywanych jest duzo takich operacji
    cout << "Podaj druga liczbe calkowita" << endl;
    cin >> Liczba2;
 
    Wynik = Liczba1 + Liczba2;
    cout << '\n' << Liczba1 << '+' << Liczba2 << '=' << Wynik << '\n';
 
    return 0;
 }

Ćwiczenia

Ćwiczenie 1

Napisać program, który czyta ze strumienia standardowego wejścia i zmienia małe litery na wielkie i odwrotnie (nie bierzemy pod uwagę polskich znaków), wypisując wynik do strumienia standardowego wyjścia. Następnie zmodyfikować go tak, aby pracował na plikach: wejściowym oraz wyjściowym, podanych jako parametry programu.

Ćwiczenie 2

Mamy tablice kwadratowa, której wymiarem jest liczba nieparzysta. Napisz program, który wypełni ja zerami i jedynkami w następujący sposób:

0 0 1 0 0
0 1 0 1 0
1 0 0 0 1
0 1 0 1 0
0 0 1 0 0

Ćwiczenie 3

Dany jest plik:

+-----------+----+-----------+--------------+
|PESEL      |Płeć|Imię       |Nazwisko      |
+-----------+----+-----------+--------------+
 45679815845  M   Tomasz      Buczakowski
 48491848438  M   Andzej      Krzemień
 81871681861  K   Karolina    Cubisz
 78168181348  M   Aleksander  Buczykowski
 48618481389  M   Jerzy       Apostoł
 56884864684  K   Magdalena   Koczkowska
 84184864889  M   Patryk      Rutkowski
 93818984869  M   Daniel      Dworkowski
 48498386181  K   Karina      Puszkowski
 78681864864  M   Jakub       Buczakowski
 48648848646  M   Stefan      Buczakowski
 84681846844  K   Anna        Stepaniuk
 45784698943  M   Grzegorz    Warszawski

1. Wypisać wszystkie nazwiska kończące się na "ski" w porządku alfabetycznym, bez powtórzeń.
2. Wypisać w odwrotnym porządku alfabetycznym osobno imiona żeńskie i męskie.

Ćwiczenie 4

Napisz funkcje wypisującą liczby pierwsze (lub złożone) z podanego zakresu liczb.

Podpowiedź: Należy użyć algorytmu sita Eratostenesa.

Ćwiczenie 5

Mamy taki oto plik źrodłowy:

 #include <iostream>
 
 using namespace std;
 
 class wydatkiMiesieczne
 {
    public:
 
       //w tym miejscu wpisz brakujace pola klasy
 
    private:
       int cenaChleb;  //                                            
       int cenaMleko;  //ceny produktow (przypisz je w konstruktorze)
       int cenaGazeta; //                                            
 
       bool zakupChleba; //
       bool zakupMleka;  //zmienne true/false
       bool zakupGazety; //
 
       int pensja; //pensja obiektu (człowieka)
       int sumaWydatkowMiesiecznych; //zmienna ktora sumuje wydatki
       bool czyWystarczaNaMiesiac; //zmienna przechowuje true jesli pensja jest wieksza niz wydatki; jesli jest odwrotnie - false
 };
 
 int main(int argc, char** argv)
 {
    wydatkiMiesieczne Marian;
    Marian.zarobek(200); 
    Marian.czyKupujeChleb(true);
    Marian.czyKupujeMleko(true);
    Marian.czyKupujeGazete(true);
    Marian.obliczanieWydatkowMiesiecznych();
    cout << "Pensja Mariana " << (Marian.czyWystarczaPieniedzyNaWydatkiMiesieczne() ? "jest wystarczajaca" : "nie jest wystarczajaca");
    cout << " na pokrycie kosztow codziennych zakupow" << endl;
 
    wydatkiMiesieczne* Jadwiga = new wydatkiMiesieczne;
    Jadwiga->zarobek(12000);
    Jadwiga->czyKupujeChleb(true);
    Jadwiga->czyKupujeMleko(true);
    Jadwiga->czyKupujeGazete(false);
    Jadwiga->obliczanieWydatkowMiesiecznych();
    cout << "Pensja Jadwigi " << (Jadwiga->czyWystarczaPieniedzyNaWydatkiMiesieczne() ? "jest wystarczajaca" : "nie jest wystarczajaca");
    cout << " na pokrycie kosztow codziennych zakupow" << endl;
    delete Jadwiga;
 
    getchar();
    return 0;
 }

Program ten oblicza czy pensja, ktorą dostaje człowiek zdefiniowany jako obiekt klasy wydatkiMiesieczne, jest w stanie pokryc uproszczone wydatki miesięczne. Jednak program nie jest kompletny. Uzupełnij brakujące pola klasy w sekcji public stosując się do poniższych instrukcji:

• Użyj konstruktora do przypisania wartosci polom danych:

    +-----------+-----------------+
    |nazwa pola |wartosc ktora ma |
    |  danych   |zostac przypisana|
    +-----------+-----------------+
    | cenaChleb |         2       |
    | cenaMleko |         3       |
    | cenaGazeta|         2       |
    |           |                 |
    | sumaWydat-|                 |
    | kowMiesie-|         0       |
    | cznych    |   (opcjonalnie) |
    +-----------+-----------------+

• Pamiętaj że zmienne cenaChleb, cenaMleko i cenaGazeta reprezentują cene za jedną sztukę danego produktu, a my bedziemy potrzebować ceny za zakup tych towarów przez cały miesiąc (przyjmijmy ze miesiąc ma 30 dni).
• Nie tworz innych funkcji w sekcji public niż te, które zostały wywołane w funkcji main().
• Funkcja zarobek() ma pobierac liczbe reprezentującą zarobek danej osoby (w zł) i wpisywac tą wartość w zmienną pensja.
• Funkcje z przedrostkami czyKupuje- mają przypisywac wartość (true - jeśli kupuje dany produkt; false - jeśli nie) do swoich odpowiednikow z sekcji private (np. funkcja czyKupujeMleko() przypisze wartość zmiennej zakupMleka).
• Funkcja obliczanieWydatkowMiesiecznych() ma obliczyć kwotę jaka bedzie wydana przez miesiąc kupowania ustalonych przez obiekt produktów i przypisać wynik zmiennej sumaWydatkowMiesiecznych.
• Funkcja czyWystarczaPieniedzyNaWydatkiMiesieczne() ma obliczyc czy pensja danego obiektu jest wystarczająca na pokrycie kosztów zakupów, przekazać wynik true, albo false do zmiennej czyWystarczaNaMiesiac i zwrocić go.

Różnice między C a C++

"Hello World" program w C i C++.

Komentarze

W ANSI C (C89) nie jest dozwolone używanie komentarzy zaczynających się od //. Zostały jednak dodane w standardzie C99.

Stałe

Stałe w C++ (obiekty zadeklarowane ze słowem const) są stałe w pełnym tego słowa znaczeniu. Np. stałe typów całkowitych mogą być stosowane tam, gdzie wymaga się stałych wyrażeń (tzn. jako etykiety case, jako rozmiar tablic itp.). W C już nie i tam do takich stałych trzeba stosować dyrektywę preprocesora #define. W C stała jest dokładnie tym samym co zmienna, z tym tylko zastrzeżeniem, że nie można jej jawnie modyfikować (ale można zmodyfikować zawartość wskaźnika do adresu stałej, czyli de facto zmodyfikować stałą).

Konsekwencją tego po części jest fakt, że globalnie deklarowane stałe w języku C mają to samo wiązanie (ang. linkage) co zmienne, czyli zewnętrzne. W języku C++ stałe mają domyślnie wiązanie lokalne i aby były one zewnętrzne (dzielone między jednostkami kompilacji), muszą być zadeklarowane razem z inicjalizacją i słowem extern.

Zmienne

• możliwość deklarowania zmiennych np. w instrukcji sterującej petli for
• możliwość mieszania instrukcji i deklaracji zmiennych w jednym bloku kodu (w ANSI C zmienne muszą być deklarowane przed pierwszą instrukcją)

Wiązanie (ang. linkage) i obiekty niejawne

W języku C wiązanie symboli z obiektami, które są przez nie oznaczane, czyli odwoływanie się w jednych jednostkach kompilacji do obiektów lub funkcji z innych jednostek kompilacji, jest opisane luźniejszymi regułami, niż w C++.

W języku C obowiązuje "słabe wiązanie" (ang. vague linkage), przy czym nie istnieją w tym języku żadne obiekty niejawne. To oznacza, że funkcja lub zmienna globalna o określonej nazwie może wystąpić dowolną ilość razy w całym zbiorze kompilacji (zbiorze jednostek kompilacji składających się na jeden plik wykonywalny lub bibliotekę dynamiczną). Podczas procesu wiązania wybierany jest w takim wypadku "pierwszy lepszy" ze wszystkich takich obiektów. Język C pozwala również na wielokrotne definicje zmiennej globalnej w tym samym pliku - definicje te, jak też definicje zmiennej o tej samej nazwie w innych jednostkach kompilacji będą się odnosić do dokładnie tej samej zmiennej. Właściwość ta pochodzi prawdopodobnie z czasów, gdy w C nie było słowa extern, więc deklarację zmiennej globalnej można było bez dodatkowych oznaczeń zamieścić w pliku nagłówkowym.

W języku C++ obowiązuje "silne wiązanie" (ang. strict linkage) dla obiektów jawnych, natomiast słabe dla obiektów niejawnych. Obiekty niejawne w C++ to są tablice metod wirtualnych tworzonych dla określonej klasy oraz funkcje inline. Silne wiązanie oznacza, że jeśli w zbiorze kompilacji zostaną znalezione dwa obiekty o tej samej nazwie, to linker zgłosi błąd i odmówi wiązania.

Typ stałej znakowej

W języku C literał znakowy (stała znakowa), np. 'a' jest traktowana jako int, natomiast w C++ jest uważana za char.

Typ bool

W C++ istnieje oficjalny typ bool i dwie stałe tego typu true i false, które służą do przechowywania wartości logicznych. Jest typem zwracanym operatorów porównawczych i relacji oraz typem przyjmowanym i zwracanym przez operatory && i ||. Ten typ musi mieć również wyrażenie podawane do if, while i drugiego wyrażenia w for.

Ze względu na wsteczną zgodność jednak pozostawiono domyślną konwersję typu bool na int, przy czym false i true są konwertowane odpowiednio na 0 i 1, natomiast w drugą stronę 0 konwertuje się na false i każda inna wartość całkowita na true.

Typy wskaźników

W języku ANSI C dozwolone są niejawne konwersje pomiędzy różnymi typami wskaźnikowymi oraz pomiędzy typami wskaźnikowymi i typami całkowitymi. Co prawda wiele kompilatorów zgłasza ostrzeżenia przy próbach dokonania takiej konwersji bez jawnego rzutowania (za wyjątkiem konwersji, w których uczestniczy void*), nie jest ona jednak w ANSI C błędem.

W języku C++ niejawne konwersje pomiędzy wskaźnikami i referencjami do różnych typów są możliwe tylko w przypadku typów spokrewnionych, tzn. wskaźnik do klasy pochodnej może być niejawnie konwertowany na wskaźnik do klasy bazowej (w tym również niejako uważa się "typ void" za bazę dla wszystkich typów, zatem każdy wskaźnik na dane można niejawnie konwertować na void*). Wszelkie inne konwersje pomiędzy wskaźnikami do danych różnych typów oraz wskaźnikami i typami całkowitymi muszą być jawnie zrzutowane.

Warto zaznaczyć, że rzutowanie pomiędzy typami klasowymi, które są zhierarchizowane (np. rzutowanie wskaźnika do klasy bazowej na wskaźnik do klasy pochodnej) mogą się odbywać wyłącznie poprzez operator static_cast lub dynamic_cast. Użycie do tego celu rzutowania ogólnego "(typ)obiekt" lub reinterpret_cast może spowodować niezdefiniowane zachowanie.

Alternatywne słowa kluczowe

W języku C++ dodano dodatkowe słowa kluczowe opisujące niektóre operatory. Operatory &&, || i ! możemy też zapisywać jako and, or i not. Istnieją także słowa dla operatorów bitowych &, | i ^: bitand, bitor i xor. Podobnie również dla operatorów połączonych z przypisaniem: and_eq , or_eq i xor_eq . Istnieje także, choć szczerze nie wiem po co, not_eq .

Biblioteka standardowa

C++ używa innych nazw plików nagłówkowych dla biblioteki standardowej odziedziczonej z języka C - np. cstdio zamiast stdio.h. Zobacz też rozdział Przestrzenie nazw.

Funkcje

W języku C pusta lista argumentów: funkcja() oznacza, że prototyp nie precyzuje argumentów przyjmowanych przez funkcję, natomiast deklaracja funkcja(void) oznacza, że funkcja nie przyjmuje argumentów.

W języku C++ puste nawiasy są tożsame z (void) - nie przyjmowanie argumentów, natomiast efekt taki, co puste nawiasy w C można uzyskać poprzez (...), czyli zmienną listę argumentów, ale bez określania argumentów początkowych (to z kolei nie jest dostępne w języku C).

Należy zwrócić szczególną uwagę, że jest to w istocie dość uciążliwe ułatwienie, że () jest tożsame z (void). W konsekwencji bowiem o ile wyrażenie (a) (gdzie 'a' jest jakąś zmienną) można odróżnić od nazwy typu w nawiasach, np. (int), to w przypadku () jest to nie do odróżnienia. Stąd mała niekonsekwencja w deklarowaniu obiektów wraz z argumentami konstruktora:

Klasa x( arg1, arg2 );

ale bez argumentów musi być deklarowane jako

Klasa x;

czyli bez nawiasów.

Należy też pamiętać, że odróżnianie argumentu w nawiasach od typu w nawiasach źle działa w przypadku obiektów tymczasowych:

Klasa1 obiekt( Klasa2() );

które, wbrew pozorom, nie deklaruje obiektu klasy Klasa1 z podaniem obiektu tymczasowego typu Klasa2 do konstruktora, lecz deklaruje funkcję o nazwie 'obiekt', która przyjmuje funkcję (bezparametrową, zwracającą Klasa2) i zwraca typ Klasa1. Rozwiązaniem jest dodanie nawiasów, więcej światła na ten problem rzucą poniższe przykłady:

Klasa1 o1( Klasa2 funkcja() ); // funkcja (przyjmująca funkcję)
Klasa1 o2( Klasa2 (int) );  // funkcja (przyjmująca funkcję przyjmującą jeden argument)
Klasa1 o3( Klasa2 (10) );   // obiekt (z podaniem tymczasowego obiektu, z podaniem wartości)
Klasa1 o4( (Klasa2()) );    // obiekt (z podaniem tymczasowego obiektu)

Manglowanie nazw funkcji

W związku z przeciążaniem funkcji, każda funkcja w C++ ma unikalną identyfikację, niezależną od jej nazwy. Ten identyfikator służy również do rozpoznania odpowiedniej wersji funkcji na poziomie wiązania - nawet jeśli istnieje prototyp funkcji o określonej nazwie, ale z innymi parametrami, niż te, z którymi została ta funkcja zdefiniowana, to błąd przy próbie wywołania takiej funkcji zostanie wykryty na etapie wiązania (w przypadku języka C nie zostałby wykryty w ogóle).

To spowodowało niezgodność sposobu wiązania funkcji z językiem C. Żeby móc w C++ użyć funkcji zdefiniowanej w języku C, to jej prototyp musi być poprzedzony extern "C". Taka funkcja nie może wtedy podlegać przeciążaniu (tzn. może być wiele funkcji o takiej nazwie, ale tylko jedna z nich może być extern "C").

Struktury

Jeśli mamy strukturę Struktura to w C zmienne definiujemy struct Struktura s1, s2;. W C++ możemy pominąć słowo kluczowe struct (i podobnie jest z union, enum i class). Dla zgodności z językiem C jednak nie jest zabronione ponowne użycie nazwy struktury w innym znaczeniu (np. funkcji, co ma miejsce w przypadku standardowej funkcji z języka C stat), tyle że jeśli się tak stanie, to wtedy nie można już pominąć słowa struct, jeśli się ma na myśli określony typ strukturalny.

Pozostałe

Zasoby

Linki zewnętrzne

• Thinking in C++ - darmowy, bardzo dobry podęcznik Bruce'a Eckela
  • Niekompletne, darmowe polskie tłumaczenie
• http://www.cppreference.com/ - bardzo zwięzły opis najważniejszych elementów C++
• http://it.hk.pl - kurs C++ od podstaw z przykładami
• C++ bez cholesterolu
• http://cprogramming.com Tutoriale, zasoby, artykuły o c++
• Oficjalna dokumentacja STL na stronie SGI
• http://xion.org.pl/productions/texts/coding/megatutorial/ polski tutorial "Od zera do gier kodera"

Książki

• Jerzy Grębosz, Symfonia C++
• Jerzy Grębosz, Pasja C++

Licencja

Version 1.2, November 2002

Copyright (C) 2000,2001,2002  Free Software Foundation, Inc.
51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.

0. PREAMBLE

The purpose of this License is to make a manual, textbook, or other functional and useful document "free" in the sense of freedom: to assure everyone the effective freedom to copy and redistribute it, with or without modifying it, either commercially or noncommercially. Secondarily, this License preserves for the author and publisher a way to get credit for their work, while not being considered responsible for modifications made by others.

This License is a kind of "copyleft", which means that derivative works of the document must themselves be free in the same sense. It complements the GNU General Public License, which is a copyleft license designed for free software.

We have designed this License in order to use it for manuals for free software, because free software needs free documentation: a free program should come with manuals providing the same freedoms that the software does. But this License is not limited to software manuals; it can be used for any textual work, regardless of subject matter or whether it is published as a printed book. We recommend this License principally for works whose purpose is instruction or reference.

1. APPLICABILITY AND DEFINITIONS

This License applies to any manual or other work, in any medium, that contains a notice placed by the copyright holder saying it can be distributed under the terms of this License. Such a notice grants a world-wide, royalty-free license, unlimited in duration, to use that work under the conditions stated herein. The "Document", below, refers to any such manual or work. Any member of the public is a licensee, and is addressed as "you". You accept the license if you copy, modify or distribute the work in a way requiring permission under copyright law.

A "Modified Version" of the Document means any work containing the Document or a portion of it, either copied verbatim, or with modifications and/or translated into another language.

A "Secondary Section" is a named appendix or a front-matter section of the Document that deals exclusively with the relationship of the publishers or authors of the Document to the Document's overall subject (or to related matters) and contains nothing that could fall directly within that overall subject. (Thus, if the Document is in part a textbook of mathematics, a Secondary Section may not explain any mathematics.) The relationship could be a matter of historical connection with the subject or with related matters, or of legal, commercial, philosophical, ethical or political position regarding them.

The "Invariant Sections" are certain Secondary Sections whose titles are designated, as being those of Invariant Sections, in the notice that says that the Document is released under this License. If a section does not fit the above definition of Secondary then it is not allowed to be designated as Invariant. The Document may contain zero Invariant Sections. If the Document does not identify any Invariant Sections then there are none.

The "Cover Texts" are certain short passages of text that are listed, as Front-Cover Texts or Back-Cover Texts, in the notice that says that the Document is released under this License. A Front-Cover Text may be at most 5 words, and a Back-Cover Text may be at most 25 words.

A "Transparent" copy of the Document means a machine-readable copy, represented in a format whose specification is available to the general public, that is suitable for revising the document straightforwardly with generic text editors or (for images composed of pixels) generic paint programs or (for drawings) some widely available drawing editor, and that is suitable for input to text formatters or for automatic translation to a variety of formats suitable for input to text formatters. A copy made in an otherwise Transparent file format whose markup, or absence of markup, has been arranged to thwart or discourage subsequent modification by readers is not Transparent. An image format is not Transparent if used for any substantial amount of text. A copy that is not "Transparent" is called "Opaque".

Examples of suitable formats for Transparent copies include plain ASCII without markup, Texinfo input format, LaTeX input format, SGML or XML using a publicly available DTD, and standard-conforming simple HTML, PostScript or PDF designed for human modification. Examples of transparent image formats include PNG, XCF and JPG. Opaque formats include proprietary formats that can be read and edited only by proprietary word processors, SGML or XML for which the DTD and/or processing tools are not generally available, and the machine-generated HTML, PostScript or PDF produced by some word processors for output purposes only.

The "Title Page" means, for a printed book, the title page itself, plus such following pages as are needed to hold, legibly, the material this License requires to appear in the title page. For works in formats which do not have any title page as such, "Title Page" means the text near the most prominent appearance of the work's title, preceding the beginning of the body of the text.

A section "Entitled XYZ" means a named subunit of the Document whose title either is precisely XYZ or contains XYZ in parentheses following text that translates XYZ in another language. (Here XYZ stands for a specific section name mentioned below, such as "Acknowledgements", "Dedications", "Endorsements", or "History".) To "Preserve the Title" of such a section when you modify the Document means that it remains a section "Entitled XYZ" according to this definition.

The Document may include Warranty Disclaimers next to the notice which states that this License applies to the Document. These Warranty Disclaimers are considered to be included by reference in this License, but only as regards disclaiming warranties: any other implication that these Warranty Disclaimers may have is void and has no effect on the meaning of this License.

2. VERBATIM COPYING

You may copy and distribute the Document in any medium, either commercially or noncommercially, provided that this License, the copyright notices, and the license notice saying this License applies to the Document are reproduced in all copies, and that you add no other conditions whatsoever to those of this License. You may not use technical measures to obstruct or control the reading or further copying of the copies you make or distribute. However, you may accept compensation in exchange for copies. If you distribute a large enough number of copies you must also follow the conditions in section 3.

You may also lend copies, under the same conditions stated above, and you may publicly display copies.

3. COPYING IN QUANTITY

If you publish printed copies (or copies in media that commonly have printed covers) of the Document, numbering more than 100, and the Document's license notice requires Cover Texts, you must enclose the copies in covers that carry, clearly and legibly, all these Cover Texts: Front-Cover Texts on the front cover, and Back-Cover Texts on the back cover. Both covers must also clearly and legibly identify you as the publisher of these copies. The front cover must present the full title with all words of the title equally prominent and visible. You may add other material on the covers in addition. Copying with changes limited to the covers, as long as they preserve the title of the Document and satisfy these conditions, can be treated as verbatim copying in other respects.

If the required texts for either cover are too voluminous to fit legibly, you should put the first ones listed (as many as fit reasonably) on the actual cover, and continue the rest onto adjacent pages.

If you publish or distribute Opaque copies of the Document numbering more than 100, you must either include a machine-readable Transparent copy along with each Opaque copy, or state in or with each Opaque copy a computer-network location from which the general network-using public has access to download using public-standard network protocols a complete Transparent copy of the Document, free of added material. If you use the latter option, you must take reasonably prudent steps, when you begin distribution of Opaque copies in quantity, to ensure that this Transparent copy will remain thus accessible at the stated location until at least one year after the last time you distribute an Opaque copy (directly or through your agents or retailers) of that edition to the public.

It is requested, but not required, that you contact the authors of the Document well before redistributing any large number of copies, to give them a chance to provide you with an updated version of the Document.

4. MODIFICATIONS

You may copy and distribute a Modified Version of the Document under the conditions of sections 2 and 3 above, provided that you release the Modified Version under precisely this License, with the Modified Version filling the role of the Document, thus licensing distribution and modification of the Modified Version to whoever possesses a copy of it. In addition, you must do these things in the Modified Version:

• A. Use in the Title Page (and on the covers, if any) a title distinct from that of the Document, and from those of previous versions (which should, if there were any, be listed in the History section of the Document). You may use the same title as a previous version if the original publisher of that version gives permission.
• B. List on the Title Page, as authors, one or more persons or entities responsible for authorship of the modifications in the Modified Version, together with at least five of the principal authors of the Document (all of its principal authors, if it has fewer than five), unless they release you from this requirement.
• C. State on the Title page the name of the publisher of the Modified Version, as the publisher.
• D. Preserve all the copyright notices of the Document.
• E. Add an appropriate copyright notice for your modifications adjacent to the other copyright notices.
• F. Include, immediately after the copyright notices, a license notice giving the public permission to use the Modified Version under the terms of this License, in the form shown in the Addendum below.
• G. Preserve in that license notice the full lists of Invariant Sections and required Cover Texts given in the Document's license notice.
• H. Include an unaltered copy of this License.
• I. Preserve the section Entitled "History", Preserve its Title, and add to it an item stating at least the title, year, new authors, and publisher of the Modified Version as given on the Title Page. If there is no section Entitled "History" in the Document, create one stating the title, year, authors, and publisher of the Document as given on its Title Page, then add an item describing the Modified Version as stated in the previous sentence.
• J. Preserve the network location, if any, given in the Document for public access to a Transparent copy of the Document, and likewise the network locations given in the Document for previous versions it was based on. These may be placed in the "History" section. You may omit a network location for a work that was published at least four years before the Document itself, or if the original publisher of the version it refers to gives permission.
• K. For any section Entitled "Acknowledgements" or "Dedications", Preserve the Title of the section, and preserve in the section all the substance and tone of each of the contributor acknowledgements and/or dedications given therein.
• L. Preserve all the Invariant Sections of the Document, unaltered in their text and in their titles. Section numbers or the equivalent are not considered part of the section titles.
• M. Delete any section Entitled "Endorsements". Such a section may not be included in the Modified Version.
• N. Do not retitle any existing section to be Entitled "Endorsements" or to conflict in title with any Invariant Section.
• O. Preserve any Warranty Disclaimers.

If the Modified Version includes new front-matter sections or appendices that qualify as Secondary Sections and contain no material copied from the Document, you may at your option designate some or all of these sections as invariant. To do this, add their titles to the list of Invariant Sections in the Modified Version's license notice. These titles must be distinct from any other section titles.

You may add a section Entitled "Endorsements", provided it contains nothing but endorsements of your Modified Version by various parties--for example, statements of peer review or that the text has been approved by an organization as the authoritative definition of a standard.

You may add a passage of up to five words as a Front-Cover Text, and a passage of up to 25 words as a Back-Cover Text, to the end of the list of Cover Texts in the Modified Version. Only one passage of Front-Cover Text and one of Back-Cover Text may be added by (or through arrangements made by) any one entity. If the Document already includes a cover text for the same cover, previously added by you or by arrangement made by the same entity you are acting on behalf of, you may not add another; but you may replace the old one, on explicit permission from the previous publisher that added the old one.

The author(s) and publisher(s) of the Document do not by this License give permission to use their names for publicity for or to assert or imply endorsement of any Modified Version.

5. COMBINING DOCUMENTS

You may combine the Document with other documents released under this License, under the terms defined in section 4 above for modified versions, provided that you include in the combination all of the Invariant Sections of all of the original documents, unmodified, and list them all as Invariant Sections of your combined work in its license notice, and that you preserve all their Warranty Disclaimers.

The combined work need only contain one copy of this License, and multiple identical Invariant Sections may be replaced with a single copy. If there are multiple Invariant Sections with the same name but different contents, make the title of each such section unique by adding at the end of it, in parentheses, the name of the original author or publisher of that section if known, or else a unique number. Make the same adjustment to the section titles in the list of Invariant Sections in the license notice of the combined work.

In the combination, you must combine any sections Entitled "History" in the various original documents, forming one section Entitled "History"; likewise combine any sections Entitled "Acknowledgements", and any sections Entitled "Dedications". You must delete all sections Entitled "Endorsements."

6. COLLECTIONS OF DOCUMENTS

You may make a collection consisting of the Document and other documents released under this License, and replace the individual copies of this License in the various documents with a single copy that is included in the collection, provided that you follow the rules of this License for verbatim copying of each of the documents in all other respects.

You may extract a single document from such a collection, and distribute it individually under this License, provided you insert a copy of this License into the extracted document, and follow this License in all other respects regarding verbatim copying of that document.

7. AGGREGATION WITH INDEPENDENT WORKS

A compilation of the Document or its derivatives with other separate and independent documents or works, in or on a volume of a storage or distribution medium, is called an "aggregate" if the copyright resulting from the compilation is not used to limit the legal rights of the compilation's users beyond what the individual works permit. When the Document is included in an aggregate, this License does not apply to the other works in the aggregate which are not themselves derivative works of the Document.

If the Cover Text requirement of section 3 is applicable to these copies of the Document, then if the Document is less than one half of the entire aggregate, the Document's Cover Texts may be placed on covers that bracket the Document within the aggregate, or the electronic equivalent of covers if the Document is in electronic form. Otherwise they must appear on printed covers that bracket the whole aggregate.

8. TRANSLATION

Translation is considered a kind of modification, so you may distribute translations of the Document under the terms of section 4. Replacing Invariant Sections with translations requires special permission from their copyright holders, but you may include translations of some or all Invariant Sections in addition to the original versions of these Invariant Sections. You may include a translation of this License, and all the license notices in the Document, and any Warranty Disclaimers, provided that you also include the original English version of this License and the original versions of those notices and disclaimers. In case of a disagreement between the translation and the original version of this License or a notice or disclaimer, the original version will prevail.

If a section in the Document is Entitled "Acknowledgements", "Dedications", or "History", the requirement (section 4) to Preserve its Title (section 1) will typically require changing the actual title.

9. TERMINATION

You may not copy, modify, sublicense, or distribute the Document except as expressly provided for under this License. Any other attempt to copy, modify, sublicense or distribute the Document is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance.

10. FUTURE REVISIONS OF THIS LICENSE

The Free Software Foundation may publish new, revised versions of the GNU Free Documentation License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. See http://www.gnu.org/copyleft/.

Each version of the License is given a distinguishing version number. If the Document specifies that a particular numbered version of this License "or any later version" applies to it, you have the option of following the terms and conditions either of that specified version or of any later version that has been published (not as a draft) by the Free Software Foundation. If the Document does not specify a version number of this License, you may choose any version ever published (not as a draft) by the Free Software Foundation.

How to use this License for your documents

To use this License in a document you have written, include a copy of the License in the document and put the following copyright and license notices just after the title page:

Copyright (c)  YEAR  YOUR NAME.
Permission is granted to copy, distribute and/or modify this document
under the terms of the GNU Free Documentation License, Version 1.2
or any later version published by the Free Software Foundation;
with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
A copy of the license is included in the section entitled "GNU
Free Documentation License".

If you have Invariant Sections, Front-Cover Texts and Back-Cover Texts, replace the "with...Texts." line with this:

with the Invariant Sections being LIST THEIR TITLES, with the
Front-Cover Texts being LIST, and with the Back-Cover Texts being LIST.

If you have Invariant Sections without Cover Texts, or some other combination of the three, merge those two alternatives to suit the situation.

If your document contains nontrivial examples of program code, we recommend releasing these examples in parallel under your choice of free software license, such as the GNU General Public License, to permit their use in free software.