WprowadzenieWprowadzenie

PK3PK3

Dr inż. Roman StarosolskiDr inż. Roman Starosolski

PokójPokój nr 52 nr 5211 ( (konsultacje konsultacje etc.)etc.)roman.starosolskiroman.starosolski@@polslpolsl.pl.pl

http://platforma.polsl.pl/rau2/course/view.php?id=161http://platforma.polsl.pl/rau2/course/view.php?id=161((http://sun.http://sun.aeiaei.polsl.pl/~rstaros/.polsl.pl/~rstaros/S/Pk34S/Pk34//))

regulaminyregulaminy materiałymateriały zasobyzasoby

Plan wykładówPlan wykładów Programowanie obiektowe w języku C++ (30h)Programowanie obiektowe w języku C++ (30h)

Dr inż. R.StarosolskiDr inż. R.Starosolski

Zaawansowane biblioteki C++ (10h)Zaawansowane biblioteki C++ (10h)Dr hab. inż. prof. S.DeorowiczDr hab. inż. prof. S.Deorowicz

Podstawy języka C# (10h)Podstawy języka C# (10h)Dr inż. D. MyszorDr inż. D. Myszor

Plan wykładówPlan wykładówProgramowanie obiektowe, język C++ (30h)Programowanie obiektowe, język C++ (30h)1.1. WprowadzenieWprowadzenie2.2. Rozszerzenia nieobiektoweRozszerzenia nieobiektowe3.3. Paradygmat obiektowy, klasaParadygmat obiektowy, klasa4.4. Konstruktor, destruktorKonstruktor, destruktor5.5. OperatoryOperatory6.6. DziedziczenieDziedziczenie7.7. Metody wirtualne, polimorfizm, RTTIMetody wirtualne, polimorfizm, RTTI8.8. Dziedziczenie wielobazoweDziedziczenie wielobazowe9.9. WzorceWzorce10.10. Obsługa wyjątkówObsługa wyjątków11.11. Biblioteka standardowa Biblioteka standardowa 12.12. STLSTL

C++ C++ historiahistoria 1983: C with classes -> C++1983: C with classes -> C++

z virtual, bez klas abstrakcyjnych, dziedziczenia wielobazowego, szablonów, z virtual, bez klas abstrakcyjnych, dziedziczenia wielobazowego, szablonów, wyjątków, STL …wyjątków, STL …

C++98/C++03 C++98/C++03 Pierwszy formalny standard i jego korekta (major release)Pierwszy formalny standard i jego korekta (major release)

C++TR1 (2007)C++TR1 (2007) Rozszerzona biblioteka standardowa, nieobligatoryjnyRozszerzona biblioteka standardowa, nieobligatoryjny

(C++0x)/C++11(C++0x)/C++11 Rozszerzenia, programowanie generyczne (major release)Rozszerzenia, programowanie generyczne (major release)

C++14C++14 minor releaseminor release

C++17C++17

Przeznaczenie językaPrzeznaczenie języka Better Better C C

DData abstraction ata abstraction tooltool

OObject-oriented programming bject-oriented programming tooltool

GGeneric programming eneric programming tool tool NEW 2011 !NEW 2011 !

Książki oKsiążki o C++ C++ Bjarne Stroustrup „Język C++” WNT W-wa Bjarne Stroustrup „Język C++” WNT W-wa

International Standard for Information Systems—Programming Language C++, ANSI

Książki oKsiążki o C++ C++ Grębosz J.: Symfonia C++. RM, W-wa, Grębosz J.: Symfonia C++. RM, W-wa,

Grębosz J.: Pasja C++. RM, W-wa, Grębosz J.: Pasja C++. RM, W-wa,

Nicolai M. Josuttis: C++ Biblioteka Nicolai M. Josuttis: C++ Biblioteka standardowa Podręcznik Programisty, Helionstandardowa Podręcznik Programisty, Helion

Materiały online oMateriały online o C++ C++ [1] Programming Language C++, ANSI IS working draft 2014[1] Programming Language C++, ANSI IS working draft 2014

http://open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3797.pdfhttp://open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3797.pdf

[2] cplusplus.com[2] cplusplus.comhttp://www.cplusplus.com/reference/http://www.cplusplus.com/reference/

