\documentclass[10pt]{beamer}

\usetheme{CambridgeUS}
\usecolortheme{rose}
\usepackage[polish]{babel}
\usepackage[T1]{fontenc}
\usepackage[utf8]{inputenc}
\usepackage{listings}
\lstset{language=C++,
	basicstyle=\ttfamily,
	keywordstyle=\color{blue}\ttfamily,
	stringstyle=\color{red}\ttfamily,
	commentstyle=\color{magenta}\ttfamily,
}

\title{\textsf{C++11} w domu i~zagrodzie}
\author{Bartosz Szreder}
\date{}

\begin{document}


\frame{\maketitle}

\begin{frame}[t]{O czym \textbf{nie} zamierzam mówić}
	\pause
	\ldots co nie znaczy, że nie mogę.
	\pause
	\begin{block}{}
		\begin{itemize}
			\item \texttt{<regex>}
			\item \texttt{<memory>}: \texttt{unique\_ptr}, \texttt{shared\_ptr}, \texttt{weak\_ptr}
			\item $\lambda$-abstrakcja
			\item \textit{variadic templates}, \texttt{<tuple>}, metaprogramowanie
			\item wielowątkowość
			\item \textit{rvalue reference}, \textit{move semantics}
			\item delegacja konstruktorów
		\end{itemize}
	\end{block}
\end{frame}

\section{Ostateczne rozwiązanie kwestii \texttt{NULL}-pointerów}

\begin{frame}[fragile]{Ostateczne rozwiązanie kwestii \texttt{NULL}-pointerów}
	\begin{block}{}
		\texttt{NULL} nie jest częścią języka, a~makrodefinicją.

		\begin{lstlisting}
			//<cstddef>
			#ifndef __cplusplus
			#define NULL ((void *)0)
			#else   /* C++ */
			#define NULL 0
		\end{lstlisting}
	\end{block}
\end{frame}

\begin{frame}[fragile]
	\begin{alertblock}{Problem}
		\begin{lstlisting}
			void f(int);
			void f(char *);
		\end{lstlisting}
		\pause
		Co się stanie jak wywołamy \texttt{f(NULL)}?
	\end{alertblock}

	\pause
	\vspace{0.5cm}
	Żeby nie było takich sytuacji, mamy od teraz \texttt{nullptr}:
	\begin{block}{}
		\begin{lstlisting}
			f(nullptr);
			int *p = nullptr;
		\end{lstlisting}
	\end{block}
\end{frame}

\section{,,Specyfikatory'' \texttt{override} i~\texttt{final}}

\begin{frame}[fragile]{,,Specyfikatory'' \texttt{override} i~\texttt{final}}
	Jawnie deklarujemy metody jako \textit{przeciążające} bazowe metody wirtualne:
	\begin{block}{}
		\begin{lstlisting}
			class A {
			public:
			    virtual void f(int);
			    virtual void g(int);
			};

			class B : public A {
			public:
			    void f(int) override;       //OK
			    void g(long long) override; //compile error
			};
		\end{lstlisting}
	\end{block}
\end{frame}

\begin{frame}[fragile]
	Możemy też zabronić przeciążania:
	\begin{block}{}
		\begin{lstlisting}
			class A {
			public:
			    virtual void f(int);
			    virtual void g(int) final;
			};

			class B : public A {
			public:
			    void f(int) override; //OK
			    void g(int) override; //compile error
			};
		\end{lstlisting}
	\end{block}
\end{frame}

\begin{frame}[fragile]
	Możemy nawet zabronić dziedziczenia:
	\begin{block}{}
		\begin{lstlisting}
			class A final { ... };
			class B : A { ... }; //compile error
		\end{lstlisting}
	\end{block}
\end{frame}

\begin{frame}[fragile]
	Gdzie to się może przydać?

	\pause
	\begin{block}{Przykład 1.}
		Zmiana sygnatury metody w~klasie bazowej i~niezrobienie tego w~klasie pochodnej.
		Mamy złapanie błędu na~etapie kompilacji.
	\end{block}

	\pause
	\begin{block}{Przykład 2.}
		Real-life problem, który udało mi się wygenerować programując w Qt:
		\begin{lstlisting}
			class SomeQtClass {
			public:
			    virtual int rowCount(const QModelIndex &) const;
			};

			class MyClass : public SomeQtClass {
			public:
			    int rowCount(const QModelIndex &);
			};
		\end{lstlisting}
	\end{block}

	\pause
	\textbf{Gdzie jest błąd?}
