lecture05.tex

\documentclass[unknownkeysallowed,xcolor=table]{beamer}
 
\usepackage[T2A,T1]{fontenc}
\usepackage[utf8]{inputenc}
\usepackage[english,russian]{babel}
\usepackage{listings}
\usepackage{amsmath}
\usepackage{url}
\usepackage{textcomp}
\usepackage{multirow}
\usepackage{tikz}

\setbeamertemplate{navigation symbols}{}

\newcommand{\textapprox}{\raisebox{0.5ex}{\texttildelow}}

\newcommand{\rarr}{$\rightarrow$}
 
\colorlet{mygreen}{green!60!blue}
\colorlet{mymauve}{red!60!blue}
\definecolor{light-gray}{gray}{0.9}

\lstset{
      basicstyle=\ttfamily\small,
      commentstyle=\color{mygreen},
      keywordstyle=\color{blue},
      numberstyle=\tiny\color{blue},
      stringstyle=\color{mymauve},
      numbers=left,
      stepnumber=1,
      columns=fullflexible,
      breaklines=true,
      postbreak=\mbox{\textcolor{red}{\ensuremath{\hookrightarrow}\space}},
      literate={~} {\textapprox}{1},
      language={[11]C++}
}

\lstnewenvironment{cmdline}
  {\lstset{
      basicstyle=\ttfamily\scriptsize,
      keywordstyle=\color{blue},
      backgroundcolor=\color{light-gray},
      language={bash}
  }}
  {}

\lstnewenvironment{cmdlinelarge}
  {\lstset{
      basicstyle=\ttfamily\small,
      keywordstyle=\color{blue},
      backgroundcolor=\color{light-gray},
      language={bash}
  }}
  {}

\makeatletter
\newcommand{\srcmediumsize}{\@setfontsize{\srcmediumsize}{7pt}{7pt}}
\makeatother

\makeatletter
\newcommand{\srcbigsize}{\@setfontsize{\srcbigsize}{8pt}{8pt}}
\makeatother

\makeatletter
\newcommand{\srcsize}{\@setfontsize{\srcsize}{6pt}{6pt}}
\makeatother

\makeatletter
\newcommand{\srcsmallsize}{\@setfontsize{\srcsmallsize}{5pt}{5pt}}
\makeatother