[3] C++11 wiki page (jest też wersja PL)[3] C++11 wiki page (jest też wersja PL)http://en.wikipedia.org/wiki/C%2B%2B11http://en.wikipedia.org/wiki/C%2B%2B11

[4] C++11 FAQ by Bjarne Stroustrup[4] C++11 FAQ by Bjarne Stroustruphttp://www.stroustrup.com/C++11FAQ.htmlhttp://www.stroustrup.com/C++11FAQ.html

[5] C++14 wiki page [5] C++14 wiki page http://en.wikipedia.org/wiki/C%2B%2B14http://en.wikipedia.org/wiki/C%2B%2B14

[6] Tzw. „help” środowiska zintegrowanego, np. VisualStudio[6] Tzw. „help” środowiska zintegrowanego, np. VisualStudio

Nieobiektowe Nieobiektowe rozszerzenia rozszerzenia C++C++

Hello World!Hello World!#include <iostream>#include <iostream>using namespace std;using namespace std;

int main()int main(){{ cout << "Hello World!";cout << "Hello World!";}}

Przestrzenie nazwPrzestrzenie nazw Przestrzeń nazw – co to takiego?Przestrzeń nazw – co to takiego?

namespacenamespace

Kiedy potrzebujemy przestrzeni nazw?Kiedy potrzebujemy przestrzeni nazw?

Przestrzenie nazw - używaniePrzestrzenie nazw - używanienamespace mojanamespace moja{{

void printf(int);void printf(int);class plik;class plik;void fprintf(const plik&, int);void fprintf(const plik&, int);

}}

moja::printf(44);moja::printf(44);moja::plik plikwe;moja::plik plikwe;fprintf(plikwe, 31415323);fprintf(plikwe, 31415323); // wystarczy, że jeden z argumentów// wystarczy, że jeden z argumentów

// należy do przestrzeni moja, aby funkcja// należy do przestrzeni moja, aby funkcja// fprintf była najpierw szukana w przestrzni moja// fprintf była najpierw szukana w przestrzni moja// (reguła wyszukiwania Koeniga)// (reguła wyszukiwania Koeniga)

Przestrzenie nazw - używaniePrzestrzenie nazw - używanie Nazwę (lub wszystkie nazwy) z przestrzeni nazw można Nazwę (lub wszystkie nazwy) z przestrzeni nazw można

przenieść na globalny (lokalny) poziom widocznościprzenieść na globalny (lokalny) poziom widoczności using moja::plik; using moja::plik; using namespace moja;using namespace moja;

Nie używaj using w plikach nagłówkowych!Nie używaj using w plikach nagłówkowych! dlaczego?dlaczego? używaj kwalifikacji nazwa_namespace::nazwa_z_namespace!używaj kwalifikacji nazwa_namespace::nazwa_z_namespace!

Przestrzenie nazw można dowolnie rozszerzać i łączyćPrzestrzenie nazw można dowolnie rozszerzać i łączyć w jednym plikuw jednym pliku w kilku plikachw kilku plikach

Przestrzenie nazw - stdPrzestrzenie nazw - std biblioteka standardowa jest zdefiniowana w biblioteka standardowa jest zdefiniowana w

przestrzeni nazw std.przestrzeni nazw std. klasy strumienioweklasy strumieniowe klasy łańcuchoweklasy łańcuchowe STLSTL #include <iostream>#include <iostream>

using namespace std;using namespace std;

int main()int main(){{ cout << "Hello cout << "Hello

World!";World!";}}

Standardowe wejście i wyjścieStandardowe wejście i wyjście Operatory strumieniowe nie są tak podatne na błędy, jak Operatory strumieniowe nie są tak podatne na błędy, jak

funkcje z <stdio.h> (vide scanf() )funkcje z <stdio.h> (vide scanf() )

Można używać nawet operatorów C++ <iostream> razem z Można używać nawet operatorów C++ <iostream> razem z funkcjami C z <stdio.h> (są funkcje synchronizujące), ale funkcjami C z <stdio.h> (są funkcje synchronizujące), ale zaleca się ograniczyć się do strumieni C++zaleca się ograniczyć się do strumieni C++

