C++17 STL Стандартная библиотека шаблонов

Выполняем преобразование между абсолютными и относительными значениями с использованием std::chrono

До C++11 было довольно сложно получить физическое время и просто вывести его на экран, поскольку C++ не имела собственной библиотеки для работы с временем. Требовалось всегда вызывать функции библиотеки С, которая выглядит очень архаично, учитывая, что такие вызовы могут быть инкапсулированы в собственные классы.

Начиная с C++11, в STL можно найти библиотеку

chrono

В этом примере мы возьмем местное время, выведем его на экран и поработаем с ним, добавляя разные смещения, что очень удобно делать с помощью библиотеки

std::chrono

Как это делается

В примере мы сохраним текущее время и выведем его на экран. Кроме того, наша программа будет добавлять разные смещения к сохраненному времени и выводить на экран полученные результаты.

1. Сначала идут типичные директивы

include

std

#include 

#include 

#include 

using namespace std;

2. Выведем на экран абсолютные моменты времени. Они будут иметь форму шаблона типа

chrono::time_point

%c

put_time

ostream& operator<<(ostream &os,

     const chrono::time_point &t)

{

  const auto tt (chrono::system_clock::to_time_t(t));

 const auto loct (std::localtime(&tt));

  return os << put_time(loct, "%c");

}

3. Для секунд, минут, часов и т.д. в STL существуют описания типов. Сейчас мы добавим тип

days

chrono::duration

using days = chrono::duration<

 chrono::hours::rep,

  ratio_multiply>>;

4. Чтобы наиболее элегантным способом выразить продолжительность длиной в несколько дней, можно определить собственный пользовательский литерал

days

3_days

constexpr days operator ""_days(unsigned long long h)

{

  return days{h};

}

5. В самой программе сделаем снимок момента времени, который затем просто выведем на экран. Это очень легко и удобно, поскольку мы уже реализовали правильную версию перегруженного оператора.

int main()

{

  auto now (chrono::system_clock::now());

  cout << "The current date and time is " << now << '\n';

6. Сохранив текущее время в переменной

now

  chrono::hours chrono_12h {12};

  cout << "In 12 hours, it will be "

    << (now + chrono_12h)<< '\n';

7. Объявляя об использовании по умолчанию пространства имен

chrono_literals

  using namespace chrono_literals;

  cout << "12 hours and 15 minutes ago, it was "

    << (now - 12h - 15min) << '\n'

    << "1 week ago, it was "

    << (now - 7_days) << '\n';

}

8. Компиляция и запуск программы дадут следующий результат. Поскольку мы использовали в качестве строки форматирования

%c

$ ./relative_absolute_times

The current date and time is Fri May 5 13:20:38 2017

In 12 hours, it will be Sat May 6 01:20:38 2017

12 hours and 15 minutes ago, it was Fri May 5 01:05:38 2017

1 week ago, it was Fri Apr 28 13:20:38 2017

Как это работает

Мы получили текущий момент времени из

std::chrono::system_clock

time

Чтобы вывести на экран такие моменты времени, мы реализовали оператор

<<

ostream& operator<<(ostream &os,

    const chrono::time_point &t)

{

  const auto tt (chrono::system_clock::to_time_t(t));

 const auto loct (std::localtime(&tt));

  return os << put_time(loct, "%c");

}

Здесь мы сначала преобразуем экземпляр типа

chrono::time_point

std::time_t

std::localtime

Функция

std::put_time

"%c"

"Sun Mar 12 11:33:40 2017"

Мы также могли бы указать строку

"%m/%d/%y"

Помимо вывода на экран мы добавили смещения к нашему моменту времени. Это было просто, поскольку можно выразить промежутки времени, такие как 12 часов 15 минут, в виде

12h+15min

chrono_literals

h

min

s

ms

us

ns

Добавление подобной продолжительности к значению момента времени создает новое значение момента времени, поскольку типы имеют соответствующие перегруженные версии операторов

+

–

Безопасно извещаем о сбое с помощью std::optional

Когда программа общается с внешним миром и полагается на значения, получаемые извне, могут происходить всевозможные сбои.

Это означает вот что: когда мы пишем функцию, которая должна возвращать значение, но также может дать сбой, это нужно отразить с помощью неких изменений в интерфейсе функции. У нас есть несколько вариантов. Посмотрим, как разработать интерфейс функции, которая возвращает строку, но способна дать сбой:

□ использовать возвращаемое значение, указывающее на успех, и выходные параметры:

bool get_string(string&);

□ возвращать указатель (или умный указатель), значение которого можно установить на