\end{frame}

\section{Operatory rzutowania/konwersji \texttt{explicit}}

\begin{frame}[fragile]{Operatory rzutowania/konwersji \texttt{explicit}}
	Dobra praktyka z~poprzedniego standardu: niektóre konstruktory warto prefiksować słowem kluczowym \texttt{explicit}.
	Bez tego kompilator ma~prawo dokonać niejawnej konwersji np. w~takiej sytuacji:
	\begin{block}{}
		\begin{lstlisting}
			class MyClass {
			public:
			    MyClass(int);
			};

			void f(MyClass);

			f(42);          //OK
			MyClass x = 42; //OK
		\end{lstlisting}
	\end{block}
\end{frame}

\begin{frame}[fragile]
	\begin{block}{Wersja z~konstruktorem \texttt{explicit}}
		\begin{lstlisting}
			class MyClass {
			public:
			    explicit MyClass(int);
			};

			f(42);                    //compile error
			f(MyClass(42));           //OK
			MyClass x = 42;           //compile error
			MyClass x(42);            //OK
			MyClass x = MyClass(42);  //OK
		\end{lstlisting}
	\end{block}
\end{frame}

\begin{frame}[fragile]
	Poprzedni standard dozwalał też na~implementację operatorów konwersji:
	\begin{block}{}
		\begin{lstlisting}
			class MyClass {
			public:
			    operator int() const
			    {
			        return value;
			    }

			private:
			    int value;
			};

			void f(int);

			MyClass x;
			f(x);      //OK
			int a = x; //OK
		\end{lstlisting}
	\end{block}
\end{frame}

\begin{frame}[fragile]
	Można w~ten sposób konwertować w~dowolnie złożone typy, np. \texttt{QString} lub~własne.
	Przydatne chociażby w~konwersji do~napisów celem wypisek debugowych.
	Silne, ale~niebezpieczne. Nowy standard umożliwia definiowanie takich operatorów jako \texttt{explicit}.

	\pause
	\begin{block}{}
		\begin{lstlisting}
			class MyClass {
			public:
			    explicit operator int() const;
			};

			void f(int);

			MyClass x;
			f(x);                        //compile error
			f(static_cast<int>(x));      //OK
			f(int(x));                   //OK
			int a = x;                   //compile error
			int a = static_cast<int>(x); //OK
			int a = int(x);              //OK
			int a(x);                    //OK
		\end{lstlisting}
	\end{block}
\end{frame}

\section{Wsparcie dla napisów UTF}

\begin{frame}{Wsparcie dla napisów UTF}
	W~poprzednim standardzie oprócz \texttt{\dq{}standardowych\dq} napisów typu \texttt{char *}
	umieszczanych w~cudzysłowie można było użyć przedrostka \texttt{L} i~pisać \texttt{L\dq{}napisy\dq{}}
	typu \texttt{wchar\_t *}.

	\pause
	\begin{alertblock}{}
	W zasadzie nikt nie wie co to jest \texttt{wchar\_t} (\textit{wide char}).
	\end{alertblock}

	\pause
	Od teraz można też definiować napisy:
	\begin{itemize}
		\item UTF-8 przedrostkiem \texttt{u8} (typ \texttt{char *}),
		\item UTF-16 przedrostkiem \texttt{u} (nowy typ \texttt{char16\_t *}),
		\item UTF-32 przedrostkiem \texttt{U} (nowy typ \texttt{char32\_t *}).
	\end{itemize}
\end{frame}

\begin{frame}
	Pojedyncze ,,krzaki'' można wstawiać ciągiem heksadecymalnym. Zamiast zwyczajowego
	\texttt{0x} wstawiamy przedrostek:
	\begin{itemize}
		\item dla UTF-8 i~UTF-16 cztery cyfry (2 bajty) \texttt{\textbackslash{}u1234},
		\item dla UTF-32 osiem cyfr (4 bajty) \texttt{\textbackslash{}U12345678}.
	\end{itemize}

	\pause
	\begin{block}{}
		W~zasadzie jeśli używamy Qt, to pewnie lepiej jest korzystać z~tamtejszych wynalazków,
		jak np. \texttt{QString::fromUtf8()}. Ale nie wszyscy korzystają z~Qt\ldots
	\end{block}
