С++

• std::stacktrace,
• z и uz,
• 61 с половиной багфикс в ядре языка,
• string::contains,
• Executors & Networking,
• и прочие новости.

std::stacktrace

#include <stacktrace>// ...std::cout << std::stacktrace::current();

0# bar(int) at /path/to/source/file.cpp:701# bar(int) at /path/to/source/file.cpp:702# bar(int) at /path/to/source/file.cpp:703# bar(int) at /path/to/source/file.cpp:704# main at /path/to/main.cpp:935# __libc_start_main in /lib/x86_64-linux-gnu/libc.so.66# _start

Z и UZ

for (auto i = 0uz; i < vec.size(); ++i) {      assert(i == vec[i].size());}

Большой рефакторинг стандарта

string::contains

str.substr(0, str2.size()) == str2

str.starts_with(str2);

str.size() >= str2.size() && !str.compare(    str.size() - str2.size(),    std::string_view::npos,    str2)

str.ends_with(str2);

std::sort(std::begin(d), std::end(d));

std::ranges::sort(d);

Executors & Networking

• github.com/executors/executors-impl
• github.com/facebookexperimental/libunifex
• github.com/jaredhoberock/cusend
• github.com/jaredhoberock/cuex
• github.com/chriskohlhoff/propria

Прочие новости

Обычный рабочий процесс