StrumienieStrumienie cin cin - std. input- std. input coutcout - std. output- std. output cologcolog - log output- log output cerrcerr - std. error output (niebuforowany)- std. error output (niebuforowany)

KomentarzKomentarz/* /* komentarz komentarz C, C, stosowanystosowany

również wrównież w C++, C++, wielowierszowy wielowierszowy */ */

// // jednowierszowy komentarz jednowierszowy komentarz C++ C++ // // od „//” do końca wierszaod „//” do końca wiersza

#if 0#if 0Nadal można używać preprocesora do „wyłączania”Nadal można używać preprocesora do „wyłączania”większych fragmentów kodu źródłowegowiększych fragmentów kodu źródłowego

#endif#endif

KomentarzKomentarz

/* /* do komentarzy wielowierszowychdo komentarzy wielowierszowychużywaj komentarza z C lub z C++używaj komentarza z C lub z C++ */ */

// // lecz ich nie mieszajlecz ich nie mieszaj !!! !!!

void foo()void foo() // // tutaj użyj komentarza z C++tutaj użyj komentarza z C++{{

return; return; // // wygodniejszy i bezpieczniejszywygodniejszy i bezpieczniejszy}}

gotogoto ograniczenia w stosunku doograniczenia w stosunku do C: C:

tylko wewnątrz blokutylko wewnątrz bloku skok nie może pominąć inicjalizacjiskok nie może pominąć inicjalizacji zdecydowanie zaleca się unikanie gotozdecydowanie zaleca się unikanie goto

gotogotoa:a:

int foo()int foo(){{

b:b:goto b;goto b;int i=7;int i=7;

c:c:return i;return i;

}}d:d:

void foofoo()void foofoo(){{

e:e:return;return;

}}

TypTypyy silna kontrola typówsilna kontrola typów ( (w porównaniu do w porównaniu do C) – C) – aby aby

umożliwić kontrolę błędówumożliwić kontrolę błędów nie ma automatycznej konwersji void* do innych nie ma automatycznej konwersji void* do innych

typów wskaźnikowychtypów wskaźnikowych automatyczna konwersja typówautomatyczna konwersja typów – – gdy nie prowadzi gdy nie prowadzi

do niejednoznacznoścido niejednoznaczności gdy to tylko możliwe, konwersja bez utraty gdy to tylko możliwe, konwersja bez utraty

precyzji/informacjiprecyzji/informacji ( (nie gwarantowane dla nie gwarantowane dla wszystkich konwersjiwszystkich konwersji: : cchar/short/int/long/single/har/short/int/long/single/ float/double/signed/unsigned)float/double/signed/unsigned)

*_cast*_castoperatory rzutowania dla zastąpienia rzutowania w stylu operatory rzutowania dla zastąpienia rzutowania w stylu

języka Cjęzyka C

staticstatic_cast_cast << type-id type-id > > (( wyrażeniewyrażenie )) dynamic_castdynamic_cast << type-id type-id > > (( wyrażeniewyrażenie )) reinterpretreinterpret_cast_cast << type-id type-id > > (( wyrażeniewyrażenie ))

unsigned int adress=reinterpret_cast<unsigned int>(ptr);unsigned int adress=reinterpret_cast<unsigned int>(ptr);

constconst_cast_cast << type-id type-id > > (( wyrażeniewyrażenie ))

to 4 operatory i 4 słowa kluczowe C++to 4 operatory i 4 słowa kluczowe C++ zaprojektowane by umożliwić większą kontrolę na poziomie kompilacji i zaprojektowane by umożliwić większą kontrolę na poziomie kompilacji i

wykonania kodu nad (podatnymi na błędy) rzutowaniamiwykonania kodu nad (podatnymi na błędy) rzutowaniami pozwalają wyrazić intencję programistypozwalają wyrazić intencję programisty szczegółowo omówimy je późniejszczegółowo omówimy je później

TypTypyy gdy nie określono typu, przyjmuje się intgdy nie określono typu, przyjmuje się int

unsigned u;unsigned u;const a; const a; static i; static i;

zaleca się jawne określanie typu intzaleca się jawne określanie typu int

autoauto Stare znaczenie z języka C (zm. automatyczna) nie Stare znaczenie z języka C (zm. automatyczna) nie