nullptr

string* get_string();

□ генерировать исключение в случае сбоя и оставить сигнатуру функции очень простой:

string get_string();

Все эти подходы имеют свои преимущества и недостатки. Начиная с C++17, существует новый тип, который можно применять для решения такой задачи другим способом:

std::optional

Мы можем обернуть в тип

optional

Как это делается

В этом примере мы реализуем программу, которая считывает целые числа, поступающие от пользователя, и складывает их. Поскольку пользователь всегда может ввести случайные символы вместо чисел, мы увидим, как тип

optional

1. Сначала включим все необходимые заголовочные файлы и объявим об использовании пространства имен

std

#include 

#include 

using namespace std;

2. Определим целочисленный тип, который, может быть, содержит значение. Нам идеально подойдет тип std::optional. Обернув любой тип в тип optional, задаем ему еще одно возможное состояние, которое отражает тот факт, что тип не имеет значения:

using oint = optional;

3. Определив необязательный целочисленный тип, можем выразить тот факт, что функция, которая возвращает целое число, тоже способна дать сбой. Если мы возьмем целое число из пользовательских входных данных, то существует вероятность сбоя, поскольку пользователь может ввести какой-то другой символ, несмотря на наше приглашение. Возврат целого числа, обернутого в тип

optional

optional

oint read_int()

{

  int i;

  if (cin >> i) { return {i}; }

 return {};

}

4. Наши возможности не ограничиваются возвратом целых чисел из функций, способных дать сбой. Что если мы подсчитаем сумму двух целых чисел, которые могут не содержать значений? Мы получим реальную численную сумму только в том случае, если оба операнда содержат значения. В любом другом нужно вернуть пустую переменную типа

optional

a

b

!a

!b

*a

*b

oint operator+(oint a, oint b)

{

  if (!a || !b) { return {}; }

 return {*a + *b};

}

oint operator+(oint a, int b)

{

  if (!a) { return {}; }

 return {*a + b};

}

int main()

{

  cout << "Please enter 2 integers.\n> ";

 auto a {read_int()};

  auto b {read_int()};

10

a

b

sum

  auto sum (a + b + 10);

a

b

a

b

optional

+

  if (sum) {

   cout << *a << " + " << *b << " + 10 = "

     << *sum << '\n';

  } else {

   cout << "sorry, the input was "

   "something else than 2 numbers.\n";

  }

}

$ ./optional

Please enter 2 integers.

> 1 2

1 + 2 + 10 = 13

$ ./optional

Please enter 2 integers.

> 2 z

sorry, the input was something else than 2 numbers.

optional

T

std::optional

optional::has_value()

true

T& optional::value()

if (x.has_value()) {...}

x.value()

if (x) {  }

*x

std::optional

bool

operator*

optional

->

struct Foo { int a; string b; }

x

optional

x->a

x->b

х

optional

std::logic_error

try-catch

cout << "Please enter 3 numbers:\n";

try {

  cout << "Sum: "

    << (*read_int() + *read_int() + *read_int())

    << '\n';

} catch (const std::bad_optional_access &) {

 cout << "Unfortunately you did not enter 3 numbers\n";

}

std::optional

optional::value_or

x = optional_var.value_or(123)

123

Применяем функции для кортежей

Начиная с C++11, STL предоставляет тип

std::tuple

Однако иногда мы помещаем в кортеж значения, а затем хотим вызвать функции, передав в них его отдельные члены. Распаковывать члены по отдельности для каждого аргумента функции очень утомительно (а кроме того, могут возникнуть ошибки, если где-то вкрадется опечатка). Это выглядит так:

func(get<0>(tup)

get<1>(tup)

get<2>(tup), ...);

Ниже мы рассмотрим, как упаковывать значения в кортежи и ловко распаковывать из них, чтобы вызвать функции, которые не знают о кортежах.

Как это делается

В этом примере мы реализуем программу, которая упаковывает значения в кортежи и распаковывает из них. Затем увидим, как вызывать функции, ничего не знающие о кортежах, и передавать в них значения из кортежей.

1. Сначала включим множество заголовочных файлов и объявим об использовании пространства имен

std

#include 

#include 

#include 

#include 

#include 

#include 

using namespace std;

2. Определим функцию, которая принимает несколько параметров, описывающих студента, и выводит их на экран. Многие устаревшие интерфейсы и интерфейсы функций языка С выглядят похоже:

static void print_student(size_t id, const string &name, double gpa)

{

  cout << "Student " << quoted(name)

    << ", ID: " << id

    << ", GPA: " << gpa << '\n';

}

