Михаил Матросов, Повседневный С++: boost и STL

Повседневный С++: boost и STL
Михаил Матросов
mikhail.matrosov@gmail.com
mmatrosov@aligntech.com
1

"Повседневный С++: boost и STL", Михаил Матросов, C++ Russia 2016 3

С++17
С++11/14
С++98
С
High level
Expert level
Modern C++

“Within C++ is a smaller, simpler, safer
language struggling to get out”
Bjarne Stroustrup

High level:
 Парадигма RAII и исключения (exceptions)
 Алгоритмы и контейнеры STL и boost
 Семантика перемещения
 λ-функции
 Классы и конструкторы
 Простые шаблоны
Expert level:
 Операторы new/delete, владеющие
указатели
 Пользовательские операции копирования
и перемещения
 Пользовательские деструкторы
 Закрытое, защищённое, ромбовидное,
виртуальное наследование
 Шаблонная магия, SFINAE
 Все функции языка Си, препроцессор
 «Голые» циклы
Классический слайд с телом и заголовком

7
Which boost
features overlap
with C++11?

bool doCompare(const Bakery* oldBakery, const Bakery* newBakery)
{
if (!oldBakery || !newBakery)
{
return false;
}
std::vector<Cookie> oldCookies;
std::vector<Cookie> newCookies;
std::vector<std::pair<Cookie, int>> diff;
collectCookies(*oldBakery, oldCookies);
collectCookies(*newBakery, newCookies);
std::sort(oldCookies.begin(), oldCookies.end(), compareCookies);
std::sort(newCookies.begin(), newCookies.end(), compareCookies);
auto oldIt = oldCookies.begin();
auto newIt = newCookies.begin();
while ((oldIt != oldCookies.end()) || (newIt != newCookies.end()))

{
{
return false;
}
{
if (compareCookies(*oldIt, *newIt))
{
diff.push_back(std::pair<Cookie, int>(*oldIt, 1));
++oldIt;
}
else if (compareCookies(*newIt, *oldIt))
{
diff.push_back(std::pair<Cookie, int>(*newIt, 2));
++newIt;
}
else
{
++oldIt;
++newIt;
}
}
if (oldIt != oldCookies.end())
{
for (; oldIt < oldCookies.end(); oldIt++)
{
}
}
if (newIt != newCookies.end())
{
for (; newIt < newCookies.end(); newIt++)
{
}
}
for (const auto& item : diff)
{
std::cout << "Bakery #" << item.second <<
" has a different cookie "" << item.first.name <<
"" (weight=" << item.first.weight <<
", volume=" << item.first.volume <<
", tastiness=" << item.first.tastiness << ")." << std::endl;
}
if (diff.size() > 0)
return false;
return true;
}
bool doCompare(const Bakery& oldBakery, const Bakery& newBakery)
{
std::vector<Cookie> oldCookies = collectSortedCookies(oldBakery);
std::vector<Cookie> newCookies = collectSortedCookies(newBakery);
std::vector<Cookie> lostCookies;
boost::range::set_difference(oldCookies, newCookies, std::back_inserter(lostCookies));
std::vector<Cookie> appearedCookies;
boost::range::set_difference(newCookies, oldCookies, std::back_inserter(appearedCookies));
for (const auto& cookie : lostCookies)
{
std::cout << "We've lost a friend: " << cookie << "." << std::endl;
}
for (const auto& cookie : appearedCookies)
{
std::cout << "We got a new friend: " << cookie << "." << std::endl;
}
return lostCookies.empty() && appearedCookies.empty();
}

{
{
return false;
}
// ...

{
collectCookies(oldBakery, oldCookies);
collectCookies(newBakery, newCookies);
// ...

{
// ...

void collectCookies(const Bakery& bakery, std::vector<Cookie>& o_cookies);
{
// ...

std::vector<Cookie> collectCookies(const Bakery& bakery);
{
std::vector<Cookie> oldCookies = collectCookies(oldBakery);
std::vector<Cookie> newCookies = collectCookies(newBakery);
// ...
In-depth: Functional programming in C++

λλ
=:

// ...
{
{
++oldIt;
}
{
// ...

struct Cookie
{
double weight;
double volume;
std::string name;
int tastiness;
};
bool compareCookies(const Cookie& a, const Cookie& b)
{
if (a.tastiness != b.tastiness)
return a.tastiness < b.tastiness;
if (a.weight != b.weight)
return a.weight < b.weight;
if (a.volume != b.volume)
return a.volume < b.volume;
return a.name < b.name;
}

struct Cookie
{
double weight;
double volume;
std::string name;
int tastiness;
};
bool operator<(const Cookie& a, const Cookie& b)
{
}

// ...
{
{
++oldIt;
}
{
// ...

// ...
std::sort(oldCookies.begin(), oldCookies.end());
std::sort(newCookies.begin(), newCookies.end());
{
if (*oldIt < *newIt)
{
++oldIt;
}
else if (*newIt < *oldIt)
{
// ...

{
}

{
return std::make_tuple(a.tastiness, a.weight, a.volume, a.name) <
std::make_tuple(b.tastiness, b.weight, b.volume, b.name);
}

struct Cookie
{
double weight;
double volume;
std::string name;
int tastiness;
};
{
return std::make_tuple(a.tastiness, a.weight, a.volume, a.name) <
std::make_tuple(b.tastiness, b.weight, b.volume, b.name);
}

struct Cookie
{
double weight;
double volume;
std::string name;
int tastiness;
};
{
return std::tie(a.tastiness, a.weight, a.volume, a.name) <
std::tie(b.tastiness, b.weight, b.volume, b.name);
}

struct Cookie
{
double weight;
double volume;
std::string name;
int tastiness;
auto rank() const
{
return std::tie(tastiness, weight, volume, name);
}
};
{
return a.rank() < b.rank();
}
Implementing comparison operators via 'tuple' and 'tie', a good idea?

struct Cookie
{
double weight;
double volume;
std::string name;
int tastiness;
auto rank() const // -> std::tuple<const int&, const double&,
{ // const double&, const std::string&>
}
};
{
}
Implementing comparison operators via 'tuple' and 'tie', a good idea?

struct Cookie
{
double weight;
double volume;
std::string name;
int tastiness;
auto rank() const // -> std::tuple<const int&, const double&,
{ // const double&, const std::string&>
}
};
{
}
bool operator==(const Cookie& a, const Cookie& b)
{
return a.rank() == b.rank();
}

{
// ...

std::vector<Cookie> collectCookies(const Bakery& bakery)
{
std::vector<Cookie> cookies;
// ...
// ...
return cookies;
}
{
// ...

std::vector<Cookie> collectSortedCookies(const Bakery& bakery)
{
std::vector<Cookie> cookies;
// ...
std::sort(cookies.begin(), cookies.end());
return cookies;
}
{
// ...

// ...
{
++oldIt;
}
{
++newIt;
}

// ...
{
diff.push_back(std::make_pair(*oldIt, 1));
++oldIt;
}
{
diff.push_back(std::make_pair(*newIt, 2));
++newIt;
}

// ...
{
diff.push_back({ *oldIt, 1 });
++oldIt;
}
{
diff.push_back({ *newIt, 2 });
++newIt;
}

// ...
{
diff.emplace_back(*oldIt, 1);
++oldIt;
}
{
diff.emplace_back(*newIt, 2);
++newIt;
}

for (const auto& item : diff) // item is std::pair<Cookie, int>
{
}

for (const auto& item : diff) // item is std::pair<Cookie, int>
{
" has a different cookie " << item.first << "." << std::endl;
}
std::ostream& operator<<(std::ostream& stream, const Cookie& cookie)
{
return stream << """ << cookie.name <<
"" (weight=" << cookie.weight <<
", volume=" << cookie.volume <<
", tastiness=" << cookie.tastiness << ")";
}

return false;
return true;

return diff.empty();

{
{
++oldIt;
}
{
++newIt;
}
else
{
++oldIt;
++newIt;
}
}
for (; oldIt != oldCookies.end(); oldIt++)
{
}
for (; newIt != newCookies.end(); newIt++)
{
}
1 2 5 7 8 9
1 3 5 6 9
2 7 83 6
oldCookies
newCookies
diff
Ошибка. Должно быть &&
Sean Parent: C++ Seasoning (no raw loops)

std::set_difference(oldCookies.begin(), oldCookies.end(),
newCookies.begin(), newCookies.end(),
std::back_inserter(lostCookies));
std::set_difference(newCookies.begin(), newCookies.end(),
oldCookies.begin(), oldCookies.end(),
std::back_inserter(appearedCookies));

{
}
{
}

{
}
{
}
{
}

{
{
return false;
}
{
{
++oldIt;
}
{
++newIt;
}
else
{
++oldIt;
++newIt;
}
}
if (oldIt != oldCookies.end())
{
for (; oldIt < oldCookies.end(); oldIt++)
{
}
}
if (newIt != newCookies.end())
{
for (; newIt < newCookies.end(); newIt++)
{
}
}
for (const auto& item : diff)
{
}
return false;
return true;
}
{
{
}
{
}
}

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

И ещё немного
по теме…

struct Cookie
{
double weight;
double volume;
std::string name;
int tastiness;
auto rank() const
{
}
};

struct Cookie
{
double weight;
double volume;
std::string name;
int tastiness;
double density() const
{
return weight / volume;
}
auto rank() const
{
return std::tie(tastiness, density(), name);
}
};

struct Cookie
{
double weight;
double volume;
std::string name;
int tastiness;
{
}
auto rank() const
{
return std::make_tuple(tastiness, density(), std::ref(name));
}
};

struct Cookie
{
double weight;
double volume;
std::string name;
int tastiness;
{
}
auto rank() const // -> std::tuple<int, double, const std::string&>
{
return std::make_tuple(tastiness, density(), std::ref(name));
}
};

{
}
{
}

auto reportLost = [](const Cookie& cookie)
{
};
auto reportAppeared = [](const Cookie& cookie)
{
};
boost::range::set_difference(oldCookies, newCookies,
boost::make_function_output_iterator(reportLost));
boost::range::set_difference(newCookies, oldCookies,
boost::make_function_output_iterator(reportAppeared));

auto reportLost = [](const Cookie& cookie)
{
};
auto reportAppeared = [](const Cookie& cookie)
{
};
boost::range::set_difference(oldCookies, newCookies,
boost::make_function_output_iterator(reportLost));
boost::range::set_difference(newCookies, oldCookies,
boost::make_function_output_iterator(reportAppeared));
return oldCookies == newCookies; // was "lostCookies.empty() && appearedCookies.empty()"

auto f = [](int x) { std::cout << x; };
auto it = boost::make_function_output_iterator(f);
decltype(it) it2 = it; // Ok, copied
it2 = it; // Does not compile, cannot assign!
std::function<void(int)> f = [](int x) { std::cout << x; };
it2 = it; // Ok, iterator holds an std::function instance
auto f = [](int x) { std::cout << x; };
auto it = boost::make_function_output_iterator(std::ref(f));
it2 = it; // Ok, iterator holds a reference
auto f = +[](int x) { std::cout << x; };
it2 = it; // Ok, note the plus before [], it triggers special C++ magic
Resolving ambiguous overload
on function pointer and
std::function for a lambda using +
boost::function_output_iterator
constructed from lambda
function is not assignable

Советы:
 Мыслите на высоком уровне
 Код должен ясно выражать намерение
 Знайте свои инструменты и используйте их к месту
// references
// auto variables
// auto function return type
// move semantics
// lambda functions
operator<();
std::make_tuple();
std::tie();
std::ref();
std::make_pair();
std::vector<T>::emplace_back();
std::vector<T>::empty();
operator<<();
std::back_inserter();
std::set_difference();
boost::range::set_difference();
boost::make_function_output_iterator();
std::function<>

 Мыслите на высоком уровне
 Код должен ясно выражать намерение
 Знайте свои инструменты и используйте их к месту
"Повседневный С++: boost и STL", Михаил Матросов, C++ Russia 2016
std::make_pair();
std::vector<T>::emplace_back();
std::vector<T>::empty();
operator<<();
std::back_inserter();
std::set_difference();
boost::range::set_difference();
boost::make_function_output_iterator();
std::function<>
Спасибо за внимание!
// references
// auto variables
// auto function return type
// move semantics
// lambda functions
operator<();
std::make_tuple();
std::tie();
std::ref();
61

compareRanked(Cookie const&, Cookie const&):
movl 16(%rsi), %edx
cmpl %edx, 16(%rdi)
movl $1, %eax
jl .L2
movl $0, %eax
jg .L2
movsd (%rdi), %xmm1
movl $1, %eax
movsd (%rsi), %xmm0
ucomisd %xmm1, %xmm0
ja .L2
xorl %eax, %eax
ja .L2
movsd 8(%rsi), %xmm0
ucomisd 8(%rdi), %xmm0
seta %al
.L2:
rep ret
compareDirect(Cookie const&, Cookie const&):
movl 16(%rsi), %eax
cmpl %eax, 16(%rdi)
je .L9
setl %al
ret
.L9:
movsd (%rdi), %xmm0
movsd (%rsi), %xmm1
jp .L13
jne .L13
movsd 8(%rsi), %xmm0
ucomisd 8(%rdi), %xmm0
seta %al
ret
.L13:
seta %al
ret

Ссылки
 Which boost features overlap with C++11?
 In-depth: Functional programming in C++
 Implementing comparison operators via 'tuple' and 'tie', a good idea?
 Sean Parent: C++ Seasoning (no raw loops)
 boost::function_output_iterator constructed from lambda function is not assignable
 Resolving ambiguous overload on function pointer and std::function for a lambda using +

Михаил Матросов, Повседневный С++: boost и STL

More Related Content

What's hot

Viewers also liked

More from Sergey Platonov

Recently uploaded

Михаил Матросов, Повседневный С++: boost и STL

Editor's Notes