\end{frame}

\section{Raw string literals}

\begin{frame}[fragile]{\textit{Raw string literals}}
	Jeśli musimy wpisać do~kodu źródłowego tekst o~sporej liczbie śmiesznych znaczków typu
	apostrofy, cudzysłowy, backslashe itp. (regexpy, interpretery, parsery, HTML, XML, OMG, WTF\ldots),
	to szybko można się pogubić w~\textit{escapingu}.

	\pause
	\begin{block}{}
		const QString regexp = \dq{}\textbackslash\textbackslash\textbackslash{}*(\textbackslash'|\textbackslash\dq{})\textbackslash*\textbackslash\textbackslash\dq{};
	\end{block}

	\pause
	Lepiej:
	\begin{block}{}
		const QString regexp = R"(\textbackslash{}*('|")*\textbackslash{})";
	\end{block}

	\pause
	\textit{(To wyrażenie powyżej najpewniej nie ma żadnego sensu.
		Nothing to see here, move along.)}
\end{frame}

\begin{frame}[fragile]
	\begin{itemize}
		\item
		\textit{Raw strings} umieszczamy w~ciągu \texttt{R\dq{}(\ldots)\dq{}}.

		\pause
		\item
		Możemy też w~ten sposób: \texttt{R\dq{}separator(\ldots)separator\dq{}},
		gdzie \texttt{separator} to maksymalnie 16-znakowy ciąg niemalże dowolnych znaków,
		poza nawiasami okrągłymi, backslashem i~znakami kontrolnymi.

		\pause
		\item
		Użycie separatora pozwala na~zawarcie nawiasów okrągłych wewnątrz \textit{raw string}.

		\pause
		\item
		\textit{Raw strings} można łączyć z UTF, np. \texttt{u8R"(tekst)"}.
	\end{itemize}
\end{frame}

\section{Listy inicjujące}

\begin{frame}[fragile]{Listy inicjujące}
	Weźmy taką klasę:
	\begin{block}{}
		\begin{lstlisting}
			struct student {
			    std::string nazwisko;
			    float srednia_ocen;
			};
		\end{lstlisting}
	\end{block}

	\pause
	Możemy inicjować obiekty tej klasy w~ten sposób:
	\begin{block}{}
		\begin{lstlisting}
			student a{"Kowalski", 5.0};
			student b = {"Nowak", 3.5};
		\end{lstlisting}
	\end{block}

	\pause
	Czyli w klamerkach i po przecinku podajemy wartości kolejnych pól obiektu.
\end{frame}

\begin{frame}[fragile]
	Listy inicjujące działają ,,rekurencyjnie'':
	\begin{block}{}
		\begin{lstlisting}
			std::pair <student, student> a {
			    {"Kowalski", 5.0},
			    {"Nowak", 3.5}
			};
			student b[] {
			    {"Kowalski", 5.0},
			    {"Nowak", 3.5}
			};
			std::vector <student> c {
			    {"Kowalski", 5.0},
			    {"Nowak", 3.5}
			};
		\end{lstlisting}
	\end{block}
\end{frame}

\begin{frame}[fragile]
	Listy inicjujące działają ,,rekurencyjnie'':
	\begin{block}{}
		\begin{lstlisting}
			struct student {
			    std::string nazwisko;
			    float srednia_ocen;
			};

			struct indeks {
			    int numer;
			    student s;
			    std::string uczelnia;
			};

			indeks i{123456, {"Kowalski", 5.0}, "MIMUW"};
		\end{lstlisting}
	\end{block}
\end{frame}

\begin{frame}[fragile]
	Korzystając z~powyższej klamerkowej składni, ujednolicono inicjowanie obiektów.
	Od~teraz możemy wywoływać konstruktory w~klamerkach, a~nie tylko w~nawiasach:

	\begin{block}{}
		\begin{lstlisting}
			int x{6};
			std::string s{"napis"};
			std::pair <double, char> p{1.0, 'w'};

			struct student {
			    std::string nazwisko;
			    float srednia_ocen;

			    student(std::string n, float so)
			        : nazwisko{n}, srednia_ocen{so} {}
			};
		\end{lstlisting}
	\end{block}