std::string sample(int d, std::string (*cb)(int, std::string)) {  // Getting new descriptors from d with a timeout  auto result = get(d, 1000);  if (result != -13) {    // Descriptor is fine, processing with non bulk options    auto data = process(result, true, false, true);    // Passing processing result to the callback    return cb(data.second.first, data.second.second);  }  // Notifying callback on error  return cb(result, {});}

enum class Descriptor : int {};std::string sample(Descriptor d, std::string (*cb)(Descriptor, std::string)) {  // Getting new descriptors from d with a timeout  auto result = get(d, 1000);  if (result != Descriptor(-13)) {    // Descriptor is fine, processing with non bulk options    auto data = process(result, true, false, true);  // <== ERROR    // Passing processing result to the callback    return cb(data.second.first, data.second.second);  // <== ERROR  }  // Notifying callback on error  return cb(result, {});}

Боль

std::pair<Descriptor, std::pair<int, std::string>> process(bool, Descriptor, bool, bool);

Выжимка проблем

• Код написан на двух языках:
  Его в два раза больше.
  При отладке возникают проблемы со сверкой двух языков.
  

• Комментариев всё ещё недостаточно:
  Приходится читать код смежных функций.
  Есть магические константы.
  

• Код обработки ошибок и основной логики перемешаны:
  Большие блоки кода с большими отступами.
  

Читаемый код

std::string Sample(Descriptor listener,                              std::string (*cb)(Descriptor, std::string)){  UASSERT_MSG(cb, "Callback must be a non-zero function pointer");  const auto new_descriptor = Accept(listener, kAcceptTimeout);  if (new_descriptor == kBadDescriptor) {    return cb(kBadDescriptor, {});  }  auto data = Process(Options::kSync, new_descriptor);  return cb(data.descriptor, data.payload);}

Приёмы

Compute(payload, kComputeTimeout)

Compute(payload=payload, timeout=1023);

Compute({.payload=payload, .timeout=1023});

Compute(payload=payload, timeout=MAX_TEST_RUN_TIME);

Compute(payload, Device::kGPU)

Compute(payload=payload, is_cpu=False);

Compute(data.node_id, data.chunk_id)

std::tuple<int, std::string> Receive();

struct Response {    int pending_bytes;    std::string payload;};Response Receive();

void Accept(Descriptor, std::chrono::milliseconds)

def Accept(listener: Descriptor, timeout: datetime.timedelta) -> None:

namespace detail { void Compute(Data data); }

def _compute(data: Data) -> None:

descriptor, callback, mutator, GetDestination

connection_ = address.Connect(kTimeout);

self._connection = address.Connect(TIMEOUT);

ASSERT(attempts > 0);

assert timeout > 0

if (attempts <= 0) throw NegativeAttempts();

if (attempts <= 0) raise NegativeAttempts();

ASSERT(attempts > 0);if (attempts <= 0) throw NegativeAttempts();

if (value != BAD) {    auto a = foo(value);    auto b = bar(value);    if (a + b < 0) {         return a * b;    } else {         return a / b + baz();    }}return 0;

if (value == BAD) {    return 0;}auto a = foo(value);auto b = bar(value);if (a + b < 0) {     return a * b;}return a / b + baz();

Вместо заключения

Об объектно-ориентированном программировании (ООП) как инструменте

Об энтропии как тайной силе, подпитывающей разработку ПО

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

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

О легкости удаления кода как о принципе проектирования

О производительности по определению

О борьбе со стереотипами

• С хорошим ООП так бы не вышло. Это плохо спроектированное ООП. Этот код не следует принципам ООП и тому подобное. Слышал такие вещи, когда демонстрировал примеры ООП, заведшего во все тяжкие (как я уже говорил выше, с ООП-кодом такое происходит неизбежно). Это типичный пример логического заблуждения Ни один истинный шотландец.
• Я знаю ООП, и, если начинать с чистого листа, то больше ничем пользоваться не хочу. Это страх потерять свой сеньорский статус после того, как на протяжении всей карьеры пользовался принципами ООП и руководил другими людьми, от которых также требовал использовать эти принципы. Я считаю, что здесь мы имеем дело с примером ошибки невозвратных издержек.
• Все знают ООП, очень удобно говорить с людьми на общем языке, обладая общими знаниями. Это логическая ошибка, называемая аргумент к народу, то есть, если практически все программисты пользуются принципами ООП, то эта идея не может быть неподходящей.

Существует открытый проект COVID-19 CovidSim Model, написанный на языке C++. Существует статический анализатор кода PVS-Studio, который умеет хорошо находить ошибки. Однажды они встретились. Познайте хрупкость алгоритмов математического моделирования и почему нужно прикладывать максимум усилий к качеству программного кода.

На днях мне понадобилось кое-что найти на GitHub, что является началом этой маленькой истории. Изучая результаты поиска, я случайно набрёл на проект COVID-19 CovidSim Model. Недолго думая, я решил проверить его с помощью анализатора PVS-Studio.

Проект оказался совсем крошечным. В нём всего 13 000 строк кода, если не считать пустые строки и комментарии. И ошибок там тоже почти нет. Но одна ошибка настолько проста и красива, что я не могу пройти мимо!

void CalcLikelihood(int run, std::string const& DataFile,                    std::string const& OutFileBase){  ....  double m = Data[row][col]; // numerator  double N = Data[row][col + 1]; // denominator  double ModelValue;  // loop over all days of infection up to day of sample  for (int k = offset; k < day; k++)  {    // add P1 to P2 to prevent degeneracy    double prob_seroconvert = P.SeroConvMaxSens *      (1.0 - 0.5 * ((exp(-((double)(_I64(day) - k)) * P.SeroConvP1) + 1.0) *      exp(-((double)(_I64(day) - k)) * P.SeroConvP2)));    ModelValue += c * TimeSeries[k - offset].incI * prob_seroconvert;  }  ModelValue += c * TimeSeries[day - offset].S * (1.0 - P.SeroConvSpec);  ModelValue /= ((double)P.PopSize);  // subtract saturated likelihood  LL += m * log((ModelValue + 1e-20) / (m / N + 1e-20)) +        (N - m) * log((1.0 - ModelValue + 1e-20) / (1.0 - m / N + 1e-20));  ....}

Серьёзный научный код. Что-то считается. Формулы. Выглядит всё умно и обстоятельно.

Вот только все эти вычисления разбиваются о человеческую невнимательность. Хорошо, что на помощь может прийти анализатор кода PVS-Studio и указать на баг: V614 [CWE-457] Uninitialized variable 'ModelValue' used. CovidSim.cpp 5412

И действительно, посмотрим внимательнее на это:

double ModelValue;for (int k = offset; k < day; k++){  double prob_seroconvert = ....;  ModelValue += c * TimeSeries[k - offset].incI * prob_seroconvert;}

Перед нами простая и одновременно страшная ошибка: неинициализированная переменная. Этот алгоритм может насчитать всё что угодно.

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

Это уже не первая наша статья на эту тему:

• Анализ кода ROOT фреймворка для анализа данных научных исследований
• NCBI Genome Workbench: научные исследования под угрозой
• Большой Калькулятор выходит из-под контроля

Используйте статический анализатор кода PVS-Studio! Польза от своевременно найденных ошибок может быть колоссальной. Спасибо за внимание.

Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Andrey Karpov. COVID-19 Research and Uninitialized Variable.

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

Однако есть и классическая, более распространённая техника для борьбы с циклами использование итераторов и диапазонов для ленивых операций над последовательностями. Всё это уже сто лет есть в Бусте и других сторонних библиотеках (к примеру, range-v3) и постепенно просачивается в стандартную библиотеку.

Хотя, в некотором смысле, и в стандартной библиотеке ленивые итераторы уже есть давно (см. std::reverse_iterator).

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

Содержание

1. Итератор
2. Ленивость
   
   1. Transform Iterator
   2. Filter Iterator
3. Ленивые диапазоны
   
   1. Transform Range
   2. Stride
4. Компоновка
5. Суть итераторов и диапазонов
6. Ссылки

Итератор

Начнём с простого. Что вообще такое итератор?

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

• Продвижение (например, ++i или i + n);
• Разыменование (*i).

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

Ленивость

Внедрение в операции над диапазонами может быть сколь угодно хитрым и сложным (простые примеры я привёл ниже). Ленивость же состоит в том, что нет никаких промежуточных результатов. Все вычисления происходят только тогда, когда вызываются операции разыменования или продвижения.

Определение 1. Итератор e достижим из итератора b, если существует схема f продвижения итератора b такая, что f(b) = e.

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

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

Transform Iterator

Простой пример внедрения в операцию разыменования это boost::transform_iterator.

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

Таким образом, каждому итератору i типа I мы поставили в соответствие итератор j типа J такой, что *j = f(*i).

auto v = std::vector{1, 2, 3, 4};//                   2  4  6  8auto i = v.begin();auto t = boost::make_transform_iterator(i, [] (auto x) {return x * 2;});assert(*t == 2);++t;assert(*t == 4);...

Filter Iterator

Пример внедрения в продвижение это boost::filter_iterator.

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

Таким образом, мы "выбросили" из исходной последовательности итераторы i такие, что p(*i) == false, и в результирующей последовательности, для каждого итератора j типа J выполняется p(*j) == true.

auto v = std::vector{1, 2, 3, 4};//                      ^     ^auto i = v.begin();auto f = boost::make_filter_iterator(i, [] (auto x) {return x % 2 == 0;});assert(*i == 2);++i;assert(*i == 4);

Ленивые диапазоны

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

При этом диапазон это уже более сложная конструкция, и у него другой интерфейс, похожий на интерфейс контейнеров:

• Взятие итераторов на начало и конец (r.begin(), r.end());
• Взятие первого элемента диапазона (r.front());
• Проверка на пустоту (r.empty()).

Разница только в том, что диапазон не владеет элементами, которые он задаёт. Хотя бы потому что канонический диапазон это просто пара итераторов (к примеру, std::equal_range).

Важно отметить, что диапазон принято задавать полуинтервалом [b, e). Это значит, что итератор-начало b указывает на первый элемент последовательности, а итератор-конец e указывает на элемент после последнего. Таким образом, когда мы приходим в итератор-конец, мы точно знаем, что последовательность закончилась.

Transform Range

На основе преобразующих итераторов можно собрать диапазон (см. boost::iterator_range).

auto v = std::vector{...};auto l = [] (auto x) {return x * x;};auto tb = boost::make_transform_iterator(v.begin(), l);auto te = boost::make_transform_iterator(v.end(), l);auto tr = boost::make_iterator_range(tb, te);for (auto x: tr){    ...}

Или проще (см. boost::transformed):

auto v = std::vector{...};auto tr = boost::adaptors::transform(v, [] (auto x) {return x * x;});for (auto x: tr){    ...}

В C++20 это std::transform_view:

auto v = std::vector{...};auto tr = std::ranges::views::transform(v, [] (auto x) {return x * x;});for (auto x: tr){    ...}

Stride

Другой пример ленивого диапазона это boost::strided.

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

auto v = std::vector{1, 2, 3, 4};//                   ^     ^auto s = boost::adaptors::strided(v, 2);assert(s.front() == 1);s.advance_begin();assert(s.front() == 3);

Компоновка

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

Например, если мы хотим для некоей последовательности чисел:

• возвести их в квадрат,
• взять только каждый четвёртый элемент,
• и оставить только чётные числа,

то можно это сделать так:

auto v = std::vector{...};auto r = v | transformed([] (auto x) {return x * x;})           | strided(4)           | filtered([] (auto x) {return x % 2 == 0;});

Или, в C++20:

auto v = std::vector{...};auto r = v | std::views::transformed([] (auto x) {return x * x;})//         | strided(4) // В C++20 такого нет.           | std::views::filtered([] (auto x) {return x % 2 == 0;});

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

Суть итераторов и диапазонов

Помимо C++, в некоторых языках программировани также существует концепция под названием "итератор", но эта концепция зачастую имеет какой-то свой, альтернативный смысл.
К примеру, "итераторы" в языках Java и C# знают свой предел. С точки зрения языка C++ это, скорее, диапазоны.

В C++ итератор это именно обобщение указателя. По сути указатель это самый сильный (или наиболее конкретный) итератор, причём иерархия следующая:

• Однопроходный итератор (input iterator);
• Однонаправленный итератор (forward iterator);
• Двунаправленный итератор (bidirectional iterator);
• Итератор произвольного доступа (random access iterator);
• Непрерывный итератор (contiguous iterator);
• Указатель.

Диапазон же можно рассматривать именно как пару итераторов (даже если это на самом деле не так). Диапазон уже знает, где у него конец, может накладывать дополнительную логику на операции с итераторами и т.д. Также диапазон может быть сконвертирован обратно в итераторы (потому что диапазон это пара итераторов, как уже было сказано выше).

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

Один из примеров создания сложной операции над диапазонами я привёл в статье Ленивые операции над множествами в C++.

Ссылки

• Итераторы
• Boost.Iterator
• Boost.Range
• range-v3
• Ranges (C++20)

Библиотека концепций C++

template <список параметров>concept concept-name = constraint-expression;...<i>// concept</i>template <class T, class U>concept Derived = std::is_base_of<U, T>::value;

#include <string>#include <cstddef>#include <concepts>template<typename T>concept Sorter = requires(T a) {{ std::hash<T>{}(a) } -> std::convertible_to<std::size_t>;};struct asdf {};template<Sorter T>void f(T) {}int main() {using std::operators;f(abcs); <i>// Верно, std::string удовлетворяет условиям Sorter</i><i>//f(asdf{}); // Ошибка: asdf не удовлетворяет условиям Sorter</i>}

main.cpp: In function 'int main()':main.cpp:18:9: error: use of function 'void f(T) [with T = asdf]' with unsatisfied constraints18 | f(asdf{}); <i>// Ошибка: asdf не удовлетворяет условиям Sorter</i>|     ^main.cpp:13:6: note: declared here13 | void f(T) {}|   ^main.cpp:13:6: note: constraints not satisfiedmain.cpp: In instantiation of 'void f(T) [with T = asdf]':main.cpp:18:9:  required from heremain.cpp:6:9:  required for the satisfaction of 'Sorter<T>' [with T = asdf]main.cpp:6:18:  in requirements with 'T a' [with _Tp = asdf; T = asdf]main.cpp:7:21: note: the required expression 'std::hash<_Tp>{}(a)' is invalid7 |   { std::hash<T>{}(a) } -> std::convertible_to<std::size_t>|    ~~~~~~~~~~~~~~^~~cc1plus: note: set '-fconcepts-diagnostics-depth=' to at least 2 for more detail

template<typename T>concept Meshable = requires(T a, T b){a + b;};template<typename T>void f(T x){if constexpr(Meshable<T>){ <i>/*...*/</i> }else if constexpr(requires(T a, T b) { a + b; }){ <i>/*...*/</i> }}

Requires-expression

template<typename T>constexpr bool Movable = requires(T i) { i>>1; };bool b1 = Movable<int>; <i>// true</i>bool b2 = Movable<double>; <i>// false</i>Главный сценарий использования <i>requires-expression</i> состоит в создании концепций, просто проверить наличие нужных полей и методов внутри типа.template <typename T>concept Vehicle =requires(T v) { <i>// любая переменная m из концепции Vehicle</i>v.start();   <i>// обязательно должна обладать `v.start()`</i>v.stop();   <i>// и `v.stop()`</i>};

template <typename T>void smart_swap(T& a, T& b){constexpr bool have_element_swap = requires(T a, T b){a.swap(b);};if constexpr (have_element_swap) {a.swap(b);}else {using std::swap;swap(a, b);}}

Requires clause

template<typename T>void f(T&&) requires Eq<T>;template<typename T> requires Dividable<T>T divide(T a, T b) { return a/b; }

template <typename T>requires is_standard_layout_v<T> && is_trivial_v<T>void fun(T v);int main(){std::string s;fun(1); <i>// верно</i>fun(s); <i>// ошибка компиляции</i>}

template<typename T>requires Sumable<T>auto f1(T a, T b) requires Subtractable<T>; <i>// Sumable<T> && Subtractable<T></i>auto l = []<typename T> requires Sumable<T>(T a, T b) requires Subtractable<T>{};template<typename T>requires Sumable<T>class C;template<typename T>requires requires(T a, T b) {a + b;}auto f4(T x);

Модули

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

<i>//module.cpp</i>export module speech;export const char* get_phrase() {return Hello, world!;}<i>//main.cpp</i>import speech;import <iostream>;int main() {std::cout << get_phrase() << '\n';}

Сопрограммы

• оператор co_await для приостановки выполнения до возобновления;

task<> tcp_echo_server() {char data[1024];for (;;) {size_t n = co_await socket.async_read_some(buffer(data));co_await async_write(socket, buffer(data, n));}}

• ключевое слова co_yield для приостановки выполнения, возвращающего значение;

generator<int> iota(int n = 0) {while(true)co_yield n++;}

• ключевое слова co_return для завершения выполнения, возвращающего значение.

lazy<int> f() {co_return 7;}

Оператор KK

#include <set>struct Data{int i;int j;bool operator<(const Data& rhs) const {return i < rhs.i || (i == rhs.i && j < rhs.j);}};int main(){std::set<Data> d;d.insert(Data{ 1,2 });}

#include <set>#include <compare>struct Data{int i;int j;auto operator<=>(const Data& rhs) const = default;};int main(){Data d1{ 1, 4 };Data d2{ 3, 2 };d1 == d2;d1 < d2;d1 <= d2;std::set<Data> d;d.insert(Data{ 1,2 });}

Этим летом на онлайн-конференции C++ Russia побывал самый почетный гость, какой только может быть на мероприятии по C++: создатель этого языка Бьярне Страуструп. Мы поговорили с ним о контроле над языком, нововведениях, удалении старых функций, о том, почему у языка нет четкой экосистемы, и как так получилось, что у С++ нет стандартной сетевой библиотеки.

А поскольку сообщество C++ вечно обсуждает Rust, не обошлось и без вопроса о заимствованиях между этими языками.

Бьярне не нуждается в особых представлениях, но у него столько активностей и заслуг, что попробуем перечислить:
написал множество публикаций, в том числе книги Язык программирования С++ и Программирование: Принципы и практика использования C++
работает управляющим директором в отделе технологий компании Морган Стенли в Нью-Йорке
преподает в Колумбийском университете
принимает активное участие в работе комитета по стандартизации C++
состоит в Национальной академии инженерии США, IEEE, Ассоциации по вычислительной технике. Исследует программирование в области распределенных вычислений, инструменты развития ПО и языки программирования.
Магистр и заслуженный профессор Орхусского университета и доктор по направлению Информатика Кембриджского университета и почетный член научного сообщества Колледжа Черчилля, заслуженный профессор Санкт-Петербургского ИТМО

Вопросы ему задавали С++ программист, организатор С++ Siberia Сергей Платонов и руководитель разработки бэкенда Яндекс.Лавки Сергей Федоров. Под катом перевод, а также видеозапись интервью для тех, кто хочет послушать на английском.

Об истории

Сергей Платонов: Спасибо, что присоединились к нам. Говорить с вами большая честь. У нас есть несколько вопросов от сообщества, но хотелось бы начать с тех, что проще и короче. Начнем с истории, поскольку об этом часто спрашивают. В первую очередь хотелось бы сказать, что вы самый упоминаемый спикер. Каждый раз, когда мы спрашиваем у зрителей, кого следует пригласить на конференцию, первым называют ваше имя. Зрителям хотелось бы поучаствовать в обсуждениях, в живом общении. Не могли бы вы в паре предложений рассказать, как вы стали создателем C++? С чего все началось? Мне кажется, все читали Дизайн и эволюцию, но если возможно, хотелось бы услышать ее укороченную версию.

Бьярне: Я пришел к C++, когда захотел создать систему для Bell Labs, которая бы стала первым UNIX-кластером. Это была бы система для распределенных вычислений, объединенная в общую сеть из нескольких компьютеров. Мне предстояло написать код, который бы работал на нижнем уровне, на уровне железа: диспетчеры памяти, планировщики процессов, сетевые интерфейсы и все в таком духе. И при этом нужно было уйти от железа. Мне нужно было перейти на высший уровень, чтобы заставить один код взаимодействовать с другим, используя определенный протокол передачи данных определенным образом.

Итак, мне нужен был язык программирования, который бы работал и на низшем, и на высшем уровне. В то время было как минимум с десяток языков, которые справлялись с задачами низшего уровня, C был одним из них. Лаборатория Денниса Ритчи и Брайана Кернигана находилась в одном коридоре с моей, поэтому дальнейшие действия казались очевидными, но на тот момент я подумал, что этот язык работал со слишком низким уровнем. Мне были нужны механизмы абстракции. У меня был опыт работы с Симулой, о которой я узнал от Кристена Нюгора. И я взял классы из Симулы, перенес их в C, сделав его достаточно эффективным для программирования сложных систем. На второй неделе работы над проектом я добавил конструкторы и деструкторы. Тогда они были нужны, в том числе для управления ресурсами. Затем я добавил то, что сейчас называется прототипами функций и проверку аргументов функции.

Основой C++ стала его возможность эффективной абстракции, ядром которой являются статическая проверка типов, конструкторы и деструкторы, что в совокупности позже начало именоваться как RAII (Resource Acquisition Is Initialization, получение ресурса есть инициализация). В 80-е у меня было совсем мало времени на изобретение хороших названий для хороших технологий, лучше, чем RAII, я ничего не придумал, так что уж имеем то, что имеем.

Контроль над языком

Сергей П.: Вы не помните тот момент, когда C++ ушел из-под вашего контроля в руки сообщества?

Бьярне: У меня, на самом деле, не было никогда контроля над языком в полном смысле слова. Как только языком начинают пользоваться, у его создателя появляются свои обязанности. Нужно отвечать на запросы пользователей. В моем случае это случилось спустя шесть месяцев после запуска проекта. Появился пользователь, и я потерял возможность выносить единоличные решения. Я не мог решиться пойти на то, чтобы все сломать.

Потом, где-то спустя 10 лет, люди из IBM и Sun, а также представители HP пришли ко мне в офис и сказали: Знаешь, Бьярне, надо сделать так, чтобы C++ соответствовал нормам ISO. Я тогда объяснил, что это невозможно. Было слишком рано, я не был готов. После часового разговора я согласился, так как выбора у нас не было. Они объявили, что не могут позволить своим компаниям зависеть от чего-то, что зависит от их потенциального конкурента, например, AT&T. Помню, они сказали: Мы, конечно, тебе доверяем, но скорее всего мы назначим тебе начальника. И тогда мы начали стандартизацию.

В целом, процесс стандартизации очень непрост и сильно раздражает. Многие стороны со своими потребностями должны прийти к единому мнению относительно вещей, на которые у всех разные взгляды. Спустя годы мне кажется, мы все сделали совсем недурно. Сегодня у нас есть проблемы посерьезнее. Тогда собиралось 60 человек, все друг друга знали, было доверие. Сейчас у нас 230240 человек, мы не можем хорошо узнать друг друга. Работа сейчас строится иначе, и она стала труднее. И, конечно же, в этом году нам приходится связываться через Интернет, потому что собрания запрещены. Пройди встреча комитета по C++ в течение недели в одном небольшом помещении, мы бы точно потеряли часть людей языку это бы не пошло на руку.

Работа в комитете

Сергей Федоров: Не могли бы вы рассказать, какую позицию в комитете занимаете на данный момент?

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

Вы, возможно, видели мои выступления, где я рассказывал о Вазе шведском боевом корабле, построенном в 20-е годы XVII века.
Его строили по указу короля, согласно которому новый корабль должен был стать самым красивым и самым мощным морским орудием в португальской зоне. Затея была хороша. Ему дали название в честь королевской династии Ваза. Строители было приступили к работе, однако вскоре заметили, что потенциальный враг начал строительство боевых кораблей большего размера с двумя орудийными палубами вместо одной, что на тот момент было инновацией. Тогда все поняли, что дело идет к большому позору, поскольку если в морском бою сойдутся два корабля однопалубный и двухпалубный, первый быстро пойдет ко дну. Тогда король сказал, что нужен двухпалубный корабль. Королю был нужен самый большой, самый мощный корабль, который также мог бы использоваться как средство дипломатии. Оценив план строительства, все поняли, что нужен был корабль большего размера, а для пущего размаха на него должны были установить статуи. Тогда у главного инженера начались проблемы. По слухам, он покончил жизнь самоубийством после постройки корабля или немного времени спустя. Королю сказали, что нужно больше времени на переработку основы конструкции. Король не согласился. В принципе, это похоже на ситуацию, когда управляющий высокого ранга не видит всех нюансов, проявляющихся где-то на нижнем уровне, где трудятся простые рабочие.

Итак, корабль следовало построить к сроку. Они успели. После создания чего-либо необходимо это что-либо испытать. Боевые корабли проходили испытания по следующему принципу: команда корабля в полном составе встает у одного борта. Затем по команде бежит к другому борту, добежав, разворачивается и бежит обратно. И так 14 раз. Если корабль не переворачивается, значит, он прошел испытания. Команде удалось сделать 7 пробегов, а затем испытание остановили из страха, что он опрокинется. Собственно, испытания провели не полностью, сэкономив на этом. Очень зря. Как бы там ни было, в день спуска на воду ничего не предвещало беды: развевающиеся флаги, духовой оркестр, прекрасные статуи, гром холостых выстрелов. Корабль проходит через бухту в Стокгольме, которая является серединой маршрута. Но вдруг порыв ветра переворачивает корабль, который в итоге идет ко дну. Спустя 350 лет его достали со дна и разместили в красивом музее в Стокгольме. Если когда-нибудь будете в этом городе, обязательно посмотрите на корабль Ваза. Он очень красив и выглядит впечатляюще.

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

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

Нововведения

Сергей Ф.: К слову о красивых новых пушках, в новых стандартах C++ присутствуют функции, которые вас особенно раздражают?

Бьярне: Да нет. Мне кажется, C++20 будет отличным стандартом, мы наконец-то воплотили в жизнь концепции. Я бы хотел внедрить их еще в 19861988 годах, когда я создал шаблоны, но не знал, как это сделать. Мы попытались в стандарте C++11, но у нас не получилось все сделать как надо. Я надеялся, что к стандарту С++17 все будет готово, поскольку у нас появилось необходимое понимание, но в итоге, они появятся лишь в С++20. У нас наконец-то появится нормальное обобщенное программирование. Благодаря этому выражения станут четче, проще, и все будет работать намного быстрее. Добавьте к этому constexpr, и вы получите сильно упрощенное обобщенное программирование и сильно ускоренное метапрограммирование во время компиляции.

Другое нововведение, которым я очень доволен, это сопрограммы. Сопрограммы были в основе C++ в первые 10 лет. Я тогда писал симуляции и то, что сегодня называют многопоточными программами, с помощью сопрограмм. Мои симуляции были меньше и быстрее любых аналогов. А также они были меньше и быстрее потоков. Здорово, что мы вернули сопрограммы. Мы когда-то ушли от них потому, что компания Sun не хотела внедрять их в архитектуру Spark, поскольку очевидная реализация управляет стековыми фреймами. Сегодня же мы имеем более быстрые сопрограммы.

И теперь перейдем к последней функции, которая, скорее всего, будет играть важнейшую роль в долгосрочной перспективе. Это модули. По сути, это относится к организации программы, а не к написанию кода. Если вернуться во времена Windows DNA, я помню, как я мечтал о нормальном методе разнесения программ по частям. Нам приходилось пользоваться заголовочными файлами. Тогда в 80-е и 90-е мы знали, как лучше. Введение новых возможностей в язык с несколькими сотнями миллиардов строчек кода не так просто, но мы сделаем это. Итак, модули. Они значительно повысят скорость компиляции. Я видел, как скорость возрастает в 50 раз, если сравнивать с методом использования заголовочных файлов. Надеюсь, что большинство программ ускорится, скажем, в семь раз. И, наконец, мы нашли способ предотвратить распространение макросов по всей системе. Вы помещаете макрос в заголовочный файл, кто-то затем включает ваш заголовочный файл в свой файл, затем этот файл включается в следующий файл, и так ваш макрос присутствует в конечном файле, создатель которого даже не знает о существовании вашего заголовочного файла, из которого появился макрос. С появлением модулей эта проблема уйдет. Теперь код чище, и именно благодаря этому повышается скорость компиляции. Думаю, эти три функции самые важные, они будут в значительной мере влиять на написание кода в следующие десять лет.

Есть небольшая проблема отсутствия поддержки стандартной библиотеки. Сегодня не существует одного стандартного набора модулей, кроме того, сопрограммы не поддерживаются библиотеками в полной мере. В стандартной библиотеке есть некоторые концепции, поэтому, я считаю, у нас все будет хорошо. Надеюсь, в стандарт С++23 будут включены все новые возможности. Трудно обеспечить библиотеками то, что пока не внедрено. Мы решили, что сначала введем новые функции в язык, чтобы опробовать их в деле в разных масштабах. Нам нужны программы с миллионами строчек кода в них новые возможности будут использоваться в полной мере. Затем, набравшись опыта, мы доработаем их в стандарте С++23, и их использование станет проще и, наверное, быстрее.

Удаление старых функций

Сергей П.: Что насчет функций, которые не используются в языке программирования? Вам не кажется, что некоторые из них можно было бы удалить? И поскольку у нас есть трехсекундная задержка, я позволю себе перефразировать вопрос. У комитета есть какие-то возможности по удалению старых функций из языка? Я спрашиваю потому, что язык становится все объемнее, а следовательно, труднее для изучения. Людям все труднее поспевать за появляющимися нововведениями.

Бьярне: Этот вопрос касается большого и сложного дела. Не думаю, что в C++ есть какая-либо основополагающая функция, которую мы могли бы удалить, не разозлив несколько сотен тысяч или даже миллион пользователей. Такого не должно произойти. Если посмотреть на этот вопрос философски, я могу сказать, что основные функции языка хороши, другое дело мелкие детали. Но с этим мы ничего поделать не можем. Мы разрабатываем язык, смотрим на то, как он функционирует, опираясь на отзывы. Однако, как бы то ни было, когда мы вводим что-то масштабное, убрать это нововведение не так просто. Несколько раз мы пытались удалить старые возможности, и каждый раз у нас не получалось. В рамках стандарта ISO мы можем сократить функционал языка с помощью так называемой депрекации, объявляя функции устаревшими. Мы объявляем пользователям, что одна из функций языка больше не будет использоваться и мы удалим ее через 3510 лет. Этот подход не работает с основополагающими функциями.

В течение десятилетия нам никак не удавалось убрать триграфы. Сейчас мы от них избавились, при этом большинство даже никогда не слышало о триграфах. Оказалось, что каждая машина в IBM не может запуститься без триграфов. Убрать триграфы языка убить IBM. Такого не должно произойти, да и в IBM любят цепляться за старые фишки. И снова нам приходится сообщать о том, что мы удаляем возможности, что ими не стоит пользоваться. Нам было очень сложно избавиться от правила implicit int, хотя в C++ его никогда и не было, оно пошло от C.

Все мечтают избавиться от тех вещей, которые им не нравятся, от всего устаревшего и прочего. Но договориться о том, что устарело, что не нужно, никто не может. Получается, что не существует согласия между 4,5 млн программистов, пишущих на C++. Более того, его никогда и не будет. Добавьте к вышесказанному и то, что после удаления функции из языка, поставщики компиляторов будут вынуждены поддерживать ее еще лет 2030. В общем, что-то убрать почти невозможно. Даже если мы придем к согласию, все равно удаление не пройдет легко.
Сегодня мы не можем поменять или убрать основополагающие функции, при этом тратить время на удаление каких-то мелких функций кажется совсем смешным. Так как же заставить людей двигаться дальше? Во-первых, обучить их писать на современном C++. Сегодня все еще много тех, кто начинает изучать C и загоняет себя в ловушку бессмысленного распределения памяти, вместо того, чтобы обратить внимание на векторы, RAII и прочее. Во-вторых, нам нужно поддерживать современный подход к программированию, который проще и благодаря которому создаются более быстрые и менее объемные коды. Когда кто-то начинает писать операции над строками в стиле из C, он обычно получает баги и медленный код. Эксперты справляются лучше, но у экспертов, как правило, есть дела поважнее.

Я работаю с друзьями над C++ Core Guidelines. Если им следовать, можно сказать, набору правил, а не беспорядочно использовать все функции языка, ваш код будет лучше и вы пойдете спать раньше. Да, это правила. Нам всем не нравятся правила, их трудно запомнить, поэтому для них нужна поддержка. Правила отчасти зависят от стандартной библиотеки и от 10 небольших компонентов из GSL (guidelines support library), которые мы хотим перенести в стандарты, чтобы избавиться от необходимости в GSL.

Например, мы добавили span в стандарт C++20. Span это простая абстракция, по сути, указатель плюс размер. Если нужна ссылка на непрерывный набор элементов, используете span, который знает расположение элементов и их количество, поэтому вы можете задать диапазон и, при желании, произвести проверку диапазона. При этом у вас нулевой шанс ошибиться.
Предположим, у нас есть массив, мы берем span, присваиваем ему значение массива. Span обратится к массиву, поймет, какие в него входят элементы, они получат тип span-а. Далее он узнает количество элементов в массиве, возьмет этот размер. Все, вы получаете правильную абстракцию непрерывной последовательности битов, как с объектами, и это вам необходимо для коммуникационных программ и прочих низкоуровневых дел. Деннис Ритчи хотел сделать что-то похожее в C, но ему сказали, что ничего не выйдет. Это все не ново, но полезно. Это одна из мелочей, которая реально помогает в работе.

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

А при включении другой статической проверки, первая будет предотвращать переполнение буфера. Например, при использовании указателей вы рано или поздно придете к переполненному буферу. При использовании общих указателей рано или поздно дело придет к висячему указателю. Например, согласно нашим правилам, вы должны использовать span вместо указателя. Используете RAII, затем включаете проверку (сейчас она развертывается в Visual Studio, поэтому то, чем я говорю, реальность) и избавляете себя от всех проблем с памятью. Проверка обнаружит все проблемы.

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

Об экосистеме

Сергей Ф.: Почему, по вашему мнению, у С++ нет четкой экосистемы?

Бьярне: Потому что у языка нет законного владельца. Нет одной компании, которая бы все контролировала. Каждый создает что-то свое. Мы начинали вообще без финансирования, если говорить об исследовательских проектах в Bell Labs. Я самостоятельно делал 98% работы по первому коммерческому запуску языка: составлял документацию, учебные библиотеки и прочее. Наш рекламный бюджет тогда был 5000 долларов на три года, и тогда я вернул 1000, потому что не знал, как правильно распорядиться средствами.

Многие не понимают, что у C++ никогда не было бюджета. Вместо денег было сообщество, причем не одно сообщество, а множество. Проблема состоит не в отсутствии графического интерфейса, а в том, что их 25. Проблема не в том, что у нас нет системы сборки, а в том, что их 7. Это я еще преуменьшаю. Люди не могут прийти к единому мнению. Все принадлежат к разным сообществам. Все хотят делать по-своему, никто не хочет слияний. Некоторые проблемы лежат в коммерческой плоскости, некоторые части имеют открытый код, аспекты вызывают проблемы из-за большого самомнения некоторых лиц. В итоге у нас демократический хаос, и я не знаю, как его прекратить.
Возможно, если бы я обладал лучшими навыками организации, мы могли бы еще что-то сделать, когда это было возможно, а возможно это было в 80-е. Правда, в 80-е и особенно в 90-е все хотели создать свое сообщество, организованное вокруг своего решения и своего подхода. Тогда в игре были Microsoft, IBM и еще пара-тройка серьезных компаний. Все пытались создать что-то вне конкуренции, чтобы заполучить побольше пользователей. Компании тогда приходили к решениям, которые были несовместимы с решениями конкурентов, чтобы потребители вдруг не ушли к последним. У нас же было наибольшее количество инструментов, и в большинстве случаев, это не является преимуществом. Как определиться с системой сборки? Как определиться с графическим интерфейсом? Сложно. Подумайте, каково было новичку.

Сергей П.: У нас нет простой системы сборки, которая будет без проблем работать в любой системе.

Бьярне: Нет-нет, мы можем предложить вам как минимум три, которые плюс-минус подходят под ваши критерии.

О рейтингах и популярности языка

Сергей П.: Вам важно то, какое место C++ занимает в рейтингах? Следите ли вы за популярностью языка, за какой-либо статистикой? У нас на конференции будет отдельный разговор о C++ и его месте в мире.

Бьярне: Не думаю, что до конца понял вопрос. Попытаюсь ответить на него и, если я уйду не в ту сторону, поправьте меня. Я стараюсь сосредоточить внимание на самом языке и стандартной библиотеке. Я не лучший собеседник по темам вселенной C++, плеяды доступных инструментов, рекламных аспектов или открытого кода. Слишком много информации для одного человека. И я не обращал внимания на статистику. Ее очень сложно получить. Сложно считать пользователей.
Хорошо, что кто-то этим занимается. Проводятся опросы, часть информации доходит и до меня. Поэтому-то я и оперирую цифрой в 4,55 миллионов разработчиков C++. Но кто такой разработчик? Кто такой программист? Учитывать ли студентов? А всех студентов или только очников? Все эти цифры очень условны, но я, как по мне, опираюсь на самые скромные подсчеты. Я бы мог назвать и число побольше, но не собираюсь, поскольку тогда мы будем учитывать тех, кто пользуется C++ не постоянно, а это не лучший способ подсчета.

Можно спросить у тех, кто может сказать, сколько у них пользователей потому, что они как минимум могут подсчитать количество заплативших за продукт или число скачиваний, что, в целом, тоже не лучший метод подсчета. Я раньше руководствовался такой логикой: если люди не жалуются, значит, они не пользуются C++. Конечно, у нее есть свои минусы. Это я тоже знал. Компания AT&T решила провести опрос пользователей об их опыте, поскольку была необходимость следить за распространением языка, хотя он и был бесплатным. Они обнаружили, что 4 из 5 разработчиков используют C++. Это расходилось с моими подсчетами, в которых я не учитывал тех, кто не жаловался. В общем, считать проблематично.

Сетевая библиотека

Сергей Ф.: Вы говорили, что начали разрабатывать C++, когда вам понадобилось средство, чтобы преодолеть сложность организации сетевой системы. Как же так получилось, что у C++ нет стандартной сетевой библиотеки?

Бьярне: Опять же, проблема не в том, что нет сетевой библиотеки. У нас нет стандарта. С середины 80-х появлялось много библиотек. Сегодня многие пользуются библиотекой Asio, которую технически можно назвать стандартной. Думаю, что в C++23 мы добавим её. Но начинаются разговоры, что нужно больше поддержки. Помимо Asio, нужно добавить то, чего не дает Asio. И это обыденный хаос в мире C++. У нас даже нет стандарта для места хранения библиотек. Никто как следует не позаботился о создании хорошего сообщества C++. Даже удивительно, как этот язык пережил десятилетия конкуренции. Я написал статью о последних 15 годах развития C++ для конференции по истории языков программирования. Эта статья стала доступна буквально две недели назад на сайте Ассоциации по вычислительной технике. Поищите его там. Или можете пройти на мою страничку и найти ее в разделе со статьями. В статье я объясняю все события, произошедшие за последние 15 лет. Она называется Thriving in a Crowded and Changing World. В ней описываются последние 15 лет развития C++, работа над стандартами 11, 14, 17 и 20, а также некоторые проблемы сообщества. На большую часть заданных сегодня вопросов можно найти более глубокие ответы именно в статье. Сейчас я не могу отвечать в той же степени пространно. В интервью все рассуждения так или иначе абстрактны, нет возможности подтвердить слова документацией, но большая часть сказанного мною встретится вам в названной статье, оцененной другими учеными. Она не короткая. В ней 168 страниц, 30 из которых занимает список источников. На ее прочтение стоит выделить выходные.

О заимствовании фишек

Сергей П.: Как вы думаете, Rust оказывает влияние на C++ или, может быть, начнет в обозримом будущем? Может ли случиться так, что C++ позаимствует некоторые функции Rust?

Бьярне: По-моему, это скорее Rust заимствует фишки C++, а его разработчики забывают об этом рассказать. RAII был в C++ на протяжении 40 лет. Меня иногда обвиняют в том, что я своровал эту концепцию. Сообщество, конечно, не сильно опирается на академические труды или историю. То же самое и с линейной логикой и семантикой владения, над которыми я работал на протяжении 20 лет. Это фундаментальные вещи, описанные в ключевых рекомендациях. Там же описано и то, что я задумывался об этих вещах еще с середины нулевых. Думаю, мы лучше, чем Rust, просто люди этого не понимают. Я не видел в этом языке ни одной функции, которую я бы очень хотел добавить в C++. Некоторые вещи нельзя просто включить в язык. Ключевые рекомендации могут как-то показать схожесть языка с Rust, но они были написаны задолго до него. Я знаю историю Rust и проблемы заимствования (borrowing), но это слишком сложная тема.
Я экспериментировал с этим в середине нулевых, и в результате экспериментов, код превращался во что-то страшное, слишком много всего приходилось обходить. Кроме того, С++ соотносится с C, что накладывает некоторые ограничения на совместимость, от этого заимствовать только сложнее.

Я обращаю внимание на любой появляющийся язык программирования, ладно, не на любой их слишком много. Я обращаю внимание на языки программирования с интересными фишками. Если какая-то функция мне нравится и ее можно добавить в C++, я сделаю это и дам ссылку на источник. Люди могут сказать, что это кража идеи; на самом деле, нет, ведь ты сообщаешь, у кого ты ее позаимствовал. Rust не особо привлекателен для заимствований. При этом уже поступают предложения ввести в Rust что-то вроде механизмов для объявления функций устаревшими. Как по мне, это говорит о том, что они еще не пробовали удалять ненужные функции. Да и зачем? Язык еще слишком молод. Они и не могли попробовать удалить что-то устаревшее. А со временем язык будет шириться, и это сильно осложнит задачу. Со временем появляются пользователи и достаточное количество строчек кода. Кстати, был опрос, в котором у людей спросили, на чем им больше всего нравится писать программы. Rust выиграл с отрывом. При этом, из тех, кто отдает предпочтение Rust, лишь три процента написали программу на этом языке. Я тогда удивился. Это же абсурд, какого не ожидаешь.

Сергей П.: Какой язык, кроме C++, вам нравится? Может быть, приходит в голову какой-нибудь редкий язык? Или может быть, вы расскажете об идеях, воплощение которых в другом языке вам пришлось по душе?

Бьярне: Я стараюсь избегать сравнений языков программирования. Не хочу много говорить об этом. У нас есть планы на C++23: мы хотим завершить работу над поддержкой модулей, сопрограмм и еще поработать над концепциями. Если мы все сделаем, то сможем заняться вещами на будущее. Мы, очевидно, позаимствуем из другого языка сопоставление образцов из функционального программирования. Мне нравится эта возможность, я предлагал ее добавить еще в 2015 в C++17. Мы пока собрали рабочую группу, работаем над этим. Возможно, эта возможность появится в C++23. Благодаря этой функции ускорится проверка типов и появится код курсора. Такая версия C++ будет работать и с алгебраическими типами и открытыми иерархиями, и это станет альтернативой dynamic_castу. Очевидно, что все эти идеи пришли к нам так или иначе из ML.

Еще одна важная вещь, на которую мы обратили внимание, но вряд ли сможем сделать к C++23 статическая рефлексия. Рефлексия отличная штука, которая, к сожалению, очень медленно работает, является очевидной слабостью системы типов и порождает ошибки. Мы уже работали над статической рефлексией. Суть её работы заключается в том, что код узнает от компилятора информацию о программе и на ее основе создает новый код. Тогда бы можно было сказать: дайте несколько программ для чтения и записи файлов формата JSON определенных типов. Когда этот процесс завершится во время компиляции, будет сгенерирована точная поддержка среды для определенного приложения. Сравните это с представлением вашей программы в виде графа, в случае если у кого-то появится необходимость в нем. Все предложения по нововведениям можно найти на сайте WG21. WG21 это официальное название от ISO для рабочей группы. Все предложения и статьи от 1990 года выгружаются на сайт группы.

Виртуальные функции

Сергей Ф.: Благодарю. Я большой поклонник статической типизации. Что вы думаете о виртуальных концептах или добавлении любого другого type erasure механизма?

Бьярне: Я не могу сказать, что готов ответить на этот вопрос. Я был соавтором статьи о виртуальных концептах, написанной в середине нулевых, но не думаю, что они могут сыграть ключевую роль в развитии C++. И я не большой поклонник type erasure. У нас есть виртуальные функции, некоторые считают их type erasure механизмом. И я думаю, этого достаточно. Наверное, отчасти я говорю так потому, что мы не можем воспринимать сообщество программистов как единое целое. Существует множество сообществ со своими потребностями. Конечно, гибкий и простой код хотели бы многие, но если есть нужда, например, запрограммировать тормозную систему автомобиля или органы управления самолетом или электростанцией, я бы доверил эту работу программистам, работающим рука об руку с инженерами с серьезной подготовкой и инструментами, которые настроены специально под решение их задач и предлагают производительность и надежность высшего уровня. Если речь идет о программировании обработки сигнала для описанных выше технических решений, на первое место встают производительность и надежность. Мне кажется, что 1520% участников Core Working Group (NB: подгруппа Комитета Стандартизации, занимающаяся ключевыми вопросами развития языка) принадлежат к миру высокой производительности и безотказной надежности, то есть такому, которому отлично подходит C++.

Нам не нужно пытаться сделать из C++ конкурента Python, чтобы завлечь людей, не являющихся профессиональными программистами, но являющиеся экспертами в других областях. Если же нужно добиться скорости и надежности, лучше заменить Python на C++. То же самое действует и в обратном порядке: хотите экспериментировать с C++ не ослабляйте систему типов и не ослабляйте внимание при написании выражений. Я не буду делать со своим кодом все, что мог бы с ним сделать, не зная наверняка, что мне нужно. Мне кажется, C++ не создан для 8085% программистов. Всегда стоит помнить об изначальной задумке создания языка: этот язык распределенная система с прямым доступом к железу и немного повышенным уровнем сложности. Если смотреть на вещи в таком ключе, то любая вещь, нацеленная на то, на что нацелен C++, должна обладать высокой надежностью.

Этот мир сильно отличается от того, в котором существует разработчик приложений. JavaScript хорош в решении тех задач, для которых был создан, а у меня есть правило: не говорить ничего плохого о приложениях, взявших свое начало от C++ как, например, движки JavaScript. Это два разных мира, но иногда они пересекаются. Зачастую С++ ложится в основу и дальше дополняется чем-нибудь еще.

О планах по изменению языка

Сергей П.: Есть ли планы по улучшению целостности языка ценой удаления совместимости с си? Например, можно ли избавиться от препроцессора, чтобы сделать C++ прекрасным?

Бьярне: Основная стратегия и, по-моему, единственная рабочая предоставить превосходящую альтернативу и надеяться, что устаревшие функции потеряют актуальность. Старые функции нельзя удалить из языка, но их можно удалить из собственного кода. Они могут быть, так скажем, перемещены в запас. Вы можете однажды предложить друзьям или поставщикам перестать пользоваться этими функциями, или пусть они инкапсулируют их. Модули инкапсулируют все старье. В модуле у вас может быть программа, замусоренная макросами и файлами включения. Мне, в общем-то, нет никакого дела до этих файлов включения или макросов, если я не вижу их у себя в коде. Так что эта идея очень важна. По-моему, это единственный способ двигаться вперед. То же можно проделать и с отдельными функциями. Мне, например, не нравятся приведения (casts), я редко ими пользуюсь и, если мне нужно использовать их где-то ближе к уровню железа, на программном уровне я инкапсулирую их во что-то, что использует правильные типы и следует правилам.

Сергей Ф.: Не могли бы вы рассказать, почему бы в C++ не сделать семантику перемещения деструктивной?

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

Сергей П.: Люди пишут, что компилятор C++ стал очень сложным. Могли бы вы дать совет, как изучать современные компиляторы, как понимать теорию и где набраться практического опыта? Компиляторы становятся все больше.

Бьярне: Компиляторы объемны и сложны. Мне кажется, сегодня все пытаются улучшить свои компиляторы, ничего при этом не сломав, как это обычно бывает. В данный момент и в Microsoft, и в GCC идет работа по модернизации промежуточного представления. Толчком к этому стали модули, которые должны быть представлены и представлены хорошо. Если проделать эту работу на совесть и представлять модули в виде минимального типизированного промежуточного представления, их работа станет намного быстрее. Если же представить это в виде множества битов, придется перекомпилировать это множество при каждом использовании модулей, что сводит на нет все их плюсы. Да, биты инкапсулированы, но они все еще не дают работать быстро.
Мне кажется всем известно, что GCC и Microsoft улучшают их промежуточные представления. Я знаю, что в Microsoft над этим работает мой старый друг, Гэбриэль Дос Рейс. Когда мы были еще профессорами в Техасе, около 10 лет назад, мы создали представление для C++, которое имело минимальный размер и требовало минимума взаимодействий. Мы дали ему название IPR. Это представление и легло в основу внедрения модулей в Microsoft. По-моему, оно становится все популярнее. Оно в разы меньше и быстрее любой альтернативы. Однако чтобы оно работало с существующими компиляторами, придется добавить кое-какие функции, отсутствующие в минималистичном дизайне этого представления, например отладочную информацию.

Я снова отправлю вас на свой сайт, чтобы вы поискали на нем статью, которая называется A Principled, Complete, and Efficient Representation of C++. Название IPR, как вы могли догадаться, придумал я в свойственной мне креативной манере, полностью оно звучит так: Internal Program Representation. Мне не нравится, когда его называют AST (Abstract Syntax Tree) потому, что это не синтаксис, не абстрактный и не древо. Но люди все называют это таким образом.

О неопределенном поведении

Сергей Ф.: C++ знаменит своим неопределенным поведением. Есть ли у комитета по стандартизации C++ стратегия, которая позволила бы снизить количество случаев неопределенного поведения?

Бьярне: Многие забывают, что не все случаи неопределенного поведения нежелательны. Вы можете потребовать определенного поведения, которое ошибочно. Например, неопределенное поведение возникает при переполнении целочисленных типов. Вы можете исправить это, используя беззнаковые числа, они используют модульную арифметику, значит, то что было переполнением просто вернёт вас к нулю. Вы получите runtime ошибку вместо неопределенного поведения, которое может быть обнаружено компилятором и другими инструментами. Существует группа, которая занимается неопределенным поведением. Фактически, они работают над тем, чтобы хорошо определить неопределенное поведение: чтобы мы знали, что такое неопределенное поведение и почему оно таковым становится. Мы пытаемся избавиться от всего, что не должно быть неопределенным поведением, поскольку, по-моему, такая проблема есть. Например, лучше иметь определенный порядок вычисления для любого выражения. Некоторые разработчики компиляторов утверждали, что неопределенный порядок давал более быстрый код. Это было неправдой, так что налицо прогресс.

Кстати, Гэбриэль, о котором я упоминал ранее, также работает и над неопределенным поведением. Он стоит во главе рабочей группы, так что да, мы работаем над этим. Просто не стоит верить людям, заявляющим, что любое неопределенное поведение плохо. Альтернативы могут быть много хуже. Наверное, стоит воспринимать неопределенное поведение как нежелательное, но помнить о том, что альтернативы будут хуже.

Списки инициализаторов

Сергей П.: Спрошу о том, что многие хотели бы не видеть в стандарте. Сейчас речь пойдет о новой функции. Во время нескольких конференций C++ Russia мы обсуждали плохую работу списков инициализаторов. Есть ли планы по решению этой проблемы?

Бьярне: Мы пытаемся их немного улучшить. Мне бы хотелось знать больше о том, что люди думают об этих сбоях. Направьте их ко мне, это сильно поможет в работе. Списки инициализаторов работают не совсем так, как я задумывал. Их улучшали, однако, как по мне, улучшения не были улучшениями. Мы постепенно делали их менее склонными к выдаче ошибок, более мощными, более полезными. Думаю, мы продолжим работу в этом направлении. Если у кого-то есть реальные примеры плохой работы, было бы интересно узнать об этом больше: всегда сложно угадывать, что беспокоит людей. Нужно встречаться, обсуждать. Поэтому-то мне и не нравятся видеоконференции. Я не могу поговорить с вами до и после конференции, не могу узнать вашего мнения относительно не оговоренных проблем, не могу попытаться вам помочь, подкинуть какие-нибудь идеи. Живое общение очень важно, я очень скучаю по возможности встречаться с людьми.

Сергей П.: Мы тоже очень хотим проводить живые встречи.

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

Сергей П.: У рабочей группы в России есть сайт stdcpp.ru, который также является форумом, где можно обсудить свою проблему с другими участниками и проголосовать за то, чтобы ее обсудили позже в комитете. У нас в рабочей группе-21 три участника представляют вашу проблему. Если она наберет популярность, они могут помочь вам с подготовкой статьи. Такое уже случалось. В комитете уже прорабатывали предложения от сообщества, например, wide_int, которое поступило через сайт. Кстати, эту идею предложил студент, а не профессиональный разработчик. Позже он стал соавтором статьи. Сейчас этот вопрос обсуждается. Мы активно просим всех участвовать в работе, которая обычно доступна для публичного просмотра. Более того, мы организуем встречи в Москве и приглашаем принять в них участие.

Бьярне: Это великолепно. Однако, я бы хотел попросить вас напоминать людям, что большинство языков программирования умерли. У нас было как минимум 10 000 языков, которые полностью удовлетворяли своих создателей. Они в итоге исчезли. Успех языка программирования не равен победе в конкурсе популярности. Нужно думать о большем сообществе. Нужно понимать, что с вашей проблемой столкнулись и программисты в Калифорнии, Ухани, Бангалоре и других местах. Ваша проблема может быть такой же проблемой и в других сферах применения языка. Более того, многие пишут на C и C++ потому, что это старые языки. Код, написанный 10 лет назад, все еще исполняется. Это дает людям уверенность, что код, который они пишут сегодня, будет исполняться через 10 лет. Многие пользователи, большие компании думают о выживании своего кода. Поэтому я делаю акцент на совместимости. Мы не можем прийти к улучшениям ценой нарушения совместимости. Миллионы сегодня хотят и новых фишек, и избавления от старья, и чтобы код работал.

Инструменты Бьярне

Сергей Ф.: Справедливо. Какими инструментами вы обычно пользуетесь? Вы пишете программы?

Бьярне: Пишу программы каждый день. У меня есть два набора инструментов. У меня два экрана. Один от компьютера на Linux, иногда я пользуюсь кластером Linux, там GCC, система сборки и прочее. Второй компьютер на Windows, там у меня Visual Studio и остальная мелочь. Я говорю мелочь, но компьютеры не маленькие в последнем установлен i7. Я еще пользовался Mac, но мне никак не удавалось продуктивно работать с тремя разными системами, поэтому остался с двумя. Как по мне, пользоваться одной системой очень опасно для программиста и особенно дизайнера языка. Вам кажется, что эти инструменты отличный выбор, с ними все в порядке и все должны ими пользоваться. Опасный подход.

Сергей Ф.: Если у вас есть кластер на Linux, почему вы не используете систему непрерывной интеграции, чтобы пользоваться разными наборами инструментов?

Бьярне: Может, я и использую, это корпоративные машины. Кстати, компьютер на Windows может взаимодействовать с миром без каких-либо проблем с безопасностью. Я работаю в банке. Многие хотели бы взломать банк, в конце концов, там лежат деньги, поэтому о безопасности нужно думать. Если же мне взломают персональный компьютер, я расстроюсь, но миру это не нанесет серьезного ущерба.

Есть еще одна машина, на которой я могу запустить любую систему, могу загружать в нее. На ней запускается компилятор от Microsoft, Clang и GCC. Ладно, не буду продолжать. Хотелось бы еще машину на Intel и еще парочку, но поддерживать их в работе все равно что устроиться на полную ставку. У меня помимо этого есть работа, преподавание и C++.

Сергей П.: Вопрос, наверное, заключался немного в другом. Пользуетесь ли вы, например, AddressSanitizer, статическим анализатором и остальными инструментами? Как разработчик ПО, пользуетесь ли вы отладчиком? Проводите ли вы отладку своего ПО? Используете ли вы GDB или аналог, или Godbolt?

Бьярне: Да, я часто использую Godbolt. Еще я использую статический анализатор от Microsoft. Он работает по Core Guidelines, я не использую clang-tidy, поскольку не рассчитан на работу в области моих интересов. Отладчиками я пользуюсь нечасто. Есть cppreference, этого достаточно.

Последние проекты

Сергей П.: Если не секрет, не могли бы вы рассказать, над чем вы работаете в последние 23 года?

Бьярне: Моя работа видна по моим предложениям, вносимым в комитет по стандартизации я сильно занят подготовкой C++20. Вся работа излагается довольно подробно. Модули, сопрограммы, концепции. Также я работал с заказчиками, но там не сложилось. Кроме того, я писал статьи об истории развития языка в последние 15 лет, о направлении его развития. Также я постоянно работаю над ключевыми рекомендациями. Участвую во встречах с представителями Microsoft, Facebook, Red Hat.

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

Уже совсем скоро, 11-14 ноября, в онлайне пройдёт новая C++ Russia. В её программе тоже есть два интервью: с Мэттом Годболтом (вы же наверняка пользуетесь golbolt.org?) и с Тайтусом Уинтерсом (о том, стоит сломать обратную совместимость C++ во имя производительности). А кроме интервью, будут доклады на самые разные темы: современный CMake, SIMD-инструкции, лямбды В общем, если это интервью было вам интересным на новой конференции наверняка тоже найдёте много интересного.

1. HW_USART аппаратный уровень, зависит от платформы
2. MW_USART средний уровень, служит для развязки первого и третьего уровней
3. APP_ESP8266 уровень приложения, ничего не знает о МК

HW_USART

bool usart2_init(uint32_t baud_rate){  bool res = false;    /*-------------GPIOA Enable, PA2-TX/PA3-RX ------------*/  BIT_BAND_PER(RCC->AHB1ENR, RCC_AHB1ENR_GPIOAEN) = true;    /*----------GPIOA set-------------*/  GPIOA->MODER |= (GPIO_MODER_MODER2_1 | GPIO_MODER_MODER3_1);  GPIOA->OSPEEDR |= (GPIO_OSPEEDER_OSPEEDR2 | GPIO_OSPEEDER_OSPEEDR3);  constexpr uint32_t USART_AF_TX = (7 << 8);  constexpr uint32_t USART_AF_RX = (7 << 12);  GPIOA->AFR[0] |= (USART_AF_TX | USART_AF_RX);            /*!---------------USART2 Enable------------>!*/  BIT_BAND_PER(RCC->APB1ENR, RCC_APB1ENR_USART2EN) = true;    /*-------------USART CONFIG------------*/  USART2->CR3 |= (USART_CR3_DMAT | USART_CR3_DMAR);  USART2->CR1 |= (USART_CR1_TE | USART_CR1_RE | USART_CR1_UE);  USART2->BRR = (24000000UL + (baud_rate >> 1))/baud_rate;      //Current clocking for APB1    /*-------------DMA for USART Enable------------*/     BIT_BAND_PER(RCC->AHB1ENR, RCC_AHB1ENR_DMA1EN) = true;    /*-----------------Transmit DMA--------------------*/  DMA1_Stream6->PAR = reinterpret_cast<uint32_t>(&(USART2->DR));  DMA1_Stream6->M0AR = reinterpret_cast<uint32_t>(&(usart2_buf.tx));  DMA1_Stream6->CR = (DMA_SxCR_CHSEL_2| DMA_SxCR_MBURST_0 | DMA_SxCR_PL | DMA_SxCR_MINC | DMA_SxCR_DIR_0);       /*-----------------Receive DMA--------------------*/  DMA1_Stream5->PAR = reinterpret_cast<uint32_t>(&(USART2->DR));  DMA1_Stream5->M0AR = reinterpret_cast<uint32_t>(&(usart2_buf.rx));  DMA1_Stream5->CR = (DMA_SxCR_CHSEL_2 | DMA_SxCR_MBURST_0 | DMA_SxCR_PL | DMA_SxCR_MINC);    DMA1_Stream5->NDTR = MAX_UINT16_T;  BIT_BAND_PER(DMA1_Stream5->CR, DMA_SxCR_EN) = true;  return res;}

bool usart2_write(const uint8_t* buf, uint16_t len){   bool res = false;   static bool first_attempt = true;      /*!<-----Copy data to DMA USART TX buffer----->!*/   memcpy(usart2_buf.tx, buf, len);      if(!first_attempt)   {     /*!<-----Checking copmletion of previous transfer------->!*/     while(!(DMA1->HISR & DMA_HISR_TCIF6)) continue;     BIT_BAND_PER(DMA1->HIFCR, DMA_HIFCR_CTCIF6) = true;   }      first_attempt = false;      /*!<------Sending data to DMA------->!*/   BIT_BAND_PER(DMA1_Stream6->CR, DMA_SxCR_EN) = false;   DMA1_Stream6->NDTR = len;   BIT_BAND_PER(DMA1_Stream6->CR, DMA_SxCR_EN) = true;      return res;}

uint16_t usart2_read(uint8_t* buf){   uint16_t len = 0;   constexpr uint16_t BYTES_MAX = MAX_UINT16_T; //MAX Bytes in DMA buffer      /*!<---------Waiting until line become IDLE----------->!*/   if(!(USART2->SR & USART_SR_IDLE)) return len;   /*!<--------Clean the IDLE status bit------->!*/   USART2->DR;      /*!<------Refresh the receive DMA buffer------->!*/   BIT_BAND_PER(DMA1_Stream5->CR, DMA_SxCR_EN) = false;   len = BYTES_MAX - (DMA1_Stream5->NDTR);   memcpy(buf, usart2_buf.rx, len);   DMA1_Stream5->NDTR = BYTES_MAX;   BIT_BAND_PER(DMA1->HIFCR, DMA_HIFCR_CTCIF5) = true;   BIT_BAND_PER(DMA1_Stream5->CR, DMA_SxCR_EN) = true;      return len;}

MW_USART

#pragma once#include <stdint.h>#include <vector>#include <map>/*!<========Enumeration of USART=======>!*/enum class USART_NUMBER : uint8_t{  _1,  _2};class USART; //declaration of basic USART classusing usart_registry = std::map<USART_NUMBER, USART*>; /*!<=========Registry of prototypes=========>!*/extern usart_registry _instance; //Global variable - IAR Crutch#pragma inline=forced static usart_registry& get_registry(void) { return _instance; }/*!<=======Should be rewritten as========>!*//*static usart_registry& get_registry(void) {   usart_registry _instance;  return _instance; }*//*!<=========Basic USART classes==========>!*/class USART{private:protected:     static void add_prototype(USART_NUMBER num, USART* prot)  {    usart_registry& r = get_registry();    r[num] = prot;  }    static void remove_prototype(USART_NUMBER num)  {    usart_registry& r = get_registry();    r.erase(r.find(num));  }public:  static USART* create_USART(USART_NUMBER num)  {    usart_registry& r = get_registry();    if(r.find(num) != r.end())    {      return r[num]->clone();    }    return nullptr;  }  virtual USART* clone(void) const = 0;  virtual ~USART(){}    virtual bool init(uint32_t baudrate) const = 0;  virtual bool send(const uint8_t* buf, uint16_t len) const = 0;  virtual uint16_t receive(uint8_t* buf) const = 0;};/*!<=======Specific class USART 1==========>!*/class USART_1 : public USART{private:  static USART_1 _prototype;    USART_1()   {      add_prototype( USART_NUMBER::_1, this);  }public:  virtual USART* clone(void) const override final  {   return new USART_1; }  virtual bool init(uint32_t baudrate) const override final; virtual bool send(const uint8_t* buf, uint16_t len) const override final; virtual uint16_t receive(uint8_t* buf) const override final;};/*!<=======Specific class USART 2==========>!*/class USART_2 : public USART{private:  static USART_2 _prototype;    USART_2()   {      add_prototype( USART_NUMBER::_2, this);  }public:  virtual USART* clone(void) const override final  {   return new USART_2; }  virtual bool init(uint32_t baudrate) const override final; virtual bool send(const uint8_t* buf, uint16_t len) const override final; virtual uint16_t receive(uint8_t* buf) const override final;};

#include "MW_USART.h"#include "HW_USART.h"usart_registry _instance; //Crutch for IAR/*!<========Initialization of global static USART value==========>!*/USART_1 USART_1::_prototype = USART_1();USART_2 USART_2::_prototype = USART_2();/*!<======================UART1 functions========================>!*/bool USART_1::init(uint32_t baudrate) const{ bool res = false; //res = usart_init(USART1, baudrate);  //Platform depending function return res;}bool USART_1::send(const uint8_t* buf, uint16_t len) const{  bool res = false;    return res;}uint16_t USART_1::receive(uint8_t* buf) const{  uint16_t len = 0;    return len;} /*!<======================UART2 functions========================>!*/bool USART_2::init(uint32_t baudrate) const{ bool res = false; res = usart2_init(baudrate);   //Platform depending function return res;}bool USART_2::send(const uint8_t* buf, const uint16_t len) const{  bool res = false;  res = usart2_write(buf, len); //Platform depending function  return res;}uint16_t USART_2::receive(uint8_t* buf) const{  uint16_t len = 0;  len = usart2_read(buf);       //Platform depending function  return len;}

APP_ESP8266

class ESP8266{private:  ESP8266(){}  ESP8266(const ESP8266& root) = delete;  ESP8266& operator=(const ESP8266&) = delete;    /*!<---------USART settings for ESP8266------->!*/  static constexpr auto USART_BAUDRATE = ESP8266_USART_BAUDRATE;  static constexpr USART_NUMBER ESP8266_USART_NUMBER = USART_NUMBER::_2;  USART* usart;    static constexpr uint8_t LAST_COMMAND_SIZE = 32;  char last_command[LAST_COMMAND_SIZE] = {0};  bool send(uint8_t const *buf, const uint16_t len = 0);    static constexpr uint8_t ANSWER_BUF_SIZE = 32;  uint8_t answer_buf[ANSWER_BUF_SIZE] = {0};    bool receive(uint8_t* buf);  bool waiting_answer(bool (ESP8266::*scan_line)(uint8_t *));    bool scan_ok(uint8_t * buf);  bool if_str_start_with(const char* str, uint8_t *buf);public:    bool init(void);    static ESP8266& Instance()  {    static ESP8266 esp8266;    return esp8266;  }};

bool ESP8266::init(void){  bool res = false;    usart = USART::create_USART(ESP8266_USART_NUMBER);  usart->init(USART_BAUDRATE);    const uint8_t* init_commands[] =   {    "AT",    "ATE0",    "AT+CWMODE=2",    "AT+CIPMUX=0",    "AT+CWSAP=\"Tortoise_assistant\",\"00000000\",5,0",    "AT+CIPMUX=1",    "AT+CIPSERVER=1,8888"  };    for(const auto &command: init_commands)  {    this->send(command);    while(this->waiting_answer(&ESP8266::scan_ok)) continue;  }      return res;}

#pragma once#include <iostream>#include <list>#include <vector>#include <iterator>template <typename T> class Sorts{public:std::list<T> arrayList;std::vector<T> bubbleArray,insertionArray,heapArray,shakeArray;float BubbleSort(){std::cout <<"Time to Bubble>" << std::endl;unsigned int start_time = clock(); // начальное времяint size = bubbleArray.size();for (int i = 1; i < size; i++)for (int j = size-1; j >=i; j--)if (bubbleArray[j-1] > bubbleArray[j])swap(&bubbleArray, j - 1, j);unsigned int end_time = clock(); // конечное времяunsigned int search_time = end_time - start_time; // искомое времяstd::cout << (float)search_time / CLOCKS_PER_SEC << std::endl;return (float)search_time / CLOCKS_PER_SEC;}float InsertionSort(){std::cout << "Time to Insertion>" << std::endl;unsigned int start_time = clock(); // начальное времяint size = insertionArray.size();for (int i = 1; i < size; i++){T tmp = insertionArray[i];int j = i;while (j > 0 && insertionArray[j - 1] > tmp){insertionArray[j] = insertionArray[j - 1];j = j - 1;}insertionArray[j] = tmp;}unsigned int end_time = clock(); // конечное времяunsigned int search_time = end_time - start_time; // искомое времяstd::cout << (float)search_time / CLOCKS_PER_SEC << std::endl;return (float)search_time / CLOCKS_PER_SEC;}void swap(std::vector<T> *v, int n, int m){T tmp = (*v)[n];(*v)[n] = (*v)[m];(*v)[m] = tmp;}float HeapSort(){std::cout << "Time to Heap>" << std::endl;unsigned int start_time = clock(); // начальное времяint size = heapArray.size();for (int j = 0; j < size; j++){for (int i = size / 2 - 1 - j / 2; i > -1; i--){if (2 * i + 2 <= size - 1 - j){if (heapArray[2 * i + 1] > heapArray[2 * i + 2]){if (heapArray[i] < heapArray[2 * i + 1]){swap(&heapArray, i, 2 * i + 1);}}elseif (heapArray[i] < heapArray[2 * i + 2]){swap(&heapArray, i, 2 * i + 2);}}elseif (2 * i + 1 <= size - 1 - j)if (heapArray[i] < heapArray[2 * i + 1])swap(&heapArray, i, 2 * i + 1);}swap(&heapArray, 0, size - 1 - j);}unsigned int end_time = clock(); // конечное времяunsigned int search_time = end_time - start_time; // искомое времяstd::cout << (float)search_time / CLOCKS_PER_SEC << std::endl;return (float)search_time / CLOCKS_PER_SEC;}float ShakeSort(){std::cout << "Time to Shake>" << std::endl;unsigned int start_time = clock(); // начальное времяint size = shakeArray.size();int left = 0;int right = size - 1;do {for (int i = left; i < right; i++) {if (shakeArray[i] > shakeArray[i + 1])swap(&shakeArray,i,i+1);}right--;for (int i = right; i > left; i--) {if (shakeArray[i] < shakeArray[i - 1])swap(&shakeArray, i-1, i);}left++;} while (left < right);unsigned int end_time = clock(); // конечное времяunsigned int search_time = end_time - start_time; // искомое времяstd::cout << (float)search_time / CLOCKS_PER_SEC << std::endl;return (float)search_time / CLOCKS_PER_SEC;}void PrintArray(int num){switch (num){case 0:for (typename std::list<T>::iterator it = arrayList.begin(); it != arrayList.end(); it++)std::cout << (*it) << " ";break;case 1:for (typename std::vector<T>::iterator it = bubbleArray.begin(); it != bubbleArray.end(); it++)std::cout << (*it) << " ";break;case 2:for (typename std::vector<T>::iterator it = shakeArray.begin(); it != shakeArray.end(); it++)std::cout << (*it) << " ";break;case 3:for (typename std::vector<T>::iterator it = heapArray.begin(); it != heapArray.end(); it++)std::cout << (*it) << " ";break;case 4:for (typename std::vector<T>::iterator it = insertionArray.begin(); it != insertionArray.end(); it++)std::cout << (*it) << " ";break;default:break;}std::cout << std::endl;}};

#include "Sorts.h"int main(){std::vector<float> vq, vb, vs, vh, vi;float meanq = 0, meanb = 0, means = 0, meanh = 0, meani = 0;const int N = 100;srand(time(0));for (int i = 0; i < N; i++){std::cout << i+1 << " iteration" << std::endl;const int iSize = 1000;auto sort = new Sorts<int>();for (int i = 0; i < iSize; i++){int num = rand() % iSize;sort->arrayList.push_back(num);sort->bubbleArray.push_back(num);sort->shakeArray.push_back(num);sort->heapArray.push_back(num);sort->insertionArray.push_back(num);}std::cout << "Time to Quick sort from stl>" << std::endl;unsigned int start_time = clock(); // начальное времяsort->arrayList.sort();unsigned int end_time = clock(); // конечное времяunsigned int search_time = end_time - start_time; // искомое времяstd::cout << (float)search_time / CLOCKS_PER_SEC << std::endl;vq.push_back((float)search_time / CLOCKS_PER_SEC);vb.push_back(sort->BubbleSort());vs.push_back(sort->ShakeSort());vh.push_back(sort->HeapSort());vi.push_back(sort->InsertionSort());meanq += vq[i];meanb += vb[i];means += vs[i];meanh += vh[i];meani += vi[i];//sort->PrintArray(0);//sort->PrintArray(1);//sort->PrintArray(2);//sort->PrintArray(3);//sort->PrintArray(4);sort->arrayList.clear();sort->bubbleArray.clear();sort->shakeArray.clear();sort->heapArray.clear();sort->insertionArray.clear();std::cout << "end of "<< i + 1 <<" iteration" << std::endl;}std::cout << "Results:" << std::endl;std::cout << "Mean quick=" << (float)meanq / N << std::endl;std::cout << "Mean bubble=" << (float)meanb / N << std::endl;std::cout << "Mean shake=" << (float)means / N  << std::endl;std::cout << "Mean heap=" << (float)meanh / N  << std::endl;std::cout << "Mean insertion=" << (float)meani / N << std::endl;return 0;}

В программе

1. Краткая история Стандартов. Что привело к C++20.
2. Модули как новая эпоха языка:
   Долгожданный документ принят панацея или ошибка?
   Как С++ преодолевает 30-летнее отставание.
   Как сломать систему сборки.
3. Оператор космического корабля:
   Один за шестерых, но это ещё не всё.
   Порядки в C++ выходят на новый уровень.
4. Концепты и констрейнты. Средство от криптографических ошибок на 10000 строк или нечто большее?
5. Ranges. Просто адекватная замена парам итераторов или новый стиль в программировании?
6. Корутины:
   Что это, и почему их время ещё не пришло.
   Как сломать отладчик.
7. Приятные и важные мелочи. Краткий обзор других фич Стандарта:
   Designated initializers, инициализаторы в Ranged-for, span, календарь, format, шаблонные лямбды и другое.
   Что ещё дал нам C++20.
8. Будущее. Чего ожидать от C++ дальше.

Ведущий

Вебинар пройдёт 25 февраля в 19.30 (Мск).
Бесплатная регистрация.

Отслеживание жизненного цикла объекта

#include <cstdio>struct Tracer {    Tracer(const char* name1) : name{ name }2 {       printf("%s constructed.\n", name); 3    }    ~Tracer() {       printf("%s destructed.\n", name); 4    }private:    const char* const name;};

#include <cstdio>struct Tracer {    --пропуск--};static Tracer t1{ "Static variable" }; 1thread_local Tracer t2{ "Thread-local variable" }; 2int main() {  const auto t2_ptr = &t2;  printf("A\n"); 3  Tracer t3{ "Automatic variable" }; 4  printf("B\n");  const auto* t4 = new Tracer{ "Dynamic variable" }; 5  printf("C\n");}

Static variable constructed.Thread-local variable constructed.A 3Automatic variable constructed.BDynamic variable constructed.CAutomatic variable destructed.Thread-local variable destructed.Static variable destructed.

Исключения

#include <stdexcept>#include <cstdio>struct Groucho {   void forget(int x) {      if (x == 0xFACE) {         throw1 std::runtime_error2{ "I'd be glad to make an exception." };      }      printf("Forgot 0x%x\n", x);    }};

#include <stdexcept>#include <cstdio>struct Groucho {      --пропуск--};int main() {   Groucho groucho;   try { 1       groucho.forget(0xC0DE); 2       groucho.forget(0xFACE); 3       groucho.forget(0xC0FFEE); 4    } catch (const std::runtime_error& e5) {       printf("exception caught with message: %s\n", e.what()); 6    }}

Forgot 0xc0deexception caught with message: I'd be glad to make an exception.

КРАТКИЙ КУРС ПО НАСЛЕДОВАНИЮ

Прежде чем вводить исключения stdlib, нужно понять простое наследование классов C++ на очень высоком уровне. Классы могут иметь подклассы, которые наследуют функциональность своих суперклассов. Синтаксис в листинге 4.10 определяет это отношение.

struct Superclass {    int x;};struct Subclass : Superclass { 1    int y;    int foo() {      return x + y; 2    }};

В Superclass нет ничего особенного. Но вот объявление Subclass 1 является особенным. Оно определяет отношения наследования с использованием синтаксиса: Superclass. Subclass наследует члены от Superclass, которые не помечены как private. Это можно увидеть в действии, когда Subclass использует поле x 2. Это поле принадлежит Superclass, но поскольку Subclass наследует от Superclass, x доступно.

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

• domain_error сообщает об ошибках, связанных с допустимым диапазоном ввода, особенно для математических функций. Например, квадратный корень поддерживает только неотрицательные числа (в реальном случае). Если передается отрицательный аргумент, функция квадратного корня может выдать domain_error.

• Исключение invalid_argument сообщает, как правило, о неожиданных параметрах.

• Исключение length_error сообщает, что какое-либо действие нарушит ограничение максимального размера.

• Исключение out_of_range сообщает, что некоторое значение не находится в ожидаемом диапазоне. Каноническим примером является индексирование с проверкой границ в структуре данных.

• system_error сообщает, что операционная система обнаружила некоторую ошибку. Такого рода исключения могут тысячи раз встретиться на вашем пути. Внутри заголовка <system_error> находится большое количество кодов ошибок и их состояний. Когда создается system_error, информация об ошибке упаковывается, чтобы можно было определить природу ошибки. Метод .code() возвращает enumclass типа std::errc, который имеет большое количество значений, таких как bad_file_descriptor, timed_out и license_denied,

• overflow_error и underflow_error сообщают об арифметическом переполнении и потере значимости соответственно.

try {   throw std::logic_error{ "It's not about who wrong "                          "it's not about who right" };} catch (std::exception& ex) {   // Обрабатывает std::logic_error. Поскольку он наследуется от std::exception}

try {  throw 'z'; // Don't do this.} catch (...) {  // Обрабатывает любое исключение, даже 'z'}

try {  // Код, который может вызвать исключение  --пропуск--} catch (const std::logic_error& ex) {  // Запись исключения и завершение работы программы; найдена программная ошибка!  --пропуск--} catch (const std::runtime_error& ex) {  // Делаем все, что можно  --пропуск--} catch (const std::exception& ex) {  // Обработка любого исключения, наследуемого от std:exception,  // которое не является logic_error или runtime_error.  --пропуск--} catch (...) {  // Паника; было сгенерировано непредвиденное исключение  --пропуск--}

ПЕРЕБРАСВАНИЕ ИСКЛЮЧЕНИЯ
В блоке catch можно использовать ключевое слово throw, чтобы возобновить поиск подходящего обработчика исключений. Это называется перебрасыванием исключения. Есть несколько необычных, но важных случаев, когда вы, возможно, захотите дополнительно проверить исключение, прежде чем обработать его, как показано в листинге 4.11.

Листинг 4.11. Перебрасывание ошибки

try {  // Код, который может вызвать system_error  --пропуск--} catch(const std::system_error& ex) {   if(ex.code()!= std::errc::permission_denied){   // Ошибка, не связанная с отказом в доступе     throw; 1}  // Восстановление после ошибки   --пропуск--}

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

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

Листинг 4.12. Перехват конкретного исключения, но не перебрасывание

try {  // Генерация исключения PermissionDenied  --пропуск--} catch(const PermissionDenied& ex) {  // Восстановление после ошибки EACCES (отказано в доступе) 1  --пропуск--}

Если генерируется std::system_error, обработчик PermissionDenied 1 не поймает его. (Конечно, обработчик std::system_error все равно можно оставить, чтобы перехватывать такие исключения, если это необходимо.)

bool is_odd(int x) noexcept {  return 1 == (x % 2);}

void hari_kari() noexcept {   throw std::runtime_error{ "Goodbye, cruel world." };}

ПРИМЕЧАНИЕ
Ознакомьтесь с правилом 14 Эффективного использования C++ Скотта Мейерса, чтобы подробно обсудить noexcept. Суть в том, что некоторые конструкторы переноса и операторы присваивания переноса могут выдавать исключение, например если им нужно выделить память, а система не работает. Если конструктор переноса или оператор присваивания переноса не указывает иное, компилятор должен предполагать, что перенос может вызвать исключение. Это отключает определенные оптимизации.

#include <cstdio>#include <stdexcept>struct CyberdyneSeries800 {  CyberdyneSeries800() {   printf("I'm a friend of Sarah Connor."); 1  }  ~CyberdyneSeries800() {    throw std::runtime_error{ "I'll be back." }; 2}};  int main() {    try {      CyberdyneSeries800 t800; 3      thro std::runtime_error{ "Come with me if you want to live." }; 4    } catch(const std::exception& e) { 5      printf("Caught exception: %s\n", e.what()); 6    }}----------------------------------------------------------------------I'm a friend of Sarah Connor. 

ПРИМЕЧАНИЕ
Листинг 4.13 вызывает std::terminate, поэтому в зависимости от операционной среды может быть показано всплывающее окно с уведомлением.

Класс SimpleString

#include <stdexcept>struct SimpleString {  SimpleString(size_t max_size) 1    : max_size{ max_size }, 2      length{} { 3    if (max_size == 0) {      throw std::runtime_error{ "Max size must be at least 1." }; 4    }    buffer = new char[max_size]; 5    buffer[0] = 0; 6    }   ~SimpleString() {     delete[] buffer; 7    }--пропуск--private:    size_t max_size;    char* buffer;    size_t length;};

ПРИМЕЧАНИЕ
Поскольку max_size это size_t, он не имеет знака и не может быть отрицательным, поэтому не нужно проверять это фиктивное условие.

ПРИМЕЧАНИЕ
Класс SimpleString все еще имеет неявно определенный конструктор копирования. Несмотря на то что память не может быть потеряна, при копировании класс потенциально освободится вдвое. Вы узнаете о конструкторах копирования в разделеСемантике копирования, с. 176. Просто знайте, что листинг 4.14 это обучающий инструмент, а не рабочий код.

#include <cstdio>#include <cstring>#include <stdexcept>struct SimpleString {  --пропуск--  void print(const char* tag) const { 1    printf("%s: %s", tag, buffer);  }  bool append_line(const char* x) { 2  const auto x_len = strlen3(x);  if (x_len + length + 2 > max_size) return false; 4  std::strncpy(buffer + length, x, max_size - length);  length += x_len;  buffer[length++] = '\n';  buffer[length] = 0;  return true; } --пропуск--};

size_t strlen(const char* str);

char* std::strncpy(char* destination, const char* source, std::size_t num);

ПРЕДУПРЕЖДЕНИЕ
Используйте strncpy очень осторожно. Слишком легко забыть символ конца строки в исходной строке или не выделить достаточно места в целевой строке. Обе ошибки приведут к неопределенному поведению. Мы рассмотрим более безопасную альтернативу во второй части книги.

#include <cstdio>#include <cstring>#include <exception>struct SimpleString {   --пропуск--}int main() {   SimpleString string{ 115 }; 1   string.append_line("Starbuck, whaddya hear?");   string.append_line("Nothin' but the rain."); 2   string.print("A"); 3   string.append_line("Grab your gun and bring the cat in.");   string.append_line("Aye-aye sir, coming home."); 4   string.print("B"); 5   if (!string.append_line("Galactica!")) { 6      printf("String was not big enough to append another message."); 7   }}

A: Starbuck, whaddya hear? 1Nothin' but the rain.B: Starbuck, whaddya hear? 2Nothin' but the rain.Grab your gun and bring the cat in.Aye-aye sir, coming home.String was not big enough to append another message. 3

#include <stdexcept>struct SimpleStringOwner {   SimpleStringOwner(const char* x)     : string{ 10 } { 1     if (!string.append_line(x)) {       throw std::runtime_error{ "Not enough memory!" };    }    string.print("Constructed");  }  ~SimpleStringOwner() {    string.print("About to destroy"); 2  }private:  SimpleString string;};

--пропуск--int main() {   SimpleStringOwner x{ "x" };   printf("x is alive\n");}--------------------------------------------------------------------Constructed: х 1x is aliveAbout to destroy: х 2

--пропуск--void fn_c() {   SimpleStringOwner c{ "cccccccccc" }; 1}void fn_b() {  SimpleStringOwner b{ "b" };  fn_c(); 2}int main() {  try { 3   SimpleStringOwner a{ "a" };   fn_b(); 4   SimpleStringOwner d{ "d" }; 5 } catch(const std::exception& e) { 6  printf("Exception: %s\n", e.what()); }}

Constructed: aConstructed: bAbout to destroy: bAbout to destroy: aException: Not enough memory!

struct HumptyDumpty {   HumptyDumpty();   bool is_together_again();  --пропуск--};

bool send_kings_horses_and_men() {  HumptyDumpty hd{};  if (hd.is_together_again()) return false;  // Использование инвариантов класса hd гарантировано.  // HumptyDumpty с треском проваливается.  --пропуск--  return true;}

struct Result { 1   HumptyDumpty hd;   bool success;   };  Result make_humpty() { 2    HumptyDumpty hd{};    bool is_valid;    // Проверка правильности hd и установка соответствующего значения is_valid    return { hd, is_valid };   }bool send_kings_horses_and_men() {   auto [hd, success] = make_humpty();    if(!success) return false;   // Установка инвариантов класса   --пропуск--   return true;}

ПРИМЕЧАНИЕ
Более подробное описание структурированных привязок приведено в подразделе Структурированные привязки, с. 289.

В продолжение прошлой статьи о KVM публикуем новый перевод и разбираемся, как работают контейнеры на примере запуска Docker-образа busybox.

BusyBox Docker

Clone

• CLONE_NEWNET изолированные сетевые устройства
• CLONE_NEWUTS имя хоста и домена (система разделения времени UNIX)
• CLONE_NEWIPC объекты IPC
• CLONE_NEWPID идентификаторы процессов (PID)
• CLONE_NEWNS точки монтирования (файловые системы)
• CLONE_NEWUSER пользователи и группы.

static char child_stack[1024 * 1024];int child_main(void *arg) {  printf("Hello from child! PID=%d\n", getpid());  return 0;}int main(int argc, char *argv[]) {  int flags =      CLONE_NEWNS | CLONE_NEWUTS | CLONE_NEWPID | CLONE_NEWIPC | CLONE_NEWNET;  int pid = clone(child_main, child_stack + sizeof(child_stack),                  flags | SIGCHLD, argv + 1);  if (pid < 0) {    fprintf(stderr, "clone failed: %d\n", errno);    return 1;  }  waitpid(pid, NULL, 0);  return 0;}

Рабочая оболочка

int child_main(void *arg) {  char **argv = (char **)arg;  execvp(argv[0], argv);  return 0;}

Chroot

int child_main(void *arg) {  /* Unmount procfs */  umount2("/proc", MNT_DETACH);  /* Pivot root */  mount("./rootfs", "./rootfs", "bind", MS_BIND | MS_REC, "");  mkdir("./rootfs/oldrootfs", 0755);  syscall(SYS_pivot_root, "./rootfs", "./rootfs/oldrootfs");  chdir("/");  umount2("/oldrootfs", MNT_DETACH);  rmdir("/oldrootfs");  /* Re-mount procfs */  mount("proc", "/proc", "proc", 0, NULL);  /* Run the process */  char **argv = (char **)arg;  execvp(argv[0], argv);  return 0;}

Сеть

system("ip link add veth0 type veth peer name veth1");system("ip link set veth0 up");system("brctl addif br0 veth0");

char ip_link_set[4096];snprintf(ip_link_set, sizeof(ip_link_set) - 1, "ip link set veth1 netns %d",         pid);system(ip_link_set);

int child_main(void *arg) {  ....  sethostname("example", 7);  system("ip link set veth1 up");  char ip_addr_add[4096];  snprintf(ip_addr_add, sizeof(ip_addr_add),           "ip addr add 172.16.0.101/24 dev veth1");  system(ip_addr_add);  system("route add default gw 172.16.0.100 veth1");  char **argv = (char **)arg;  execvp(argv[0], argv);  return 0;}

Вывод