obowiązuje (C++11)!obowiązuje (C++11)! Nowe znaczenie – typ ma zostać określony przez Nowe znaczenie – typ ma zostać określony przez

kompilator na podstawie wyrażenia inicjalizującegokompilator na podstawie wyrażenia inicjalizującego

auto pi=3.141592; // doubleauto pi=3.141592; // double

Użyteczny dla złożonych typów i programowania Użyteczny dla złożonych typów i programowania generycznego – szczgóły omówimy późniejgenerycznego – szczgóły omówimy później

enumenum

enum numbers {ZERO, ONE, FIVE=5, SIX}; enum numbers {ZERO, ONE, FIVE=5, SIX}; „„numbers” numbers” to opcjonalna nazwa nowego typuto opcjonalna nazwa nowego typu konwersja automatyczna z enum na intkonwersja automatyczna z enum na int

dlaczego dlaczego enum enum nie jest popularnenie jest popularne??

enum class Kolor:char (Czerwony, Zielony);enum class Kolor:char (Czerwony, Zielony); „„Strong enum” jawny typ bazowy (musi być całkowity)Strong enum” jawny typ bazowy (musi być całkowity) wartości tylko w zakresie enumeracji Kolor::Czerwonywartości tylko w zakresie enumeracji Kolor::Czerwony

ReferencReferencjeje

Referencja do typuReferencja do typu T: T& T: T&

void increment_p (int * pi)void increment_p (int * pi){{ (*pi)++;(*pi)++;}}

void increment_r (int & ri)void increment_r (int & ri){{ ri++;ri++;}}

int main(){ int i=1; increment_p(&i); increment_r(i);}

ReferencReferencjeje mogą wprowadzać w błądmogą wprowadzać w błąd unikaj funkcji modyfikującej swoje argumentyunikaj funkcji modyfikującej swoje argumenty

używaj referencji, gdy ich rzeczywiście potrzebujeszużywaj referencji, gdy ich rzeczywiście potrzebujesz dla oszczędzania pamięcidla oszczędzania pamięci dla oszczędzania czasudla oszczędzania czasu do zwracania obiektów, które będą dalej przetwarzanedo zwracania obiektów, które będą dalej przetwarzane

używaj stałych referencji (optymalizacja, używaj stałych referencji (optymalizacja, bezpieczeństwo)bezpieczeństwo)

constexpr – generalized const constexpr – generalized const expressionexpression

Deklarujemy możliwość wyznaczenia podczas kompilacjiDeklarujemy możliwość wyznaczenia podczas kompilacji Dla zmiennych/obiektów: zmienna da się tak wyznaczyć (w przeciwnym razie błąd), jest const, może być Dla zmiennych/obiektów: zmienna da się tak wyznaczyć (w przeciwnym razie błąd), jest const, może być

przechowywana w tablicach kompilatora a nie pamięciprzechowywana w tablicach kompilatora a nie pamięci Dla funkcji: funkcja jest prosta (… pojedynczy return z wyrażeniem, bez dekl. zmiennych), jeżeli Dla funkcji: funkcja jest prosta (… pojedynczy return z wyrażeniem, bez dekl. zmiennych), jeżeli

argumenty będą znane podczas kompilacji, to wynik funkcji teżargumenty będą znane podczas kompilacji, to wynik funkcji też Dla konstruktorów: jak funkcja, jeżeli argumenty będą znane podczas kompilacji, to cały obiekt nim Dla konstruktorów: jak funkcja, jeżeli argumenty będą znane podczas kompilacji, to cały obiekt nim

utworzony teżutworzony też

Przykłady za [1]Przykłady za [1]

enum Flags { good=0, fail=1, bad=2, eof=4 };enum Flags { good=0, fail=1, bad=2, eof=4 };

constexpr int x1 = bad|eof;constexpr int x1 = bad|eof; // ok// ok

void f(Flags f3)void f(Flags f3){{

constexpr int x2 = bad|f3;constexpr int x2 = bad|f3; // error: can't evaluate at compile time // error: can't evaluate at compile timeint x3 = bad|f3;int x3 = bad|f3; // ok // ok

}}

constexpr – generalized const constexpr – generalized const expressionexpression