\end{frame}

\begin{frame}[fragile]
	Jeszcze jeden ciekawy przykład:
	\begin{block}{}
		\begin{lstlisting}
			struct student {
			    std::string nazwisko;
			    float srednia_ocen;
			};

			student f()
			{
			    return {"Kowalski", 5.0};
			}
		\end{lstlisting}
	\end{block}
\end{frame}

\begin{frame}[fragile]
	Możemy tworzyć \texttt{const} obiekty skomplikowanych typów, np. \texttt{std::map}:
	\begin{block}{}
		\begin{lstlisting}
			const std::map <std::string, float> tabela_studentow {
			    {"Kowalski", 5.0},
			    {"Nowak", 3.5}
			};
		\end{lstlisting}
	\end{block}

	\pause
	\vspace{0.5cm}
	Przydatne nie tylko w~wolnostojących zmiennych, ale także w~obiektach.
\end{frame}

\begin{frame}[fragile]
	Czym pod~maską są listy inicjujące?

	\pause
	\begin{block}{}
		\begin{lstlisting}
			template <typename T> std::initializer_list <T>
		\end{lstlisting}
	\end{block}

	\pause
	\begin{itemize}
		\item
		Możemy robić własne funkcje, które przyjmują w~argumencie \texttt{initializer\_list}.

		\pause
		\item
		Takie listy da się jedynie tworzyć w~kodzie, a~nie budować ,,w~locie'',
		np. dokładając po~jednym elemencie.

		\pause
		\item
		Da~się je ,,zapamiętać'' na~zmienną --- inaczej nie~dałoby się ich obsługiwać
		jako argumentów funkcji, ale~są oczywiście \textit{read-only}.

		\pause
		\item
		Mają metody \texttt{begin()} i~\texttt{end()}, zwracające iteratory (jak w~kontenerach
		z~STL), oraz \texttt{size()}.
	\end{itemize}
\end{frame}

\begin{frame}[fragile]
	Przykład z~życia: chcę mieć mapę działającą w~dwie strony (\texttt{BiMap}).

	\pause
	\begin{block}{}
		\begin{lstlisting}
			template <typename T, typename U> class BiMap {
			public:
			    BiMap(std::initializer_list <std::pair <T, U> >
			        initList);

			    U operator[](const T &leftKey) const;
			    T operator[](const U &rightKey) const;
			    void insert(const T &leftKey, const U &rightKey);

			private:
			    std::map <T, U> left;
			    std::map <U, T> right;
			};
		\end{lstlisting}
	\end{block}
\end{frame}

\begin{frame}[fragile]
	\begin{block}{}
		\begin{lstlisting}
			template <typename T, typename U>
			BiHash <T, U>::BiHash(
			    std::initializer_list <std::pair <T, U> >
			    initList)
			{
			    for (const std::pair <T, U> &p : initList)
			        insert(p.first, p.second);
			}

			template <typename T, typename U>
			void BiHash <T, U>::insert(const T &leftKey,
			    const U &rightKey)
			{
			    left.insert(leftKey, rightKey);
			    right.insert(rightKey, leftKey);
			}
		\end{lstlisting}
	\end{block}
\end{frame}

\begin{frame}[fragile]
	Mogę teraz bez problemu definiować stałe obiekty typu \texttt{BiMap}:
	\begin{block}{}
		\begin{lstlisting}
			const BiMap <float, std::vector <std::string> > oceny {
			    {5.0, {"Einstein", "Newton", "Feynman"}},
			    {3.0, {"Kowalski", "Nowak", "Malinowski"}}
			};
		\end{lstlisting}
	\end{block}
\end{frame}

\section{Nowa postać pętli \texttt{for}}