3. В самой программе определим тип кортежа динамически и заполним его осмысленными данными о студентах:

int main()

{

  using student = tuple;

 student john {123, "John Doe"s, 3.7};

4. Чтобы вывести такой объект на экран, можем разбить его на отдельные члены и вызвать функцию

print_student

  {

   const auto &[id, name, gpa] = john;

   print_student(id, name, gpa);

  }

  cout << "-----\n";

5. Создадим несколько студентов в виде списка инициализаторов для кортежей:

  auto arguments_for_later = {

   make_tuple(234, "John Doe"s, 3.7),

   make_tuple(345, "Billy Foo"s, 4.0),

   make_tuple(456, "Cathy Bar"s, 3.5),

  };

6. Мы все еще можем относительно комфортно вывести их на экран, но, чтобы разбить кортеж на части, следует знать, сколько элементов в нем содержится. Если нужно писать подобный код, то понадобится также реструктурировать его в случае изменения интерфейса вызова функции:

  for (const auto &[id, name, gpa] : arguments_for_later) {

   print_student(id, name, gpa);

  }

  cout << "-----\n";

7. Можно сделать лучше. Даже не зная типов аргументов функции

print_student

std::apply

  apply(print_student, john);

 cout << " \n";

8. Конечно, все это прекрасно работает и в цикле:

  for (const auto &args : arguments_for_later) {

   apply(print_student, args);

  }

  cout << "-----\n";

}

9. Компиляция и запуск программы покажут, что работают оба подхода, как мы и предполагали:

$ ./apply_functions_on_tuples

Student "John Doe", ID: 123, GPA: 3.7

-----

Student "John Doe", ID: 234, GPA: 3.7

Student "Billy Foo", ID: 345, GPA: 4

Student "Cathy Bar", ID: 456, GPA: 3.5

-----

Student "John Doe", ID: 123, GPA: 3.7

-----

Student "John Doe", ID: 234, GPA: 3.7

Student "Billy Foo", ID: 345, GPA: 4

Student "Cathy Bar", ID: 456, GPA: 3.5

-----

Как это работает

Функция

std::apply

Допустим, у нас есть кортеж

t

(123, "abc"s, 456.0)

tuple

f

int f(int, string, double)

Затем можно написать конструкцию

x = apply(f, t)

x = f(123, "abc"s, 456.0)

apply

f

Быстрое создание структур данных с помощью std::tuple

Взглянем на простой пример использования кортежей, с которым мы уже сталкивались. Мы можем определить следующую структуру, чтобы просто объединить некоторые переменные в одну сущность:

struct Foo {

 int a;

 string b;

 float c;

};

Вместо того чтобы определять структуру, как было сделано в предыдущем примере, можно также определить кортеж:

using Foo = tuple;

Получить доступ к его элементам можно по порядковому номеру типа из списка типов. Для получения доступа к первому члену кортежа

t

std::get<0>(t);

std::get<1>

На протяжении этой книги мы уже использовали возможности декомпозиции C++17 для кортежей. Она позволяет быстро разбить кортеж на элементы, просто написав

auto [a,b,c] = some_tuple

Композиция и декомпозиция отдельных структур данных — не единственная возможность, которую предоставляют кортежи. Мы также можем конкатенировать или разбивать кортежи. В этом разделе мы поэкспериментируем с данными функциями, чтобы узнать, как они работают.

Как это делается

В этом примере мы напишем программу, которая может динамически вывести на экран любой кортеж. Вдобавок напишем функцию, способную объединять кортежи.

1. Сначала включим несколько заголовочных файлов, а затем объявим об использовании пространства имен

std

#include 

#include 

#include 

#include 

#include 

#include 

#include 

#include 

using namespace std;

2. Поскольку мы будем работать с кортежами, было бы интересно отобразить их содержимое. Поэтому сейчас реализуем очень обобщенную функцию, которая может выводить на экран любые кортежи. Функция принимает ссылку на поток вывода

os

v

vs...

template 

void print_args(ostream &os, const T &v, const Ts &. vs)

{

  os << v;

3. Если в наборе параметров еще есть аргументы, то они выводятся на экран, притом их разделяет символ "

,

initializer_list

  (void)initializer_list{((os << ", " << vs), 0)...};

}

4. Теперь можно выводить на экран произвольное количество аргументов с помощью конструкции

print_args(cout,1,2,"foo",3,"bar")

<<

template 

ostream& operator<<(ostream &os, const tuple &t)