enum Flags { good=0, fail=1, bad=2, eof=4 };enum Flags { good=0, fail=1, bad=2, eof=4 };

constexpr int operator|(Flags f1, Flags f2) constexpr int operator|(Flags f1, Flags f2) { {

return Flags(int(f1)|int(f2)); return Flags(int(f1)|int(f2)); }}

void f(Flags x)void f(Flags x){{

switch (x) {switch (x) {case bad: /* ... */ break;case bad: /* ... */ break;case eof: /* ... */ break;case eof: /* ... */ break;case bad|eof: /* ... */ break;case bad|eof: /* ... */ break;default: /* ... */ break;default: /* ... */ break;}}

}}

FunkcjeFunkcje – Prototyp – Prototypyy

C++ wymaga prototypów funkcjiC++ wymaga prototypów funkcji!!!!!!((wartość zwracana, nazwa, argumentywartość zwracana, nazwa, argumenty))

#include „foo_prototypes.h”#include „foo_prototypes.h”

void foo();void foo();

void foo() {};void foo() {};

Funkcje Funkcje – inline– inlineinline int sum(int a, int b)inline int sum(int a, int b){{

return a+b;return a+b;}}

zastępstwo makrodefinicjizastępstwo makrodefinicji „„inlineinline”” to tylko zalecenie dla kompilatorato tylko zalecenie dla kompilatora automatyczne rozwijanie inline funkcjiautomatyczne rozwijanie inline funkcji funkcja rozwinięta funkcja rozwinięta inline inline nie ma adresunie ma adresu

Funkcje przeciążone (overloaded)Funkcje przeciążone (overloaded)

wiele funkcji o tej samej nazwiewiele funkcji o tej samej nazwie, OK. , OK. ww C++ C++

int f(int, int); int f(int, int); int f(int); int f(int); int f(long); int f(long);

Funkcje przeciążoneFunkcje przeciążone Adres Adres funkcji przeciążonejfunkcji przeciążonej – – kkompilompilator ator

wymaga przesłanek wyboru wariantu funkcjiwymaga przesłanek wyboru wariantu funkcji

int (*pd)(long);int (*pd)(long); //OK//OKpd=f;pd=f;

void *pf;void *pf; // pf=f;// pf=f; // ERROR!// ERROR!

Funkcje przeciążoneFunkcje przeciążone ParametParametryry funkcji przeciążonej muszą się różnićfunkcji przeciążonej muszą się różnić,, Typ Typ zwracany nie służy do rozróżniania funkcji zwracany nie służy do rozróżniania funkcji

przeciążonychprzeciążonych, , jest istotny gdy funkcja jest wywoływanajest istotny gdy funkcja jest wywoływana

int f(int, int); int f(int); int f(long); // OKint f(int, int); int f(int); int f(long); // OK// int f(int); double f(int); ERROR// int f(int); double f(int); ERROR

int fint fff(int); int f(int); int fff(double); // OK.(double); // OK.// f// fff(1L) ERROR! (1L) ERROR! niejednoznacznośćniejednoznaczność// void *p=f// void *p=fff(1) ERROR! typ(1) ERROR! typ zwracany zwracany

Dopasowywanie funkcji Dopasowywanie funkcji przeciążonychprzeciążonych

nie więcej niż jedna konwersja każdego argumentu wybierany najniższy poziom z możliwym dopasowaniem,

niejednoznaczność to błąd dopasowania

1. ścisła zgodność; bez konwersji lub tylko: nazwa tablicy na wskaźnik, nazwa funkcji na wskaźnik, T na const T T

2. zgodność przy promocjach w zakresie typów całkowitych: char na int, short na int, poprzednie dla typów bez znaku, float na double

3. konwersje standardowe: int ↔ double, pochodna* na podstawowa*, unsigned int ↔ int

4. konwersje zdef. przez użytkownika5. zgodność przy zastosowaniu wielokropka (…)

Dopasowywanie funkcji Dopasowywanie funkcji przeciążonychprzeciążonych

int f(int);double f(double)void f();

int i1=f(1); // OKint i2=f(1.0); // OK, wywołanie double f(double),

// konwersja wyniku int//int i3=f(„Hi”); ERROR! nie ma konwersji// char * do int ani do double