\begin{frame}[fragile]{Nowa postać pętli \texttt{for}}
	Jeśli chcemy dokonać iteracji po elementach jakiejś struktury (np. tablicy), to możemy od teraz
	pisać pętle w~taki sposób:
	\begin{block}{}
		\begin{lstlisting}
			int tab[5]{1, 2, 3, 4, 5};
			int sum = 0;
			for (int x : tab)
			    sum += x;

			vector <pair <int, int> > v{{1, 2}, {3, 4}};
			for (pair <int, int> p : v)
			    sum += p.first * p.second;
		\end{lstlisting}
	\end{block}

	\pause
	\begin{itemize}
		\item
		Iterator może być typu referencyjnego. Wtedy modyfikując go,
		zmieniamy zawartość struktury.

		\pause
		\item
		Oprócz tablic w~stylu \textsf{C}, możemy tego użyć na~dowolnej strukturze
		definiującej odpowiednio metody \texttt{begin()}, \texttt{end()} oraz~iteratory.

		\pause
		\item
		To znaczy, że~możemy użyć np. \texttt{initializer\_list}.
	\end{itemize}
\end{frame}

\begin{frame}[fragile]
	Z~życia wzięte: mamy (np. w konstruktorze) kilka widgetów Qt tego samego typu. Wszystkie
	te widgety inicjujemy w~ten sam sposób, poprzez wywołanie na~każdym kilku metod, ustawiające
	różne własności i~atrybuty.

	\pause
	\begin{block}{}
		\begin{lstlisting}
			spinBox_1 = new QSpinBox;
			spinBox_1->setAlignment(Qt::AlignRight);
			spinBox_1->setWidth(80);

			//analogicznie dla spinBox_2, spinBox_3 itd.
		\end{lstlisting}
	\end{block}

	\pause
	\begin{itemize}
		\item Kopypasta.

		\pause
		\item
		Jak będziemy chcieli np. zmienić typ zmiennych, bo robimy własnego widgeta
		dziedziczącego po \texttt{QSpinBox}, to~musimy poprawić $n$ miejsc.

		\pause
		\item
		Tak samo jeśli sposób inicjowania będzie trzeba zmienić.
	\end{itemize}
\end{frame}

\begin{frame}[fragile]
	Lepiej:

	\begin{block}{}
		\begin{lstlisting}
			for (QSpinBox **spinBox : {&spinBox_1, ... }) {
			    *spinBox = new QSpinBox;
			    (*spinBox)->setAlignment(Qt::AlignRight);
			    (*spinBox)->setWidth(80);
			}
		\end{lstlisting}
	\end{block}
\end{frame}

\section{Typ tablicowy \texttt{array}}

\begin{frame}[fragile]{Typ tablicowy \texttt{array}}

	\begin{itemize}
		\item
		Nowy standard wprowadza bardziej wysokopoziomowy typ tablicowy \texttt{std::array}.

		\pause
		\item
		Jest to typ szablonowy:
		\begin{block}{}
			\begin{lstlisting}
				template <typename T, std::size_t N>
				std::array <T, N>
			\end{lstlisting}
		\end{block}{}

		\pause
		\item
		\texttt{T} oznacza typ przechowywany w~tablicy, \texttt{N} jej rozmiar.

		\pause
		\item
		\textbf{Tablica jest stałego rozmiaru.} Ale przynajmniej ma np.
		\texttt{begin()}, \texttt{end()} i~\texttt{size()}.

		\pause
		\item
		Oprócz standardowego operatora tablicowego ma też metodę \texttt{at()}, która
		robi \textit{bounds-checking}.
	\end{itemize}
\end{frame}

\section{Silne typy wyliczeniowe}

\begin{frame}[fragile]{Silne typy wyliczeniowe}
	\begin{itemize}
		\item
		W~starszym \textsf{C++} typ wyliczeniowy (\texttt{enum}) był w~zasadzie nazwanym zbiorem stałych,
		o~niewielkiej nadbudowie typologicznej.

		\begin{block}{}
			\begin{lstlisting}
				enum Fruit {
				    Apple,
				    Orange
				};

				Fruit f = Apple;
			\end{lstlisting}
		\end{block}

		\pause
		\item
		Niewiele było wiadomo o~,,fizycznym'' typie danych użytym do~implementacji typu wyliczeniowego.
		Był \textit{implementation defined}, w~praktyce zwykle znaczyło to \texttt{int}.
	\end{itemize}
\end{frame}