{

5. Сейчас все станет чуть сложнее. Сначала мы воспользуемся лямбда-выражением, которое принимает произвольно большое количество параметров. При вызове выражение добавляет аргумент

os

print_args

capt_tup(...некоторые параметры...)

print_args(os, ...некоторые параметры...)

  auto print_to_os ([&os](const auto &...xs) {

   print_args(os, xs...);

  });

6. Теперь можем выполнить распаковку кортежа. Для этого воспользуемся методом

std::apply

t = (1,2,3)

apply(capt_tup,t)

capt_tup(1,2,3)

print_args(os,1,2,3)

  os << "(";

  apply(print_to_os, t);

 return os << ")";

}

7. О’кей, мы написали сложный фрагмент кода, который сделает нашу жизнь гораздо проще, если мы захотим вывести кортеж на экран. Но с помощью кортежей мы можем сделать больше. Допустим, напишем функцию, принимающую в качестве аргумента итерабельный диапазон данных, например вектор или список чисел. Эта функция проитерирует по данному диапазону и вернет сумму всех его чисел, а также минимальное, максимальное и среднее значения. Упаковывая эти четыре значения в кортеж, можем вернуть их как один объект, не определяя дополнительный тип структуры.

template 

tuple

sum_min_max_avg(const T &range)

{

8. Функция

std::minmax_element

std::accumulate

  auto min_max (minmax_element(begin(range), end(range)));

 auto sum (accumulate(begin(range), end(range), 0.0));

 return {sum, *min_max.first, *min_max.second,

      sum / range.size()};

}

9. Перед реализацией основной программы создадим последнюю волшебную вспомогательную функцию. Я называю ее волшебной, поскольку она на первый взгляд выглядит очень сложной, но если понять принцип ее работы, она покажется очень удобным помощником. Она сгруппирует два кортежа. Это значит, что если мы передадим ей кортежи

(1,2,3)

('a','b','c')

(1,'a',2,'b',3,'c')

template 

static auto zip(const T1 &a, const T2 &b)

{

10. Мы подобрались к самым сложным строкам данного примера. Создадим объект функции z, принимающий произвольное количество аргументов. Затем он возвращает другой объект функции, который захватывает все эти аргументы в набор параметров

xs

xs

ys

make_tuple(xs,ys)

xs = 1,2,3

ys = 'a','b','c'

(1,'a')

(2,'b')

(3,'c')

std::tuple_cat

(1,'a',2,'b',3,'c')

  auto z ([](auto ...xs) {

   return [xs...](auto ...ys) {

     return tuple_cat(make_tuple(xs, ys) );

   };

  });

11. Последний шаг состоит в том, чтобы распаковать все значения из входных кортежей

a

b

z

apply(z,a)

a

xs

apply(...,b)

b

ys

  return apply(apply(z, a), b);

}

12. Мы написали довольно много строк кода для вспомогательных функций. Теперь воспользуемся ими. Сначала создадим произвольные кортежи.

student

student_desc

std::make_tuple

int main()

{

  auto student_desc (make_tuple("ID", "Name", "GPA"));

  auto student    (make_tuple(123456, "John Doe", 3.7));

13. Выведем на экран все, чем располагаем. Сделать это очень легко, поскольку мы только что реализовали соответствующую перегруженную версию оператора

<<

  cout << student_desc << '\n'

    << student << '\n';

14. Кроме того, можем сгруппировать оба кортежа динамически с помощью

std::tuple_cat

  cout << tuple_cat(student_desc, student) << '\n';

15. Мы можем создать и новый сгруппированный кортеж, задействуя нашу функцию

zip

  auto zipped (zip(student_desc, student));

 cout << zipped << '\n';

16. Не будем забывать и о функции

sum_min_max_avg

  auto numbers = {0.0, 1.0, 2.0, 3.0, 4.0};

 cout << zip(

      make_tuple("Sum", "Minimum", "Maximum", "Average"),

       sum_min_max_avg(numbers))

     << '\n';

}

17. Компиляция и запуск программы дадут следующий результат. Первые две строки представляют отдельные кортежи

student

student_desc

tuple_cat

$ ./tuple

(ID, Name, GPA)

(123456, John Doe, 3.7)

(ID, Name, GPA, 123456, John Doe, 3.7)

(ID, 123456, Name, John Doe, GPA, 3.7)

(Sum, 10, Minimum, 0, Maximum, 4, Average, 2)

Как это работает

Отдельные фрагменты кода, представленные в этом разделе, довольно сложны. Мы написали реализацию

operator<<

sum_min_max_avg

zip