Funkcje przeciążoneFunkcje przeciążone wygodne rozszerzenie konwersji automatycznych i jawnychwygodne rozszerzenie konwersji automatycznych i jawnych

int cmp (double a, double b)int cmp (double a, double b) {{

return areturn a – – b;b;}}

int cmp (char *a, char *b)int cmp (char *a, char *b) {{

return strcmp(a,b);return strcmp(a,b);}}

Funkcje przeciążoneFunkcje przeciążone nadal korzystamy z konwersji automatycznychnadal korzystamy z konwersji automatycznych

cmp (1, 2);cmp (1, 2); //OK., //OK., konwersja dokonwersja do double double przedprzed////wywołaniemwywołaniem cmp (double a, double b) cmp (double a, double b)

można zoptymalizować kodmożna zoptymalizować kod

int cmp (int a, int b)int cmp (int a, int b) // // terazteraz cmp(1, 2) cmp(1, 2) bez konwersjibez konwersji{{

return areturn a – – b;b;}}

Domyślne argumenty funkcjiDomyślne argumenty funkcjivoid line(int len, char c=‘*’)void line(int len, char c=‘*’){{

for (int i=0; i<len; i++)for (int i=0; i<len; i++)cout << c;cout << c;

}}

teraz toteraz to: : line(x);line(x);znaczyznaczy:: line(x, ‘*’);line(x, ‘*’);

a toa to: : line(x, ‘o’);line(x, ‘o’);znaczyznaczy:: line(x, ‘o’);line(x, ‘o’);

Domyślne argumenty funkcjiDomyślne argumenty funkcjiint fun(int i1, int i2=20, int i3=30);int fun(int i1, int i2=20, int i3=30);

po pierwszym domyślnym wszystkie następne muszą być po pierwszym domyślnym wszystkie następne muszą być domyślnedomyślne

funkcja taka nie jest przeciążonafunkcja taka nie jest przeciążona, , &fun(int) == &fun(int, int)&fun(int) == &fun(int, int)

możemy niezależnie stosować przeciążaniemożemy niezależnie stosować przeciążanie: : int fun(int fun(char cchar c); );

argumenty domyślne można zdefiniować tylko razargumenty domyślne można zdefiniować tylko raz (formal (formalnie nie albo w prototypie, albo w definicjialbo w prototypie, albo w definicji).).Argumenty domyślne definiuj w pliku nagłówkowymArgumenty domyślne definiuj w pliku nagłówkowym!!

Zmienna liczba argumentów Zmienna liczba argumentów funkcjifunkcji

ww C C pisaliśmypisaliśmy::int printf(char *, …);int printf(char *, …);

ww C++ C++ jest prościejjest prościej::int printf(char * …); int printf(char * …); // // można pominąć przecinek przed …można pominąć przecinek przed …, , // ale tylko wtedy,// ale tylko wtedy, gdy zmienna poprzedzającagdy zmienna poprzedzająca „…” „…” // nie ma wartości domyślnej// nie ma wartości domyślnej..

ww C++ C++ jest jeszcze prościejjest jeszcze prościej::funkcje można przeciążaćfunkcje można przeciążać

ww C++ C++ jest jeszcze prościejjest jeszcze prościej::można definiować wzorce funkcjimożna definiować wzorce funkcji

Zarządzanie pamięcią - Zarządzanie pamięcią - przypomnienieprzypomnienie

przydział pamięciprzydział pamięci: operator new: operator newskładniaskładnia: new Typ: new Typ

int * pi = new int; int * pi = new int; // pi = (int*)malloc(sizeof(int))// pi = (int*)malloc(sizeof(int))

zwolnieniezwolnienie: operator delete: operator deleteskładniaskładnia: delete pointer: delete pointer

delete pi;delete pi; // // operator delete nie zmienia wartościoperator delete nie zmienia wartości// swojego argumentu// swojego argumentu

Uwaga: NULL został zastąpiony przez nullptrUwaga: NULL został zastąpiony przez nullptr

Zarządzanie pamięcią - tabliceZarządzanie pamięcią - tablice zarządzanie wektoramizarządzanie wektorami ( (tablicamitablicami))

int * pai = new int [x]; int * pai = new int [x]; delete [] pai; delete [] pai;