\makeatletter
\newenvironment<>{btHighlight}[1][]
{\begin{onlyenv}#2\begingroup\tikzset{bt@Highlight@par/.style={#1}}\begin{lrbox}{\@tempboxa}}
{\end{lrbox}\bt@HL@box[bt@Highlight@par]{\@tempboxa}\endgroup\end{onlyenv}}

\newcommand<>\btHL[1][]{%
  \only#2{\begin{btHighlight}[#1]\bgroup\aftergroup\bt@HL@endenv}%
}
\def\bt@HL@endenv{%
  \end{btHighlight}%
  \egroup
}
\newcommand{\bt@HL@box}[2][]{%
  \tikz[#1]{%
    \pgfpathrectangle{\pgfpoint{1pt}{0pt}}{\pgfpoint{\wd #2}{\ht #2}}%
    \pgfusepath{use as bounding box}%
    \node[anchor=base west, fill=orange!30,outer sep=0pt,inner xsep=1pt, inner ysep=0pt, rounded corners=3pt, minimum height=\ht\strutbox+1pt,#1]{\raisebox{1pt}{\strut}\strut\usebox{#2}};
  }%
}
\makeatother

\title[C++]
{Программирование на языке C++}
 
\subtitle{Вводный курс}
 
\author[А.~Б.~Морозов]
{
  \texorpdfstring{Александр Морозов\newline\href{mailto:gelu.speculum@gmail.com}{gelu.speculum@gmail.com}}
  {Александр Морозов}
}
  
\date[ITMO 2021]
{ИТМО, весенний семестр 2021}
 
\logo{%
  \makebox[0.97\paperwidth]{%
    \includegraphics[align=c,width=2cm,keepaspectratio]{itmo_logo.png}
    \hfill
    \includegraphics[align=c,width=1.5cm,keepaspectratio]{itiviti_logo.png}
  }
}

\AtBeginSection[]
{
  \begin{frame}
    \frametitle{Содержание}
    \tableofcontents[currentsection]
  \end{frame}
}

\begin{document}
 
\frame{\titlepage}

%-------------------------------------------------
\section{Структуры и классы}

\begin{frame}{Структуры и классы}
  \begin{itemize}
    \item задаёт новый тип в программе \vspace{1em}
    \item может иметь члены:
      \begin{itemize}
        \item поля данных \vspace{0.5em}
        \item методы (функции \vspace{0.5em})
        \item типы \vspace{0.5em}
        \item псевдонимы типов \vspace{0.5em}
        \item члены вложенных нестрогих \lstinline{enum} \vspace{0.5em}
        \item шаблоны \vspace{1em}
      \end{itemize}
    \item можно наследовать от других классов
  \end{itemize}
\end{frame}

\begin{frame}[fragile]{Определение}
  \begin{itemize}
    \item \emph{класс имя} \lstinline|{| \emph{члены} \lstinline|}|
    \item \emph{класс имя} \lstinline{:} \emph{список наследования} \lstinline|{| \emph{члены} \lstinline|}|
  \end{itemize}

  \vspace{1em}

  где
  \begin{itemize}
    \item \emph{класс} -- это ключевое слово \lstinline{class} или \lstinline{struct} \vspace{0.5em}
    \item \emph{имя} -- идентификатор \vspace{0.5em}
    \item \emph{члены} -- объявление членов класса \vspace{0.5em}
    \item \emph{список наследования} -- \emph{base1, ..., baseN}
  \end{itemize}

  \vspace{1em}

  Тип класса полностью определён \emph{после} закрывающей скобки.
\end{frame}

\begin{frame}[fragile]{Примеры определений классов}
  \begin{lstlisting}[basicstyle=\ttfamily\srcbigsize]
    struct A {};

    struct B {
      A a;
      int b;
      char c;
    } b1, b2;

    class C {
      const std::size_t n = 0;
    public:
      std::size_t value() const
      { return n; }
      using X = B;
    };

    int main() {
      A a;
      C c = C();
      std::cout << sizeof(a) << ":" << sizeof(b1) << ":" << sizeof(c) << std::endl;
      std::cout << C().value() << std::endl;
      C::X x;
      std::cout << x.b << std::endl;
    }
  \end{lstlisting}
\end{frame}

\begin{frame}[fragile]{Область видимости класса}
  \begin{lstlisting}[
      moredelim={**[is][\btHL<1>]{@1}{@}},
      moredelim={**[is][\btHL<2>]{@2}{@}},
      moredelim={**[is][\btHL<3>]{@3}{@}},
      moredelim={**[is][\btHL<4>]{@4}{@}},
      moredelim={**[is][\btHL<5>]{@5}{@}}
    ]
    struct S {
      struct T {
        int z = @510 * n@;
        int baz();
      };
      int foo(int x) noexcept(@4n > 100@)
      { @2return x * n;@ }
      void bar(int y @3= n@);
      int z = @53 * n@;
      static const int n = 101;
      @1char str[n];@
    };
    int S::T::baz()
    { @2return z * 3;@ }
    void S::bar(int y)
    { @2z *= y;@ }
  \end{lstlisting}
\end{frame}

\begin{frame}[fragile]{И ещё немного об области видимости класса}
  \begin{lstlisting}
    struct S {
      struct T {
        int z = 10 * n;
        int baz();
      };

      T create() const;
      T another();
    };

    //T S::create() const
    auto S::create() const
        -> T
    { return {}; }

    S::T S::another()
    { return {}; }
  \end{lstlisting}
\end{frame}

\begin{frame}[fragile]{Вторжение в область видимости класса}
  \begin{lstlisting}
    int x = 0;

    struct S
    {
      char data[x]; // error

      constexpr std::size_t size() const
      {
        return x; // OK
      }

      static constexpr std::size_t x = 55;
    };
  \end{lstlisting}
\end{frame}

\begin{frame}[fragile]{Использование имён членов вне области видимости класса}
  \begin{itemize}
    \item область видимости наследников \vspace{0.5em}
    \item оператор \lstinline{.} : \lstinline{expr.name} \\
      где \emph{expr} имеет тип:
      \begin{itemize}
        \item класса
        \item потомка
      \end{itemize}
      \vspace{0.5em}
    \item оператор \lstinline{->} : \lstinline{expr->name} \\
      где \emph{expr} имеет тип:
      \begin{itemize}
        \item указатель на класс
        \item указатель на потомок
      \end{itemize}
      \vspace{0.5em}
    \item оператор \lstinline{::} : \lstinline{Class::member} \\
      где \emph{Class}:
      \begin{itemize}
        \item имя класса
        \item имя потомка
      \end{itemize}
  \end{itemize}
\end{frame}

\begin{frame}[fragile]{Поля и методы}
  \begin{itemize}
    \item статические \vspace{0.5em}
    \item нестатические \vspace{0.5em}
  \end{itemize}
  \begin{lstlisting}[basicstyle=\ttfamily\srcbigsize]
    struct S
    {
      static int a;
      int b;

      static int get_a();
      int get_b();
    };

    int main()
    {
      std::cout << S::a;
      std::cout << S::get_a();
      S s;
      std::cout << s.b;
      std::cout << s.get_b();
      std::cout << s.a;
      std::cout << s.get_a();
    }
  \end{lstlisting}
\end{frame}

\begin{frame}[fragile]{Статические поля и методы}
  \begin{lstlisting}[basicstyle=\ttfamily\srcbigsize]
    struct S
    {
      static int a;
      static const int b, c = 5;
      static constexpr int d = 1; // inline
      static S s; // incomplete type
      static thread_local S ss;
      static const auto e = sizeof(int); // declaration only
      static const auto f = 111;

      static S & instance(); // declaration
    };
    int S::a;
    const int S::b = -1, S::c;
    S S::s;
    thread_local S S::ss;
    const int S::f;

    // definition
    S & S::instance()
    { return ss; }

    char xx[S::e];
    // const void * pp = &S::e;
    const void * pp = &S::f;
  \end{lstlisting}
\end{frame}

\begin{frame}{Нестатические поля и методы}
  Поля:
  \begin{itemize}
    \item являются подобъектами объекта класса
    \item тип должен быть полностью определён в точке объявления
    \item не могут быть \lstinline{auto}, \lstinline{extern}, \lstinline{thread_local}
    \item размер $\geq 1$
    \item неотделимы от объекта класса
    \item инициализация -- в объявлении или в конструкторе \vspace{0.5em}
  \end{itemize}
  Методы:
  \begin{itemize}
    \item при вызове имеют доступ к полям конкретного объекта класса
    \item объект класса доступен через \lstinline{this}
    \item могут иметь квалификаторы вызова
    \item специальные методы -- конструкторы, деструкторы, операторы присваивания
  \end{itemize}
\end{frame}

\begin{frame}[fragile]{Примеры нестатических полей и методов}
  \begin{lstlisting}[basicstyle=\ttfamily\srcmediumsize]
    struct S
    {
      const int a = 10;
      int b = 5;
      char str[6] = "Hello";

      void plus_one()
      { ++b; }
      void alt_plus_one()
      { ++this->b; }
      constexpr std::size_t length() const
      { return sizeof(str) / sizeof(char); }
    };

    int main()
    {
      S s1, s2;
      std::cout << "1: " << s1.a << ", " << s1.b << ", " << s1.str << std::endl;
      std::cout << "2: " << s2.a << ", " << s2.b << ", " << s2.str << std::endl;
      s1.plus_one();
      s1.plus_one();
      --s2.b;
      s2.str[1] = 'X';
      std::cout << "1: " << s1.a << ", " << s1.b << ", " << s1.str << std::endl;
      std::cout << "2: " << s2.a << ", " << s2.b << ", " << s2.str << std::endl;
      constexpr S s3;
      std::cout << s3.length() << std::endl;
      // s1.a++;
      // s3.plus_one();
    }
  \end{lstlisting}
\end{frame}

\begin{frame}[fragile]{Операторы классов}
  \begin{lstlisting}
    class C
    {
    public:
      C & operator++ ()
      {
        // some custom increment logic
      }
      C & operator &= (const C & rhs)
      {
        return *this;
      }
    };

    C c, cc;
    ++c;
    c &= ++cc;
  \end{lstlisting}
\end{frame}

\begin{frame}[fragile]{Отображение синтаксиса операторов}
  Определение операторов, как членов класса -- это частный случай перегрузки операторов.

  \begin{center}
    \begin{tabular}{ l l }
      \hline
      Синтаксис оператора & Синтаксис перегруженной функции \\
      \hline
      &\\
      @a & (a).operator@ () \\
      a@ & (a).operator@ (0) \\
      a@b & (a).operator@ (b) \\
      a(b...) & (a).operator() (b...) \\
      a[b] & (a).operator[] (b) \\
      a-> & (a).operator-> () \\
    \end{tabular}
  \end{center}
\end{frame}

\begin{frame}[fragile]{Вложенные классы}
  \begin{lstlisting}
    struct S {
      class C {
        int f();
      };
      class CC;
    };
    int S::C::f() {}

    S::C c;
    int n = c.f();

    class S::CC {};
  \end{lstlisting}
  \begin{itemize}
    \item область видимости включает имена окружающего класса
    \item как член класса имеет полные права доступа к другим его членам
  \end{itemize}
\end{frame}

\begin{frame}[fragile]{Наследование}
  \begin{lstlisting}
    struct A {};
    struct B
    {
      int a, b;
    };
    struct C : A, B
    {
      double a, c;
    };

    C c;
    int x = c.b;
    double y = c.c;
    auto z = c.a;

    static_assert(sizeof(C) >= sizeof(A) + sizeof(B));
  \end{lstlisting}
\end{frame}

\begin{frame}[fragile]{Права доступа к членам класса}
  \begin{itemize}
    \item \lstinline{public} -- публичный доступ, нет ограничений \vspace{1em}
    \item \lstinline{private} -- закрытый доступ, только другие члены этого класса (или его друзья) имеют доступ к этому имени \vspace{1em}
    \item \lstinline{protected} -- защищенный доступ, подобно закрытому, но права доступа есть также у наследников класса
  \end{itemize}
\end{frame}

\begin{frame}[fragile]{Права доступа к членам класса}
  \begin{lstlisting}
    class C
    {
    private:
      int f(int)
      { return 10; }

    public:
      int f(double)
      { return -10; }
    };

    int main()
    {
      C c;
      return c.f(1); // error
    }
  \end{lstlisting}
\end{frame}

\begin{frame}[fragile]{Назначение прав доступа}
  \begin{itemize}
    \item явно в теле класса -- действует на все последующие члены до следующего явного указания спецификатора доступа \vspace{1em}
    \item при наследовании -- действует на все члены родительского класса
  \end{itemize}
  \begin{lstlisting}
    class C
    {
      public: // inside of class definition
    };

    class CC : protected C // in inheritance list
    {
    };
  \end{lstlisting}
\end{frame}

\begin{frame}[fragile]{Пример назначения прав доступа}
  \begin{lstlisting}[basicstyle=\ttfamily\srcmediumsize]
    #include <iostream>

    class A
    {
    public:
      std::size_t size() const
      { return sizeof(n); }
    protected:
      int next()
      { return ++n; }
    private:
      int n = 0;
    };

    class B : public A
    {
    public:
      void next()
      { A::next(); }
    };

    int main()
    {
      A a;
      B b;
      std::cout << a.size() << std::endl;
      // std::cout << a.next() << std::endl;
      // std::cout << a.n << std::endl;
      b.next();
      std::cout << b.size() << std::endl;
    }
  \end{lstlisting}
\end{frame}

\begin{frame}{Права доступа и наследование}
  \begin{itemize}
    \item \lstinline{public} -- спецификаторы доступа родительского класса наследуются без изменений \vspace{1em}
    \item \lstinline{protected} -- \lstinline{public} и \lstinline{protected} члены родительского класса считаются \lstinline{protected} у наследника, \lstinline{private} не меняется \vspace{1em}
    \item \lstinline{private} -- \lstinline{public} и \lstinline{protected} члены родительского класса наследуются, как \lstinline{private}
  \end{itemize}
\end{frame}

\begin{frame}[fragile]{Права доступа и вложенные классы}
  \begin{lstlisting}[basicstyle=\ttfamily\srcbigsize]
    class Outer
    {
    public:
      class Inner
      {
      public:
        static int get_a()
        { return a; }
        int get_b(const Outer & outer) const
        { return outer.b; }
      private:
        int c = 22;
      };

      Inner get_inner() const
      {
        Inner i;
        // b = i.c;
        return i;
      }
    private:
      static const int a = 10;
      int b = -5;
    };
  \end{lstlisting}
\end{frame}

\begin{frame}[fragile]{Различие между структурами и классами}
  \begin{itemize}
    \item \lstinline{struct} -- по умолчанию, \lstinline{public} права доступа к членам, \lstinline{public} наследование \vspace{0.5em}
    \item \lstinline{class} -- по умолчанию, \lstinline{private} права доступа к членам, \lstinline{private} наследование
  \end{itemize}

  \vspace{1em}

  \begin{lstlisting}
  struct S : A // public inheritance implied
  {
    int x; // public access implied
  };

  class C : B // private inheritance implied
  {
    int y; // private access implied
  };
  \end{lstlisting}
\end{frame}

\begin{frame}[fragile]{Агрегатная инициализация}
  \begin{lstlisting}
  T obj = { a, b, c, ... };
  T obj{a, b, c, ... };
  {a, b, c, ...}; // temporary, type must be implied by context
  \end{lstlisting}

  \vspace{0.5em}

  Агрегатная инициализация возможно для агрегатов:
  \begin{itemize}
    \item Массив \vspace{0.5em}
    \item Класс с только публичными нестатическими полями, без конструкторов, без виртуальных методов, все базовые классы должны удовлетворять тем же требованиям
  \end{itemize}

  \vspace{1em}

  Эффект агрегатной инициализации -- каждый подобъект объекта-агрегата инициализируется копией значения из списка инициализации.
\end{frame}

\begin{frame}[fragile]{Пример использования агрегатной инициализации}
  \begin{lstlisting}
  struct A {
    int a_a;
    int a_b;
  };

  struct B : A {
    char b_a;
    char b_b;
  };

  struct C : A, B {
    std::string c_a;
  };

  C c { 20, 30, -20, -30, '\0', 'X', "Hello" };
  \end{lstlisting}
\end{frame}

%-------------------------------------------------
\section{Enum}

\begin{frame}[fragile]{\lstinline{enum}}
  \begin{lstlisting}
  enum Side {
    Buy,
    Sell
  };

  char encode_side(const Side side) {
    switch (side) {
      case Buy: return '1';
      case Sell: return '2';
    }
  }
  \end{lstlisting}
\end{frame}

\begin{frame}[fragile]{Классические открытые (unscoped) enum}
  \begin{itemize}
    \item \lstinline{enum} [\emph{имя}] \lstinline|{| \emph{enumerator} [\lstinline{=} \emph{const expr}]\lstinline{,} ... \lstinline|}|
    \item \lstinline{enum} \emph{имя} \lstinline{:} \emph{тип} \lstinline|{| \emph{enumerator} [\lstinline{=} \emph{const expr}]\lstinline{,} ... \lstinline|}|
    \item \lstinline{enum} \emph{имя} \lstinline{:} \emph{тип}\lstinline{;}
  \end{itemize}

  \vspace{0.5em}

  \begin{itemize}
    \item \emph{имя} -- новый тип \vspace{0.5em}
    \item \emph{тип} -- базовый тип, по умолчанию -- не шире \lstinline{int} \vspace{0.5em}
    \item \emph{enumerator} -- константа в той же области видимости \vspace{0.5em}
    \item \emph{const expr} -- значение, которым инициализируется константа \vspace{0.5em}
    \item неявное приведение $\mathbf{type}(enumerator) \to \mathbb{I}$
  \end{itemize}
\end{frame}

\begin{frame}[fragile]{Строгие (scoped) \lstinline{enum}}
  \begin{itemize}
    \item \lstinline{enum} \lstinline{class} | \lstinline{struct} \emph{имя} \lstinline|{| \emph{enumerator} [\lstinline{=} \emph{constexpr}]\lstinline{,} ... \lstinline|}|
    \item \lstinline{enum} \lstinline{class} | \lstinline{struct} \emph{имя} \lstinline{:} \emph{тип} \lstinline|{| \emph{enumerator} [\lstinline{=} \emph{constexpr}]\lstinline{,} ... \lstinline|}|
    \item \lstinline{enum} \lstinline{class} | \lstinline{struct} \emph{имя} \lstinline{;}
    \item \lstinline{enum} \lstinline{class} | \lstinline{struct} \emph{имя} \lstinline{:} \emph{тип}\lstinline{;}
  \end{itemize}

  \vspace{0.5em}

  \begin{itemize}
    \item \emph{имя} -- новый тип \vspace{0.5em}
    \item \emph{тип} -- базовый тип, по умолчанию -- \lstinline{int} \vspace{0.5em}
    \item \emph{enumerator} -- константа в области видимости \lstinline{enum} \vspace{0.5em}
    \item \emph{const expr} -- значение, которым инициализируется константа
  \end{itemize}
\end{frame}

\begin{frame}[fragile]{\lstinline{enum} и приведения типов}
  \begin{itemize}
    \item неявное приведение открытых \lstinline{enum} к интегральным типам \vspace{0.5em}
    \item явное приведение интегральных, floating типов и других \lstinline{enum} к любому \lstinline{enum} \vspace{0.5em}
    \item если базовый тип не задан, а преобразуемое значение не представимо в выбранном по умолчанию -- \textbf{UB} \vspace{0.5em}
  \end{itemize}
  \begin{lstlisting}
    enum E1 { A = 5, B, C };
    enum class E2 { A, B };

    E1 e1 = static_cast<E1>(1000);
    E2 e2 = static_cast<E2>(B);

    int main()
    {
      // return E2::B;
      return B;
    }
  \end{lstlisting}
\end{frame}

\begin{frame}[fragile]{Преимущества строгих enum над классическими}
  Имена элементов строгого \lstinline{enum} не засоряют область видимости -- важно для \lstinline{enum}, объявляемых в пространстве имен.

  \vspace{2em}

  Невозможно случайно получить неявное преобразование к совершенно другому типу.

  \vspace{1em}

  \begin{lstlisting}
  enum Side { Buy, Sell };
  enum TimeInForce { Day, GTD, IOC };

  void foo(const Side side, const TimeInForce tif) {
    if (side == Day) { // obviously, an error, but compiles happily
      ...
    }
  }
  \end{lstlisting}
\end{frame}

%-------------------------------------------------
\section{Полные и неполные типы}

\begin{frame}[fragile]{Полные и неполные типы}
  Полный тип -- определение известно.

  \vspace{1em}

  Неполный тип:
  \begin{itemize}
    \item предварительное объявление класса \vspace{0.5em}
    \item определение класса до закрывающей скобки \vspace{0.5em}
    \item \lstinline{enum} до момента определения его типа реализации \vspace{0.5em}
    \item \lstinline{void} \vspace{0.5em}
    \item ...
  \end{itemize}
\end{frame}

\begin{frame}[fragile]{Необходимость полного типа}
  Требуется знать полный тип \lstinline{T} к моменту:

  \vspace{1em}
  \begin{itemize}
    \item вызов функции, возвращающей \lstinline{T} \vspace{0.5em}
    \item объявление переменной типа \lstinline{T} \vspace{0.5em}
    \item объявление нестатического поля типа \lstinline{T} \vspace{0.5em}
    \item явное или неявное преобразование к \lstinline{T} \vspace{0.5em}
    \item обращение к членам класса типа \lstinline{T} \vspace{0.5em}
    \item использование \lstinline{T} как родителя объявляемого класса \vspace{0.5em}
    \item ...
  \end{itemize}
\end{frame}

\begin{frame}[fragile]{Примеры неполных типов}
  \begin{lstlisting}[basicstyle=\ttfamily\srcbigsize]
    class C;

    void f(const C *); // OK
    C g(); // OK

    auto c = g(); // error
    auto x = C::get(); // error
    C cc; // error

    struct S
    {
      C & c; // OK;
      C cc; // error
    };

    enum E {
      A,
      B = sizeof(E), // error
      C
    };

    enum class EE {
      A,
      B = sizeof(EE), // OK
      C
    };
  \end{lstlisting}
\end{frame}

\begin{frame}[fragile]{Opaque enum declaration}
  \begin{lstlisting}
    enum A : int;

    enum class B;

    enum class C : unsigned;

    A get_a(unsigned long x)
    {
      return static_cast<A>(x); // potential UB
    }

    B a_to_b(const A a)
    {
      return static_cast<B>(a); // OK
    }
  \end{lstlisting}
\end{frame}

%-------------------------------------------------
\section{Некоторые классы стандартной библиотеки}

\begin{frame}[fragile]{\lstinline{std::string}}
  \url{https://en.cppreference.com/w/cpp/string/basic_string}
  \begin{lstlisting}
    #include <string>

    std::string s1, s2 = "Hello", s3 = s2;

    void foo(const std::string & str) {
      if (!str.empty()) {
        const char * s = str.c_str();
      }
      if (str.size() >= 5) {
        char c = str[4];
      }
      if (std::size_t i = str.find("ll"); i != str.npos) {
        const auto ss = str.substr(i, 3);
      }
    }
  \end{lstlisting}
\end{frame}

\begin{frame}[fragile]{\lstinline{std::array}}
  \url{https://en.cppreference.com/w/cpp/container/array}
  \begin{lstlisting}
    #include <array>

    std::array<int, 5> x = {1, 2, 3, 4, 5};
    std::array<int, 10> y = x; // compilation error

    static_assert(!x.empty());
    static_assert(x.size() == 5);

    x[2] = 22;
  \end{lstlisting}
\end{frame}

\begin{frame}[fragile]{\lstinline{std::vector}}
  \url{https://en.cppreference.com/w/cpp/container/vector}
  \begin{lstlisting}
    #include <vector>

    std::vector<unsigned> x(10, 0xAE), y(100, 0x11);
    y = x;
    
    std::vector<int> z(5, -1);
    z = x; // compilation error

    x.push_back(1111);
  \end{lstlisting}
\end{frame}

\begin{frame}[fragile]{Некоторые варианты использования \lstinline{std::vector}}
  \begin{lstlisting}
  std::vector<std::string> strings;
  strings.reserve(100);
  for (std::string line; std::getline(std::cin, line); ) {
    strings.push_back(line);
  }

  std::cout << "Read " << strings.size() << " input lines" << std::endl;

  strings.clear();
  assert(strings.size() == 0);
  assert(strings.size() != strings.capacity());

  strings.shrink_to_fit();
  assert(strings.size() == strings.capacity()); // maybe
  \end{lstlisting}
\end{frame}

\begin{frame}[fragile]{\lstinline{std::pair}}
  \url{https://en.cppreference.com/w/cpp/utility/pair}
  \begin{lstlisting}
  #include <utility>

  std::pair<int, std::string> x(-10, "Cat");
  std::cout << x.first << " : " << x.second << std::endl;

  const auto y = std::make_pair(99, "Dog");

  const auto z = std::make_pair<unsigned, std::string>(99, "Explicit dog");

  std::pair<A, B> foo() {
    A a;
    B b;
    return {a, b};
  }
  \end{lstlisting}
\end{frame}

\begin{frame}[fragile]{\lstinline{std::tuple}}
  \url{https://en.cppreference.com/w/cpp/utility/tuple}
  \begin{lstlisting}[basicstyle=\ttfamily\srcbigsize]
  #include <tuple>

  auto many()
  {
    return std::make_tuple(1, 2, 'a', std::string{"str"});
  }

  std::tuple<int, char, double> alt()
  {
    return {1, 'a', 0.1};
  }

  const auto x = many();
  std::cout << std::get<0>(x)
        << ", " << std::get<1>(x)
        << ", " << std::get<2>(x)
        << ", " << std::get<3>(x) << std::endl;

  const auto y = std::tuple_cat(x, x, x);
  static_assert(std::tuple_size_v<decltype(y)> == 12);
  \end{lstlisting}
\end{frame}

\begin{frame}[fragile]{Structured bindings}
  \begin{lstlisting}
  std::tuple<A, B, C> foo();

  auto [a, b, c] = foo();
  a = A();
  const auto x = b;

  void bar(std::vector<std::pair<int, std::string>> & v) {
    for (auto & [n, s] : v) {
      n = s.size();
      s += '\n';
    }
  }
  \end{lstlisting}
\end{frame}

\end{document}