Самой простой частью была функция

sum_min_max_avg

tuple f()

return {foo_instance, bar_ instance, baz_instance};

Остальной код настолько сложен, что мы посвятим конкретным вспомогательным функциям отдельные подразделы.

operator<< для кортежей

До работы с

operator<<

print_args

ostream

template 

void print_args(ostream &os, const T &v, const Ts &. vs)

{

  os << v;

  (void)initializer_list{((os << ", " << vs), 0)...};

}

Эта функция выводит на экран первый элемент

v

vs

"1,2,3, "

",1,2,3"

initializer_list

<<

template 

ostream& operator<<(ostream &os, const tuple &t)

{

  auto capt_tup ([&os](const auto &...xs) {

   print_args(os, xs...);

  });

  os << "(";

  apply(capt_tup, t);

 return os << ")";

}

Первое, что мы делаем, — это определяем объект функции

capt_tup

capt_tup(foo, bar, whatever)

print_args(os, foo, bar, whatever)

os

После этого мы воспользуемся методом

std::apply

t

std::apply

Функция zip для кортежей

Функция

zip

template 

auto zip(const T1 &a, const T2 &b)

{

  auto z ([](auto ...xs) {

   return [xs...](auto ...ys) {

    return tuple_cat(make_tuple(xs, ys) ...);

   };

  });

  return apply(apply(z, a), b);

}

Для лучшего понимания этого кода представьте, что кортеж

a

1

2

3

b

'a'

'b'

'c'

В данном случае вызов

apply(z, a)

z(1, 2, 3)

1

2

3

xs

apply(z(1,2,3),b)

'a'

'b'

'c'

ys

z(1,2,3)('a', 'b', 'c')

О’кей, что произойдет теперь, когда у нас есть значения

xs = (1, 2, 3)

ys = ('a', 'b', 'c')

tuple_cat(make_tuple(xs, ys) ...)

Сначала элементы из наборов

xs

ys

make_tuple(xs,ys)

tuple_cat

Замена void* с использованием std::any для повышения безопасности типов

Может случиться так: нам понадобится сохранить элементы любого типа в переменной. Для такой переменной следует проверить, содержит ли она что-либо, и если да, то нужно определить, что именно. Все это надо сделать безопасно для типов.

В прошлом мы имели возможность хранить указатели на различные объекты в указателе типа

void*

Еще одним дополнением к STL в C++17 является тип

std::any

В текущем разделе мы поработаем с этим вспомогательным типом для того, чтобы несколько лучше его понять.

Как это делается

В этом примере мы реализуем функцию, которая пробует вывести на экран какие-либо данные. В качестве ее типа аргумента служит тип

std::any

1. Сначала включим необходимые заголовочные файлы и объявим об использовании пространства имен

std

#include 

#include 

#include 

#include 

#include 

using namespace std;

2. Чтобы сократить объем использования угловых скобок в следующей программе, определим псевдоним для типа

list

using int_list = list;

3. Реализуем функцию, которая утверждает, что может вывести на экран любые данные. Обещание заключается вот в чем: она выводит любые данные, предоставленные как аргумент в виде переменной

std::any

void print_anything(const std::any &a)

{

4. Первое, что нужно сделать, — проверить, содержит ли аргумент какие-то данные, или же это пустой экземпляр типа any. Если он пуст, то нет смысла пытаться определить, как его выводить на экран.

  if (!a.has_value()) {

   cout << "Nothing.\n";

5. Если он не пуст, то можно попробовать сравнивать его с разными типами до тех пор, пока не получим совпадение. Первым типом послужит тип

string

a

string

std::any_cast

  } else if (a.type() == typeid(string)) {

   cout << "It's a string: "

     << quoted(any_cast(a)) << '\n';

6. Если это не

string

int

any_cast

int

  } else if (a.type() == typeid(int)) {

   cout << "It's an integer: "

     << any_cast(a) << '\n';

7.

std::any

string

int

  } else if (a.type() == typeid(int_list)) {

   const auto &l (any_cast(a));

   cout << "It's a list: ";

   copy(begin(l), end(l),

      ostream_iterator{cout, ", "});

   cout << '\n';

8. Если не подошел ни один из перечисленных типов, то у нас закончатся догадки. В таком случае просто сдадимся и скажем пользователю, что не знаем, как выводить эти данные на экран:

  } else {

   cout << "Can't handle this item.\n";

  }

}

9. В функции

main

any

{}

"abc"

std::any

int main()