programista sam decyduje, którą wersję operatora delete użyć programista sam decyduje, którą wersję operatora delete użyć ((kompilator tego nie sprawdzi i nie ostrzeżekompilator tego nie sprawdzi i nie ostrzeże))

wielowymiarowe tablice:wielowymiarowe tablice:int *pmai = new int[x][20][30] int *pmai = new int[x][20][30]

// // wszystkie wymiary, za wyjątkem pierwszego,wszystkie wymiary, za wyjątkem pierwszego,// // muszą być znane już podczas kompilacjimuszą być znane już podczas kompilacji

delete [] pmai;delete [] pmai;

Zarządzanie pamięciąZarządzanie pamięcią można zadeklarować funkcjęmożna zadeklarować funkcję (new_handler) (new_handler), będzie , będzie

wywołana gdy zabraknie pamięciwywołana gdy zabraknie pamięciset_new_handler(); //set_new_handler(); // <new> <new>

gdy nie zdefiniowanogdy nie zdefiniowano new new__handlerhandler, po niepowodzeniu , po niepowodzeniu new new zwracazwraca nullptr nullptr ( (dawniej dawniej NULLNULL/0/0) )

delete delete nullptrnullptr; ; //nie robi nic//nie robi nic

nie mieszaj new/delete z malloc/free nie mieszaj new/delete z malloc/free (unikaj malloc/free)(unikaj malloc/free)

Zarządzanie pamięciąZarządzanie pamięcią inteligentne wskaźniki inteligentne wskaźniki

unique_ptrunique_ptrshared_ptrshared_ptrweak_ptrweak_ptr

nie wymagają zwalniana pamięcinie wymagają zwalniana pamięci będą omówione późniejbędą omówione później

Inne rozszerzenia - funkcjeInne rozszerzenia - funkcje Rozszerzenia nieobiektowe użyteczne przede Rozszerzenia nieobiektowe użyteczne przede

wszystkim w programowaniu wszystkim w programowaniu obiektowym/generycznym, omówimy je obiektowym/generycznym, omówimy je później:później: alternatywna składnia definicji funkcjialternatywna składnia definicji funkcji funkcje lambdafunkcje lambda

Ujednolicona inicjalizacjaUjednolicona inicjalizacjainitializer_listinitializer_list

Ujednolicona składnia inicjalizacji agregatów i zm. skalarnychUjednolicona składnia inicjalizacji agregatów i zm. skalarnych

int tab[] = {1, 2, 3, 4}, x={3}, y{4};int tab[] = {1, 2, 3, 4}, x={3}, y{4};vector< string > = {„one”, „two”, „three”, „four”};vector< string > = {„one”, „two”, „three”, „four”};

Można użyć do deklaracji funkcji ze zmienną liczbą argumentówMożna użyć do deklaracji funkcji ze zmienną liczbą argumentów

Realizowane za pomocą szablonu : Realizowane za pomocą szablonu : initializer_list<T_elem>initializer_list<T_elem>

(szablony omówimy poźniej)(szablony omówimy poźniej)

for – nowa składniafor – nowa składniafor ( zmienna : zakres)for ( zmienna : zakres)

instrukcja;instrukcja; Zakres może być:Zakres może być:

Kontener STL, lub inny obiekt z metodami .begin() i .end()Kontener STL, lub inny obiekt z metodami .begin() i .end() TablicaTablica string string initializer_listinitializer_list

for – nowa składniafor – nowa składniaint main()int main(){{

char napis[] = "Hello World!";char napis[] = "Hello World!";

for (auto &c : napis)for (auto &c : napis)c = toupper(c);c = toupper(c);

for (auto c : napis)for (auto c : napis)cout << c;cout << c;cout << endl;cout << endl;

for (const auto x : {for (const auto x : { 2, 0, 1, 6 2, 0, 1, 6}) cout << x ;}) cout << x ;cout << endl;cout << endl;

return 0;return 0;}}

Inne rozszerzeniaInne rozszerzenia Szablony (Szablony (TemplatesTemplates))

Wyjątki (Wyjątki (ExceptionsExceptions))

Wątki (Threads)Wątki (Threads)

... i wiele, wiele innych ...... i wiele, wiele innych ...