\begin{frame}[fragile]
	\begin{itemize}
		\item
		Nazwa typu wyliczeniowego nie była zasięgiem (\textit{scope}), co~powodowało konflikty
		nazw, gdy w~tym samym \textit{scope} chcieliśmy zdefiniować więcej niż jeden typ wyliczeniowy,
		zawierający wewnątrz identycznie nazwaną stałą.
		\begin{block}{}
			\begin{lstlisting}
				enum Fruit {Apple, Orange};
				enum Cake {Cheese, Apple};
			\end{lstlisting}
		\end{block}

		\pause
		\item
		Żeby dodać \textit{scoping} robiło się różne hacki:
		\begin{block}{}
			\begin{lstlisting}
				struct Fruit {
				    enum FruitEnum {
				        Apple,
				        Orange
				    };
				};

				Fruit::FruitEnum f = Fruit::Apple;
			\end{lstlisting}
		\end{block}
	\end{itemize}
\end{frame}

\begin{frame}
	W \textsf{C++11} pojawiły się dwa ulepszenia typów wyliczeniowych:
	\begin{enumerate}
		\pause
		\item
		Można specyfikować działający pod spodem typ całkowitoliczbowy.

		\pause
		\item
		Można dodać przedrostek \texttt{class} (albo \texttt{struct}, bez różnicy) przed
		nazwą typu wyliczeniowego. Powoduje to jego wzmocnienie.
	\end{enumerate}
\end{frame}

\begin{frame}[fragile]
	Typ wewnętrzny specyfikujemy w~taki sposób:
	\begin{block}{}
		\begin{lstlisting}
			enum Fruit : int {
			    Apple,
			    Orange
			};

			enum Cake : quint8 {
			    Cheese,
			    Apple
			};
		\end{lstlisting}
	\end{block}

	\pause
	\begin{itemize}
		\item
		W~tym przykładzie nadal mamy błąd kompilacji, bo powtarza się identyfikator
		\texttt{Apple} w~tym samym zasięgu widoczności.

		\item
		Jeśli nie wyspecyfikujemy typu wewnętrznego, domyślnie jest to \texttt{int}.
	\end{itemize}
\end{frame}

\begin{frame}[fragile]
	Wzmacniamy typy wyliczeniowe:
	\begin{block}{}
		\begin{lstlisting}
			enum class Fruit : int {
			    Apple,
			    Orange
			};

			enum class Cake : quint8 {
			    Cheese,
			    Apple
			};

			Fruit f = Fruit::Apple;
			Cake c = Cake::Apple;
		\end{lstlisting}
	\end{block}

	\pause
	\begin{itemize}
		\item
		Przedrostek z~nazwą typu wyliczeniowego jest obligatoryjny przy odwoływaniu się
		do~samych wartości.

		\pause
		\item
		\textbf{Moim zdaniem jeden z ważniejszych dodatków do języka.} Przestałem korzystać
		ze ,,słabych'' typów wyliczeniowych.
	\end{itemize}
\end{frame}

\section{Wyrażenia stałe (\texttt{constexpr})}

\begin{frame}[fragile]{Wyrażenia stałe (\texttt{constexpr})}

	\begin{itemize}
		\item
		Wyrażenia stałe to takie, które zawsze generują ten sam wynik i~można ten wynik
		otrzymać już na~etapie kompilacji.

		\pause
		\item
		Niestety w~sensie poprzedniego standardu znaczy to tyle, że wyrażenia są stałe
		tylko wtedy, gdy są całkowitoliczbowe i~nie~odpalają po~drodze żadnej funkcji.
		Nawet, jeśli ta funkcja zawsze zwraca tę samą wartość.

		\pause
		\begin{block}{}
			\begin{lstlisting}
				int f() {return 3;}
				int a[3];       //OK
				int b[3 + 3];   //OK
				int c[3 + f()]; //compile error
			\end{lstlisting}
		\end{block}

		\pause
		\item
		Jeśli prefiksujemy funkcję \texttt{f()} słowem \texttt{constexpr}, to zacznie być OK.
	\end{itemize}
\end{frame}