{

  print_anything({});

 print_anything("abc"s);

 print_anything(123);

 print_anything(int_list{1, 2, 3});

10. Если мы будем помещать объекты, копировать которые действительно дорого, в переменную типа

any

in_place_type_t{}

{1,2,3}

int_list

any

  print_anything(any(in_place_type_t{}, {1, 2, 3}));

}

11. Компиляция и запуск программы дадут следующие результаты, они полностью соответствуют нашим ожиданиям:

$ ./any

Nothing.

It's a string: "abc"

It's an integer: 123

It's a list: 1, 2, 3,

It's a list: 1, 2, 3,

Как это работает

Тип

std::any

std::optional

has_value()

optional

Прежде чем получать доступ к содержимому переменной типа

any

Определить тип значения можно с помощью следующего сравнения:

x.type() == typeid(T)

true

any_cast

Обратите внимание:

any_cast(x)

any_cast(x)

string

list

Если мы преобразуем экземпляр к неправильному типу, будет сгенерировано исключение

std::bad_any_cas

Хранение разных типов с применением std::variant

В языке С++ для создания типов можно использовать не только примитивы

struct

class

А

В

C

Рассмотрим следующий код:

union U {

  int a;

  char *b;

  float c;

};

void func(U u) { std::cout << u.b << '\n'; }

Допустим, мы вызовем функцию

func

a

b

std::variant

Тип

variant

union

void

В этом разделе мы создадим программу, которая задействует тип

variant

Как это делается

В этом примере мы реализуем программу, которая уже знакома с типами

cat

dog

1. Сначала включим все необходимые заголовочные файлы и объявим об использовании пространства имен

std

#include 

#include 

#include 

#include 

#include

using namespace std;

2. Далее реализуем два класса, имеющих схожий инструментарий, но не связанных друг с другом, что отличает их от классов, которые, скажем, наследуют от одного интерфейса или похожих интерфейсов. Первый класс — это класс

cat

class cat {

  string name;

public:

  cat(string n) : name{n} {}

 void meow() const {

   cout << name << " says Meow!\n";

  }

};

3. Второй класс — это класс

dog

dog

class dog {

  string name;

public:

  dog(string n) : name{n} {}

 void woof() const {

   cout << name << " says Woof!\n";

  }

};

4. Теперь можно определить тип

animal

std::variant

variant

using animal = variant;

5. Прежде чем писать основную программу, нужно реализовать два вспомогательных элемента. Одним из них является предикат

animal

is_type(...)

is_type(...)

animal

holds_alternative

variant

template 

bool is_type(const animal &a) {

  return holds_alternative(a);

}

6. Вторым вспомогательным элементом является структура, которая ведет себя как объект функции. Это двойной объект функции, поскольку он дважды реализует оператор

()

dog

cat

woof

meow

struct animal_voice

{

  void operator()(const dog &d) const { d.woof(); }

 void operator()(const cat &c) const { c.meow(); }

};

7. Воспользуемся результатами нашего труда. Сначала определим список переменных типа

animal

cat

dog

int main()

{

  list l {cat{"Tuba"}, dog{"Balou"}, cat{"Bobby"}};

8. Теперь трижды выведем на экран содержимое списка, каждый раз новым способом. Один из них заключается в использовании

variant::index()

animal

variant

0

dog

1

cat

variant

switch case

variant

get

cat

dog

  for (const animal &a : l) {

   switch (a.index()) {

   case 0:

    get(a).woof();

    break;

   case 1:

    get(a).meow();

    break;

   }

  }

  cout << "-----\n";

9. Вместо того чтобы использовать численный индекс типа, можно также явно запросить каждый тип. Вызов

get_if

do

dog

null

  for (const animal &a : l) {

   if (const auto d (get_if(&a)); d) {

     d->woof();

   } else if (const auto c (get_if(&a)); c) {

    c->meow();

   }

  }

  cout << "-----\n";

10. Последний — и самый элегантный вариант — это

variant::visit

variant

variant

()

  for (const animal &a : l) {

     visit(animal_voice{}, a);

  }

  cout << "-----\n";

11. Наконец подсчитаем количество экземпляров типов

cat

dog

is_type

cat

dog

std::count_if

 cout << "There are "

    << count_if(begin(l), end(l), is_type)

    << " cats and "

    << count_if(begin(l), end(l), is_type)

    << " dogs in the list.\n";

}

12. После компиляции и запуска программы на экране будет список, выведенный три раза. Затем мы увидим, что предикаты

is_type

count_if

$ ./variant Tuba says Meow!

Balou says Woof!

Bobby says Meow!

-----

Tuba says Meow!

