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