\begin{frame}[fragile]
	Ograniczenia i~możliwości:
	\begin{itemize}
		\item
		Funkcje \texttt{constexpr} muszą w~wyniku zawierać coś innego niż \texttt{void}.

		\pause
		\item
		W~ciele funkcji nie można deklarować zmiennych i~definiować nowych typów.

		\pause
		\item
		W~zasadzie najlepiej, jakby zawierała po prostu jedno \texttt{return} z~obliczeniem
		wyniku na~podstawie ewentualnych argumentów.

		\pause
		\begin{block}{}
			\begin{lstlisting}
				constexpr int g(int a, int b) {return a * b;}
			\end{lstlisting}
		\end{block}

		\pause
		\item
		Jeśli wywołamy funkcję \texttt{constexpr} z~argumentami nieznanymi w~czasie kompilacji,
		to wszystko zadziała OK, ale funkcja już nie jest \texttt{constexpr}. Tzn. argumenty
		funkcji muszą być \texttt{constexpr}, bo~inaczej tracimy tę własność.

		\pause
		\item
		Możemy też deklarować konstruktory własnych typów jako \texttt{constexpr}. Możemy
		ich wtedy używać w~wyrażeniach tego typu bez~straty stałości.
	\end{itemize}
\end{frame}

\begin{frame}[fragile]
	Ciekawy skutek ,,uboczny'': dawniej dało się definiować stałe statyczne w~klasach już w~definicji klasy,
	ale tylko pod~warunkiem, że były to~stałe typów całkowitoliczbowych.

	\begin{block}{}
		\begin{lstlisting}
		class A {
		    static const int I = 5;
		    static const double D = 5.0; //compile error
		};
		const double A::D = 5.0; //OK
		\end{lstlisting}
	\end{block}

	\pause
	\begin{block}{}
		\begin{lstlisting}
		class A {
		    static const int I = 5;
		    static constexpr double D = 5.0; //OK
		};
		\end{lstlisting}
	\end{block}
\end{frame}

\section{User-defined literals}

\begin{frame}{\textit{User-defined literals}}
	W~\textsf{C++} istnieje kilka predefiniowanych literałów, zarówno przedrostkowych jak i~przyrostkowych:
	\begin{itemize}
		\item
		Przedrostkowe: \texttt{0x} na~liczby szesnastkowe, \texttt{0} na~liczby ósemkowe,
		\texttt{u8} na~napisy UTF-8\ldots

		\item
		Przyrostkowe: \texttt{f} jako \texttt{float}, \texttt{L} jako \texttt{long},
		\texttt{LL} jako \texttt{long long}, \texttt{i} jako część urojona w~liczbach zespolonych\ldots
	\end{itemize}
\end{frame}

\begin{frame}[fragile]
	W~nowym standardzie można definiować własne literały przyrostkowe za~pomocą specjalnego operatora.
	\pause
	\begin{block}{}
		\begin{lstlisting}
			typedef qint32 LengthUnit;
			static const int LengthUnitPerMm = 10;

			inline constexpr LengthUnit
			    operator"" _mm(long double mm) {
			        return mm * LengthUnitPerMm;
			}

			inline constexpr LengthUnit
			    operator"" _cm(long double cm) {
			        return cm * 10_mm;
			}

			inline constexpr LengthUnit
			    operator"" _in(long double in) {
			        return in * 2.54_cm;
			}
		\end{lstlisting}
	\end{block}
\end{frame}

\begin{frame}[fragile]
	Składnia:
	\begin{block}{}
		\begin{lstlisting}
			wynik operator"" _sufiks(argument);
		\end{lstlisting}
	\end{block}

	\pause
	\begin{itemize}
		\item
		Sufiks powinien zaczynać się od~podkreślnika. Literały bez podkreślnika są
		zarezerwowane na~potrzeby przyszłych wersji języka.

		\pause
		\item
		Dopuszczalne typy argumentu to: \texttt{unsigned long long},
		\texttt{long double}, \texttt{char}, \texttt{const char *} (standardowy napis
		null-terminated). Ewentualnie dwa argumenty, kolejno \texttt{const char *},
		\texttt{size\_t} -- napis i~długość.
	\end{itemize}

	\pause
	Użycie:
	\begin{block}{}
		\begin{lstlisting}
			const LengthUnit Metr = 100_cm;
		\end{lstlisting}
	\end{block}
\end{frame}

\end{document}