Balou says Woof!

Bobby says Meow!

-----

Tuba says Meow!

Balou says Woof!

Bobby says Meow!

-----

There are 2 cats and 1 dogs in the list.

Как это работает

Тип

std::variant

std::any

С другой стороны, тип

std::variant

std::any

std::variant

A

B

C

variant

std::variant

Экземпляр типа

variant

union U {

  A a;

  B b;

  C c;

};

Проблема с объединениями заключается в том, что нужно создавать собственные механизмы для определения того, экземпляром какого типа оно было инициализировано:

A

B

C

std::variant

В коде, показанном в этом разделе, мы использовали три разных способа работы с содержимым переменной variant.

Первый способ — применение функции

index()

variant

variant

0

A

1

B

2

C

Следующий способ — использование функции

get_if

variant

T

T

get(x)

variant

holds_alternative(x)

Последний способ получить доступ к значению, хранящемуся в типе

variant

std::visit

variant

variant

()

Именно для этих целей мы и реализовали тип animal_voice, поскольку он может быть использован в комбинации с

visit

variant

struct animal_voice

{

  void operator()(const dog &d) const { d.woof(); }

 void operator()(const cat &c) const { c.meow(); }

};

Последний описанный способ получения доступа к экземплярам, хранящимся в экземплярах типа

variant

Утверждение о том, что тип

variant

std::monostate

Автоматическое управление ресурсами с помощью std::unique_ptr

Начиная с C++11 в STL появились умные указатели, помогающие отслеживать динамическую память и ее использование. Даже до C++11 существовал класс

auto_ptr

Однако с появлением умных указателей теперь редко приходится самостоятельно использовать ключевые слова

new

delete

unique_ptr

