C++: Хроники Дурки🚑
Ir al canal en Telegram
Очень люблю C++, но это скорее уже стокгольмский синдром. Постоянно нахожу способы стрельнуть себе в ногу.
Mostrar más915
Suscriptores
+324 horas
+57 días
+430 días
Archivo de publicaciones
Если кто не знаком с библиотекой nlohmann/json - она прекрасна. Мои мысли о том, как должна выглядеть библиотека для пользователя, она начала формировать еще году в 2012. (я гне нашел подтверждений, что она тогда уже была, но по ощущениям где-то тогда и появилась)
Но речь не об этом.
Как написано в cppreference, если ключи равны, то и хеши от них равны.
```
Given the following values:
h, an object of type std::hash<Key>.
k1 and k2, objects of type Key.
All following requirements are satisfied:
- If k1 == k2 is true, h(k1) == h(k2) is also true.
- Unless std::hash<Key> is a program-defined specialization, h(k1) will never throw an exception.
```
Иногда срабатывает даже если это объекты разных типов
const auto x1 = 42;
const auto x2 = 42u;
__builtin_printf("%b\n\n", x1 == x2);
__builtin_printf("%#08zx\n%#08zx\n",
std::hash<int>{}(x1),
std::hash<unsigned>{}(x2));1 0x00002a 0x00002aА вот если вы упакуете те же типы в обертку типа json:
const auto j1 = json{x1};
const auto j2 = json{x2};
__builtin_printf("%b\n\n", j1 == j2);
__builtin_printf("%#08zx\n%#08zx\n",
std::hash<json>{}(j1),
std::hash<json>{}(j2));1 0x286fec1b50 0x286fec1b91Потому что там есть своя специализация. И с ней это правило для hash не работает.
namespace std // NOLINT(cert-dcl58-cpp)
{
/// @brief hash value for JSON objects
/// @sa https://json.nlohmann.me/api/basic_json/std_hash/
NLOHMANN_BASIC_JSON_TPL_DECLARATION
struct hash<nlohmann::NLOHMANN_BASIC_JSON_TPL> // NOLINT(cert-dcl58-cpp)
{
std::size_t operator()(const nlohmann::NLOHMANN_BASIC_JSON_TPL& j) const
{
return nlohmann::detail::hash(j);
}
};
#толькосвоимемы
Код взят тут.
if (dim == 0) idx_dim = i0;
else if (dim == 1) idx_dim = i1;
else if (dim == 2) idx_dim = i2;
else if (dim == 3) idx_dim = i3;
const struct htp_tensor * src = (idx_dim < src0->ne[dim]) ? src0 : src1;
uint32_t s0 = i0;
uint32_t s1 = i1;
uint32_t s2 = i2;
uint32_t s3 = i3;
if (dim == 0 && src == src1) s0 -= src0->ne[0];
if (dim == 1 && src == src1) s1 -= src0->ne[1];
if (dim == 2 && src == src1) s2 -= src0->ne[2];
if (dim == 3 && src == src1) s3 -= src0->ne[3];
Ладно, искать баги в компиляторах весело, но недостаточно.
Давайте поиграемся в чуть более интересные игры.
Вспомним, что у нас в С++ есть правило: структура не может иметь нулевой размер. Потому что у ее инстанса должен быть адрес, и здесь С++ как-то забыл про Zero Cost и все такое.
Зато С++ вспомнил про Zero Cost, когда мы примешиваем пустую структуру в наследование другой.
struct Empty1 {};
struct Empty2 {};
struct NonEmpty {
int Value;
};
struct MyClass1
:public NonEmpty
,public Empty1
,public Empty2
{
};
struct MyClass2
:public Empty1
,public NonEmpty
,public Empty2
{
};
struct MyClass3
:public Empty1
,public Empty2
,public NonEmpty
{
};
static_assert(sizeof(NonEmpty) + sizeof(Empty1) + sizeof(Empty2) == 6);
static_assert(sizeof(int) == 4);
static_assert(sizeof(MyClass1) == 4);
static_assert(sizeof(MyClass2) == 4);
static_assert(sizeof(MyClass3) == 4);
int main() {}struct Empty {
void zero() { std::memset(this, 0, sizeof(*this)); }
};struct CompressedPair : Empty {
CompressedPair(Empty e, bool x) : Empty(e), b(x) { }
bool b;
};
int main() {
auto a = CompressedPair({}, true);
__builtin_printf("%b\n", a.b);
a.zero();
__builtin_printf("%b\n", a.b);
return 0;
}1 0(да, да, это UB, я знаю, прекратите. Мы тут поржать собрались или где?) Но где-то тут в безумии зараждается идея... У нас же есть
no_unique_address.
А на gcc он кладет данные в padding других структур.
#include <iostream>
template <typename T>
struct optional {
union {
char foo;
T val;
};
[[no_unique_address]] bool engaged;
};
template <typename View>
struct reverse_view {
[[no_unique_address]] optional<typename View::iterator> cache;
View base_;
};
struct MyView {
using iterator = int*;
char begin_;
};
int main() {
std::cout << "sizeof = " << sizeof(reverse_view<MyView>) << std::endl; // clang - 24, gcc - 16
std::cout << "alignof = " << alignof(reverse_view<MyView>) << std::endl;
}Ладно, разумеется прошлый пост был набросом.
Никогда не обновляйте компиляторы без очень серьезных на то причин. Мало ли что там сломается, а у вас не будет команды все это чинить.
Вот к примеру.
Вложенные лямбды с параметр паком.
#include <utility>
template <std::size_t N, std::size_t M>
concept C = requires {
[]<std::size_t... Is>(std::index_sequence<Is...>)
requires requires {
[]<std::size_t... Js>(std::index_sequence<Js...>)
requires requires { true; }
{}(std::make_index_sequence<M>{});
}
{}(std::make_index_sequence<N>{});
};
static_assert(C<2, 3>);
Убедительная просьба - обновляйте компиляторы.
Помимо внедрения множества способов выстрелить себе в ногу, новые версии компиляторов чинят разные веселые баги.
Вот к примеру вот этот код:
struct S {
int x;
auto foo() {
return [*this](this auto&& self) {
__builtin_printf("%d ", x);
x = 10;
};
}
};foo капчурит this, и потом модифицирует значение. Но что будет, если метод будет вызван у константного класса?
int main() {
S s{ 5 };
const auto l = s.foo();
l();
s.x = 15;
l();
__builtin_printf("%d\n", s.x);
}
Я сначала подумал, что надо на такие мероприятия футболку брать с QR кодом канала на спине, пиарить канал на конфе.
А потом подумал: меня же спалят как админа этого канала... Свят-свят-свят.
P.S. новый пост зашедулен на завтра :)
Те, кто со мной регулярно общаются, знают, что я ненавижу сраный move.
И всю move семантику. И у меня даже готовился доклад про то, как я его ненавижу, с кучей веселых примеров, которые не приехали еще сюда в дурку. Где я собрал в кучку почему именно я его ненавижу, но там получилось очень много и очень неструктурированно, поэтому доклад до сих пор в разработке.
Но вот один пример, который я выкину таки сюда.
int main() {
std::map<int, std::unique_ptr<int>> m;
m.emplace(1, std::make_unique<int>(42));
auto p = std::make_unique<int>(100);
auto [it, inserted] = m.emplace(std::make_pair(1, std::move(p)));
}
Return value A pair consisting of an iterator to the inserted element (or to the element that prevented the insertion) and a bool value set to true if and only if the insertion took place.Ну и вот второй emplace с ключом 1 вернет false. А что же произойдет с p? Он занулится, потому что мы его мувнули в функцию.
int main() {
std::map<int, std::unique_ptr<int>> m;
m.emplace(1, std::make_unique<int>(42));
auto p = std::make_unique<int>(100);
auto [it, inserted] = m.emplace(std::make_pair(1, std::move(p)));
std::cout << std::boolalpha;
std::cout << "inserted = " << inserted << '\n';
std::cout << "p is null = " << (p == nullptr) << '\n';
std::cout << "*it->second = " << *it->second << '\n';
}
inserted = false p is null = true *it->second = 42Тоесть в мапу значение не поместили, а из указателя оно пропало... Восхитительно. Притом что если делать std::move "на месте" такого не происходит.
int main() {
auto p = std::make_unique<int>(100);
std::move(p);
std::cout << std::boolalpha;
std::cout << "p is null = " << (p.get() == nullptr) << '\n';
}
p is null = false
make_pair, но это в тестовом примере, где это легко заметить. И когда уже знаешь проблему.
Я задолбался ловить такие приколы с move.Приятно видеть, что C++ настолько тщательно следит за обратной совместимостью.
Мы столько боли ради этой обратной совместимости пережили.
И теперь вдвойне приятно видеть, что поменяться может семантика вообще всего что угодно.
Например, вот это:
decltype(auto) f(int&& x)
{
return (x);
}
static_assert(std::same_as<decltype(f(1)), int&>);
Вместо дурки я сегодня продолжаю пересматривать доклад великолепного Константина Владимирова.
Жду не дождусь, когда он появится в открытом доступе, чтобы поскидывать интересные таймкоды. Это будет легко, просто скриптом каждые две минуты написать....
Вместо дурки хочу поделиться интересной конструкцией, о которой до этого не знал, но почерпнул из того доклада.
Пусть у нас есть класс:
template<typename T>
struct S {
S(T) {
std::cout << "S(T)" << std::endl;
}
template<typename Iter>
S(Iter beg, Iter end) {
(beg); (end);
std::cout << "S(Iter beg, Iter end)" << std::endl;
}
};
int a = 3;
auto s1 = S(a);
static_assert(std::same_as<decltype(s1),
S<int>>
);
std::vector<double> v;
auto s2 = S(v.begin(), v.end());
error: no viable constructor or deduction guide for deduction of template arguments of 'S'Что довольно логично. Но оказывается, есть возможность указать "хинт" для того, какой тип должен выводить конструктор класса!
template<typename Iter>
S(Iter, Iter)
-> S<typename std::iterator_traits<Iter>::value_type>;
std::vector<double> v;
auto s2 = S(v.begin(), v.end());
static_assert(std::same_as<decltype(s2),
S<double>>
);
#include <concepts>
struct Charmander {};
struct Charmeleon {};
struct Charizard {};
template<typename Form>
struct Pokemon {
Pokemon(Form) {}
template<typename OtherForm>
Pokemon(const Pokemon<OtherForm>&) {}
};
Pokemon(const Pokemon<Charmander>&)
-> Pokemon<Charmeleon>;
Pokemon(const Pokemon<Charmeleon>&)
-> Pokemon<Charizard>;
Pokemon(const Pokemon<Charizard>&)
-> Pokemon<Charmander>;
int main() {
Pokemon p1 = Charmander{};
Pokemon p2 = p1;
Pokemon p3 = p2;
Pokemon p4 = p3;
static_assert(std::same_as<
decltype(p1),
Pokemon<Charmander>
>);
static_assert(std::same_as<
decltype(p2),
Pokemon<Charmeleon>
>);
static_assert(std::same_as<
decltype(p3),
Pokemon<Charizard>
>);
static_assert(std::same_as<
decltype(p4),
Pokemon<Charmander>
>);
}Ой, я когда-нибудь брошу этот сраный язык.
Давайте разберем по шагам.
int main() {
Box b;
b->hi();
}
Box, иииии... вызываем у него оператор ->, а у того, что он вернет вызывает функцию hi(). Логично? Логично!
Смотрим, что такое у нас тип Box.
struct Box {
Proxy operator->() {
return {};
}
};
hi(). Логично? Логично.
Смотрим, что такое структура Proxy.
struct Proxy {
Leaf* operator->() {
static Leaf x;
return &x;
}
};
hi() нет. Ошибка компиляции. Логично? А хрен там плавал.
Уберите детей от мониторов.
Вот этот код компилируется и выводит ok
#include <iostream>
struct Leaf {
void hi() { std::cout << "ok"; }
};
struct Proxy {
Leaf* operator->() {
static Leaf x;
return &x;
}
};
struct Box {
Proxy operator->() {
return {};
}
};
int main() {
Box b;
b->hi();
}
-> до самого конца. Например сработает даже вот это:
#include <iostream>
struct Leaf {
void hi() { std::cout << "ok"; }
};
struct Proxy4 {
Leaf* operator->() {
static Leaf x;
return &x;
}
};
struct Proxy3 {
Proxy4 operator->() {
return {};
}
};
struct Proxy2 {
Proxy3 operator->() {
return {};
}
};
struct Proxy {
Proxy2 operator->() {
return {};
}
};
struct Box {
Proxy operator->() {
return {};
}
};
int main() {
Box b;
b->hi();
}
Мой дорогой друг вот с этого канала о С++:
@thisnotes
Прислал мне просто восхитительную вещь.
Давайте посмотрим вот на этот код
const std::vector<Obj>& vec =
(argc > 1)
? std::vector<Obj>{}
: ready_vec;
const продлевает время жизни ссылки.
Интересный факт, что вот такой код
#include <iostream>
#include <vector>
struct Obj {
explicit Obj() {}
Obj(const Obj&) {
std::cout << "copy\n";
}
};
int main(int argc) {
auto ready_vec = std::vector<Obj>{};
ready_vec.reserve(1);
ready_vec.emplace_back();
const std::vector<Obj>& vec =
(argc > 1)
? std::vector<Obj>{}
: ready_vec;
return vec.size();
}
#include <iostream>
#include <vector>
struct Obj {
explicit Obj() {}
Obj(const Obj&) {
std::cout << "copy\n";
}
};
int main(int argc) {
auto ready_vec = std::vector<Obj>{};
ready_vec.reserve(1);
ready_vec.emplace_back();
const auto empty_vec = std::vector<Obj>{};
const std::vector<Obj>& vec =
(argc > 1)
? empty_vec
: ready_vec;
return vec.size();
}
const std::vector<Obj>& vec =
(argc > 1)
? std::vector<Obj>{}
: ready_vec;
Повторяю пропавший пост.
Он был о докладе Евгения Ерохина с прошедшего CppRussia. С моими пространными размышлениями о том, какие у него сложные зубодробильные доклады и как надо каждый слайд ставить на паузу и уходить получать доп образования, чтобы не терять контекст...
А пример, который хотел у него подрезать для этого канала был такой:
int fn(int a, int b) {
int res = 0;
asm volatile ("nop");
asm volatile ("nop");
asm volatile ("nop");
asm volatile ("nop");
if (a > b) { // проблемный бренч
res = std::rand();
}
res = std::max(res, a);
return res;
}
Сорян, я выяснил, что у меня давно не было публикаций... А у меня просто один пост пропал. Не могу его найти ни в отложках ни в опубликованных...
В разных новых (уже скоро будет 10 лет) стандартах иногда бывают мелкие но очень приятные изменения.
Вот такой код
#include <iostream>
int main() {
bool b = true;
b++;
std::cout << b;
}<source>:6:5: error: use of an operand of type 'bool' in 'operator++' is forbidden in C++17Вот так вот.
Вот сколько я дурки повидал (у меня канал про это целый заведен так-то !!!) но с удивлением я осознал, что вот такая штука
%:include <iostream>
int main() <%
int a<:3:> = <% 10, 20, 30 %>;
std::cout << a<:1:>;
%>
Разбираем письма читателей.
Нам прислали вот такой вот код:
#include <memory>
#include <iostream>
namespace user {
struct user_type {};
using my_type = std::shared_ptr<user_type>;
void tie(my_type const&, my_type const&)
{
std::cout << "user::tie\n";
}
void oups()
{
my_type t1;
my_type t2;
tie(t1, t2);
}
} // namespace user
int main()
{
user::oups();
}
Program returned: 0Для MSVC x64 запишется
Program returned: 0 user::tieА для MSVC x86 вообще случится страшное:
Program returned: 3221225595Ну и чтобы не оставлять предложку совсем уж без изменений, я добавлю от себя немного дурки. Если в вызов функции добавить скобки:
void oups()
{
my_type t1;
my_type t2;
(tie)(t1, t2);
}
Сегодняшняя рубрика называется "обычный шаблонный код, который компилируется только после жертвоприношения".
Что выведет вот этот код?
cpp
#include <iostream>
#include <vector>
template <class T>
struct LoggedVector : std::vector<T> {
void Dump() const {
if (empty()) {
std::cout << "empty\n";
return;
}
std::cout << "size = " << size() << '\n';
}
};
int main() {
LoggedVector<int> v;
v.Dump();
}
void Dump() const {
if (this->empty()) {
std::cout << "empty\n";
return;
}
std::cout << "size = " << this->size() << '\n';
}
using std::vector<T>::size;
using std::vector<T>::empty;
Не могу не поделиться самым веселым, на мой взгляд, примером из доклада великолепного Константина Владимирова. Он делал анонс доклада в своем tg канале.
Пример вот такой:
template <auto T = []{}>
struct S {};
S a; S b;
T - это лямбда. И если мы таким образом определяем переменные, то в тип S записываются разные лямбды, и у нас получаются два разных типа:
static_assert(
!std::is_same_v<decltype(a), decltype (b)>
);
S<> a, b;
static_assert(
std::is_same_v<decltype(a), decltype (b)>
);
S a, b;
Сижу на CppRussia.
Пока тут каждый второй слайд первого же доклада - кандидат на пост сюда....
Посмеемся?
#include <iostream>
#include <string_view>
struct Base {
void Set(std::string_view) { std::cout << "string\n"; }
void Set(int) { std::cout << "int\n"; }
};
struct Derived : Base {
void Set(bool) { std::cout << "bool\n"; }
};
int main() {
Derived d;
d.Set("hello");
}