Уникальный указатель выражает принадлежность объекта, на который ссылается, и выполняет свою задачу по освобождению его памяти, если та более не используется. Этот класс может навсегда освободить нас от утечек памяти (во всяком случае вместе со своими компаньонами

shared_ptr

weak_ptr

unique_ptr

nullptr

В этом разделе мы рассмотрим

unique_ptr

Как это делается

В этом примере мы напишем программу, которая покажет, как

unique_ptr

1. Сначала включим необходимые заголовочные файлы и объявим об использовании пространства имен

std

#include 

#include 

using namespace std;

2. Мы реализуем небольшой класс для объекта, которым будем управлять с помощью

unique_ptr

class Foo

{

public:

  string name;

  Foo(string n)

   : name{move(n)}

  { cout << "CTOR " << name << '\n'; }

  ~Foo() { cout << "DTOR " << name << '\n'; }

};

3. Попробуем реализовать функцию, принимающую в качестве аргументов уникальные указатели, чтобы увидеть, какие ограничения она имеет. Она обрабатывает элемент типа

Foo

null

void process_item(unique_ptr p)

{

  if (!p) { return; }

  cout << "Processing " << p->name << '\n';

}

4. В функции main откроем еще одну область видимости, создадим два объекта типа

Foo

unique_ptr

p1

p2

make_unique

Foo

unique_ptr

int main()

{

  {

   unique_ptr p1 {new Foo{"foo"}};

   auto p2 (make_unique("bar"));

  }

5. После того как мы покинем область видимости, оба объекта будут разрушены и их память вернется в кучу. Взглянем на функцию

process_item

unique_ptr

Foo

unique_ptr

process_item

  process_item(make_unique("foo1"));

6. Если мы хотим вызвать

process_item

unique_ptr

unique_ptr

Foo

process_item

foo2

process_item

foo3

main

  auto p1 (make_unique("foo2"));

 auto p2 (make_unique("foo3"));

 process_item(move(p1));

  cout << "End of main()\n";

}

7. Скомпилируем и запустим программу. Сначала мы увидим вызовы конструктора и деструктора для

foo

bar

foo1

process_item

foo2

foo3

process_item

foo3

main

$ ./unique_ptr

CTOR foo

CTOR bar

DTOR bar

DTOR foo

CTOR foo1

Processing foo1

DTOR foo1

CTOR foo2

CTOR foo3

Processing foo2

DTOR foo2

End of main()

DTOR foo3

Как это работает

Управлять объектами кучи с помощью

std::unique_ptr

Если мы присвоим какой-то новый указатель уникальному указателю, то он сначала удалит старый объект, а только затем сохранит новый указатель. Для переменной уникального указателя

x

x.reset()

x = new_pointer

x.reset(new_pointer)

Существует единственный способ освободить объект от управления

unique_ptr

release

Поскольку указатели нужно проверять перед разыменованием, они переопределяют некоторые операторы так, чтобы те походили на необработанные указатели. Условия наподобие

if (p) {...}

if (p != nullptr) {...}

Разыменовать уникальный указатель можно с помощью функции

get()

operator*

Одна из важных характеристик

unique_ptr

unique_ptr

process_item

Поскольку существуют структуры данных, такие как

unique_ptr

shared_ ptr

new

delete

unique_ptr

Автоматическое управление разделяемой памятью кучи с использованием std::shared_ptr

В предыдущем примере мы узнали, как использовать

unique_ptr

Тип указателя

shared_ptr

В этом примере вы узнаете, как использовать

shared_ptr

unique_ptr

Как это делается

В этом примере мы напишем программу, похожую на ту, которую мы писали в предыдущем примере, чтобы освоить основные принципы использования общих указателей.

1. Сначала включим необходимые заголовочные файлы и объявим об использовании пространства имен

std

#include 

#include 

using namespace std;

2. Затем определим небольшой вспомогательный класс, который поможет увидеть, когда его экземпляры будут создаваться и разрушаться. Мы станем управлять его экземплярами с помощью

shared_ptr

class Foo

{

public:

  string name;

  Foo(string n)

   : name{move(n)}

  { cout << "CTOR " << name << '\n'; }

  ~Foo() { cout << "DTOR " << name << '\n'; }

};

3. Далее реализуем функцию, которая принимает общий указатель на экземпляр типа

Foo

void f(shared_ptr sp)

{

  cout << "f: use counter at "

    << sp.use_count() << '\n';

}

4. В функции

main

null

int main()

{

  shared_ptr fa;

5. Далее откроем еще одну область видимости и создадим два объекта типа

Foo

new

shared_ptr

make_shared

Foo

unique_ptr

  {

    cout << "Inner scope begin\n";

    shared_ptr f1 {new Foo{"foo"}};

    auto       f2 (make_shared("bar"));

6. Поскольку общие указатели могут быть разделяемыми, они должны отслеживать количество сторон, владеющих ими. Это делается с помощью внутреннего счетчика ссылок или счетчика использования. Можно вывести на экран его значение, задействуя

use_count

1

f1

fa

2

   cout << "f1's use counter at " << f1.use_count() << '\n';

   fa = f1;

    cout << "f1's use counter at " << f1.use_count() << '\n';

7. Когда мы покинем область видимости, общие указатели

f1

f2

f1

1

fa

Foo

f2

0

shared_ptr

delete

  }

  cout << "Back to outer scope\n";

  cout << fa.use_count() << '\n';

8. Теперь вызовем функцию

f

fa

f

2

f

f

  cout << "first f() call\n";

  f(fa);

  cout << "second f() call\n";

 f(move(fa));

9. После того как функция

f

Foo

main

  cout << "end of main()\n";

}

10. Компиляция и запуск программы дадут следующий результат. Сначала мы увидим, что созданы

"foo"

"bar"

f1

"foo"

2

"bar"

fa

"foo"

f

fa

2

f

f

"foo"

f

print

main

$ ./shared_ptr

Inner scope begin

CTOR foo

CTOR bar

f1's use counter at 1

f1's use counter at 2

DTOR bar

Back to outer scope

1

first f()

call

f: use counter at 2

second f() call

f: use counter at 1

DTOR foo

end of main()

Как это работает

При создании и удалении объектов

shared_ptr

unique_ptr

make_shared

make_unique

unique_ptr

Основное отличие от

unique_ptr

shared_ptr

N

shared_ptr

N

shared_ptr

0

delete

Чтобы проиллюстрировать эту идею, взглянем на рис. 8.2.

В шаге 1 у нас имеются два экземпляра типа

shared_ptr

Foo

2

shared_ptr2

1

Foo

3

0

Foo

С помощью

shared_ptr

unique_ptr

0

Дополнительная информация

Рассмотрим следующий код. Допустим, вам сказали, что он провоцирует потенциальную утечку памяти.

void function(shared_ptr, shared_ptr, int);

// "function" определена где-то еще

// ...далее по коду:

function(new A{}, new B{}, other_function());

A

B

shared_ptr

shared_ptr

f(x(),y(),z())

x()

y()

z()

f

x

y

z

new A{}

other_function()

B{}

other_function()

A

shared_ptr

// 1.)

function(make_shared(), make_shared(), other_function());

// 2.)

shared_ptr ap {new A{}};

shared_ptr bp {new B{}};

function(ap, bp, other_function());

shared_ptr