اکنون در دسترس! پژوهش تلگرام ۲۰۲۵ — مهمترین بینشهای سال 
C++: Хроники Дурки🚑
رفتن به کانال در Telegram
Очень люблю C++, но это скорее уже стокгольмский синдром. Постоянно нахожу способы стрельнуть себе в ногу.
نمایش بیشتر849
مشترکین
+624 ساعت
+697 روز
+37330 روز
آرشیو پست ها
Неожиданный пример гонки в С++.
Возьмем такой код.
struct Task {
virtual ~Task() = default;
virtual void run() = 0;
};
class AutorunTask : public Task {
public:
AutorunTask() : t_([this]() {
this->run();
}) {}
~AutorunTask() { t_.join(); }
private:
std::thread t_;
};
struct Impl : public AutorunTask {
void run() override {
puts("The string");
}
};
int main(){
Impl impl;
std::this_thread::sleep_for(1ms);
}
Program returned: 0 The stringНо зачем мы поставили sleep в конце? Дело в том, что если его закомментировать, то код упадет с ошибкой.
Program returned: 139 pure virtual method called terminate called without an active exception Program terminated with signal: SIGSEGVИтак. Давайте разбираться. Можно ли вообще в конструкторе/деструкторе использовать виртуальные функции? Смотрим paragraph 4 [ISO/IEC 14882-2014]
Member functions, including virtual functions, can be called during construction or destruction. When a virtual function is called directly or indirectly from a constructor or from a destructor, including during the construction or destruction of the class’s non-static data members, and the object to which the call applies is the object (call it x) under construction or destruction, the function called is the final overrider in the constructor’s or destructor’s class and not one overriding it in a more-derived class. If the virtual function call uses an explicit class member access and the object expression refers to the complete object of x or one of that object’s base class subobjects but not x or one of its base class subobjects, the behavior is undefined.Тоесть, можно. Что же они запускают? Ведь функция в классе-наследнике может обращаться к несконструированному классу? На самом деле, в конструкторе и деструкторе вызывается реализация "текущего" класса. Смотрим пример.
struct A {
virtual void f() {
puts("A");
}
A() { f(); }
};
struct B : public A {
public:
void f() override {
puts("B");
}
B() { f(); }
};
int main(){
B b;
}
Program returned: 0 A Bконструктор первого класса выведет A. Второго B. А как это достигается? На самом деле, в программе переписывается указатель в таблице виртуальных вызовов. Ооооо, вот тут и возникает гонка.
AutorunTask::~AutorunTask() [base object destructor]:
push rbx
mov rbx, rdi
lea rax, [rip + vtable for AutorunTask+16]
mov qword ptr [rdi], rax
add rbx, 8
mov rdi, rbx
call std::thread::join()@PLT
vtable for AutorunTask:
.quad 0
.quad typeinfo for AutorunTask
.quad AutorunTask::~AutorunTask() [base object destructor]
.quad AutorunTask::~AutorunTask() [deleting destructor]
.quad __cxa_pure_virtual
std::thread::_State_impl<std::thread::_Invoker<std::tuple<AutorunTask::AutorunTask()::'lambda'()>>>::_M_run() [complete object constructor]:
mov rdi, qword ptr [rdi + 8]
mov rax, qword ptr [rdi]
jmp qword ptr [rax + 16]
Ну а как еще можно было назвать канал, как не "Дурка"?
Ну сам факт, что вот такой код компилируется, запускается, а еще и не падает, и выводит 0!!!
#include <iostream>
class Test {
public:
void test() {
std::cout << this << std::endl;
}
};
Test & create()
{
return *((Test*)NULL);
}
int main()
{
Test &t = create();
t.test();
}
implicit конструирование типов вообще сплошная головная боль.
Но мой любимый лефтикус в одном из своих докладов (чет не помню, в каком, но в последние пару лет) поделился синтаксическим трюком, как их запретить.
Вот у нас есть пример.
struct Path {
Path(const std::string& p) : path(p) {}
Path(const char* p) : path(p) {}
std::string path;
};
void f(const Path& path, const std::string& mode) {
std::cout << "Path: " << path.path << std::endl;
std::cout << "Mode: " << mode << std::endl;
}
f.
У нас, казалось бы, есть защита от неправильного порядка аргументов.
f(Path("/etc/tmp"), std::string{"rw"});
// f(std::string{"rw"}, Path("/etc/tmp"));
// error: no matching function for call to 'f'
f("/etc/tmp", "rw");
f("rw", "/etc/tmp");
Немного про новые стандарты: когда я показываю какую-то упячку, часто мне говорят "просто не пользуйся вот этим...".
Например, "не пользуйся new/delete, пользуйся умными указателями".
Или "не пользуйся конструкторами с круглыми скобками, пользуйся {}. И порядок зафиксирует и от кучи проблем избавит.".
Увы, новые конструкции просто создают другое подмножество проблем.
Вот к примеру, что выведет вот такой код?
#include <iostream>
int main() {
auto a = std::string{48};
std::cout << a << std::endl;
}
0. Потому что идет неявное преобразование инта к чару. И chr(48) == '0'.
Что характерно, вот такая строчка
auto b = std::string(48); // error: no matching function for call to
#include <iostream>
int main() {
auto b = std::string(48, 48.0);
std::cout << b << std::endl;
}
000000000000000000000000000000000000000000000000Так или иначе, но у нас новые конструкции просто создают новые проблемы. Ну и самая большая проблема, когда эти вещи вызываются неявно. Человек, который прислал мне похожий пример, утверждает, что он пришел из продакшн кода.
#include <iostream>
#include <unordered_map>
int main() {
std::unordered_map<std::string, std::string> m;
double i = 65.5;
m["hello"] = i;
std::cout << m.at("hello");
return 0;
}
A. Прекрасно!Внимание, шутка!!
Умножение в С++ некоммутативно.
Вот пример:
#include <iostream>
int main() {
std::cout << (2,0 * 2,5) << std::endl; // 5
std::cout << (2,5 * 2,0) << std::endl; // ???
return 0;
}
Приколько поговорить про гадость, которую можно отловить на этапе компиляции.
Но есть разная дурка, которая аффектит рантайм, но проходит мимо всех ворнингов (иногда это ловят всякие clang-tidy и прочие PVS студии).
Вот канонический пример:
#include<iostream>
#include <map>
#include <vector>
#include <string>
using namespace std;
using Vec = vector<string>;
void f(pair<string, Vec>&& arg) {
for (const auto& v: arg.second) {
puts(v.c_str());
}
}
int main(){
auto m = map<string, Vec>{
{"first", {"1","2"}},
{"second", {"3","4","5"}},
};
for (auto&& p: m) {
f(std::move(p));
}
}
call memcpy@PLTЯ прошу прощения...? Какое копирование?! Где? И вообще весь блок выглядит подозрительно похоже на конструктор копирования:
.LBB1_84:
mov qword ptr [rsp + 56], r13
mov r14, qword ptr [rbx + 32]
mov rbp, qword ptr [rbx + 40]
cmp rbp, 16
jb .LBB1_87
lea r15, [rbp + 1]
mov rdi, r15
call operator new(unsigned long)@PLT
mov qword ptr [rsp + 56], rax
mov qword ptr [rsp + 72], rbp
jmp .LBB1_89
.LBB1_87:
test rbp, rbp
je .LBB1_106
lea r15, [rbp + 1]
mov rax, r13
.LBB1_89:
mov rdi, rax
mov rsi, r14
mov rdx, r15
call memcpy@PLT
.LBB1_90:
mov qword ptr [rsp + 64], rbp
mov r14, qword ptr [rbx + 64]
mov qword ptr [rsp + 88], r14
movups xmm0, xmmword ptr [rbx + 72]
mov r15, qword ptr [rbx + 72]
movups xmmword ptr [rsp + 96], xmm0
xorps xmm0, xmm0
movups xmmword ptr [rbx + 64], xmm0
mov qword ptr [rbx + 80], 0
cmp r14, r15
je .LBB1_98
Не буду тут показывать, но, если провести перфоманс тесты, мы тоже увидим, что тут все тормозит.
И если детально разобраться: так и есть - это конструктор копирования.
Проблема вот в этой функции:
void f(pair<string, Vec>&& arg) void f(pair<const string, Vec>&& arg) {key_type Key
mapped_type T
value_type std::pair<const Key, T>
У мну вопрос.
Есть вот такая строчка.
// Waits for 2..6 seconds.
void SymbianEngine::updateConfigurationsAfterRandomTime()
{
int iTimeToWait = qMax(1000, (qAbs(qrand()) % 68) * 100);
#ifdef QT_BEARERMGMT_SYMBIAN_DEBUG
qDebug("QNCM waiting random time: %d ms", iTimeToWait);
#endif
QTimer::singleShot(iTimeToWait, this, SLOT(delayedConfigurationUpdate()));
}Итак, один из любимых примеров дурки.
Мы заводим структуру данных, которая конструируется от аргумента типа double. И вторую структуру, которая конструируется от первой.
А дальше создадим переменную второго типа.
#include<iostream>
struct A {
double v;
explicit A(double d) : v(d) {}
};
struct B {
double v;
explicit B(A a) : v(a.v) {}
};
int main(){
double d = 3.14;
B b(A(d));
}b?
int main(){
double d = 3.14;
B b(A(d));
std::cout << b << std::endl;
}Program returned: 0 1Чта?! Ну, пришло время почитать ворнинги. И выясняем, что вот это:
B b(A(d));void f(int a);
void q(int(a));Микропост.
Что выведет этот код?
#include <stdio.h>
#include <stdlib.h>
int main() {
int *p = (int*)malloc(sizeof(int));
int *q = (int*)realloc(p, sizeof(int));
if (p == q) {
*p = 1;
*q = 2;
printf("%d %d\n", *p, *q);
}
}Program returned: 0 Program stdout 2 2А clang и icc выведут
Program returned: 0 Program stdout 1 2Но вообще, это просто типичный UB. p после реаллока становится невалидным указателем. Из хорошего - gcc это ловит со включенным
Wall.Дисклеймер: я не претендую на невероятною новизну фактов. Я просто показываю всем известные примеры, на которые натыкаюсь раз за разом, раз за разом....
Вот еще один прекрасный пример такой гадости.
#include<iostream>
int main(){
int a, b;
int* p = &a;
int* q = &b + 1;
std::cout << std::hex
<< "p: " << p << "\n"
<< "q: " << q << "\n"
<< std::endl;
}
O1 включительно (после O2 начинаются вопросы на gcc) то переменные будут объявлены "по порядку", и это будут одинаковые указатели. Просто сравниваем посимвольно.
clang: Program returned: 0 p: 0x7ffdfaf2696c q: 0x7ffdfaf2696c gcc: Program returned: 0 p: 0x7ffca3076f0c q: 0x7ffca3076f0cВнимание, вопрос! Что будет, если мы сравним два одинаковых указателя?
#include<iostream>
int main(){
int a, b;
int* p = &a;
int* q = &b + 1;
std::cout << std::hex
<< "p: " << p << "\n"
<< "q: " << q << "\n"
<< std::endl;
std::cout << (p == q ? "equal" : "not equal")
<< std::endl;
}
clang: Program returned: 0 p: 0x7ffd6bd0d16c q: 0x7ffd6bd0d16c equal gcc: Program returned: 0 p: 0x7ffe3c48696c q: 0x7ffe3c48696c not equalИ на самом деле - никаких противоречий со стандартом. Это просто Unspecified (даже не Undefined) Behavior. Не буду раскрывать всю подноготную, легко этот пример найти где-нибудь на хабре. Вопрос другой: вот когда на собеседовании в очередной раз задают вопросы типа "разверни список", или "проверь бинарное дерево на наличие циклов". Вот что будет, если выдать в ответ собеседующему этот пример, и попросить доказать, что сравнение указателей в случае такого дерева/списка будет вообще работать? Без него же такую задачу не решить? И посмотреть, как хорошо справится с ответом на этот вопрос тот, кто в очередной раз предложит развернуть список. Хотя, разумеется, можно написать как-то так
int a, b;
auto p = reinterpret_cast<uintptr_t>(&a);
auto q = reinterpret_cast<uintptr_t>(&b + 1);
std::cout << std::hex << p << "\n" //
<< q << "\n" //
<< std::dec << (p == q) << std::endl; //Микропостик.
Угадайте, что делает вот такой код?
union S {
long long int number;
bool yes : sizeof(long long int);
};#include <iostream> union is_odd { long long int number; bool yes : sizeof(long long int); }; int main() { std::boolalpha(std::cout); for (long long int i = -10; i < 10; ++i) { std::cout << i << " is odd? " << is_odd{ .number = i }.yes << "\n"; } }Вывод
-10 is odd? false -9 is odd? true -8 is odd? false -7 is odd? true -6 is odd? false -5 is odd? true -4 is odd? false -3 is odd? true ...Только способом из дурки.
Возвращаемся к нашему военному синусу.
Любимый пример, связанный с ним, после которого хочется переехать в комнату с мягкими стенами.
#include <iostream>
#include <cmath>
double
__attribute((weak))
sin(double x) { return 1.5; }
int main() {
std::cout << "double: " << std::sin(double(0.5)) << std::endl;
std::cout << "integer: " << std::sin(int(0)) << std::endl;
}
Program returned: 0 double: 0.479426 integer: 0Да, мы объявили какой-то синус в глобальном неймспейсе, который выдает какую-то дичь. Но мы вызываем синусы из стандартной библиотеки, значит все должно быть хорошо. Ну да ладно, давайте ничего не заменим, только закомментируем последнюю строчку.
#include <iostream>
#include <cmath>
double
__attribute((weak))
sin(double x) { return 1.5; }
int main() {
std::cout << "double: " << std::sin(double(0.5)) << std::endl;
// std::cout << "integer: " << std::sin(int(0)) << std::endl;
}
Program returned: 0 double: 1.5Как так? Почему эта строчка повлияет на поведение предыдущей? А вот, особенности порядка применения оптимизаций icc. Добро пожаловать к нам в дурку.
Первым постом в этом канале станет тот, с которого зародилось название канала.
Долгие разборы "военного синуса" привели меня к квинтессенции проблем, после которых я сумел сконструировать несколько абсолютно отвратительных примеров выстрелов себе в ногу.
#include <iostream>
#include <cmath>
double sin(std::string x) { return 1.5; }
int main() {
std::cout << "string: " << std::sin(std::string{"0.5"}) << std::endl;
}
<source>:7:40: error: no matching function for call to 'sin(std::string)'Что логично. Мы, конечно, объявили синус от строки, но в глобальном пространстве имен. А вызываем
std::sin из пространства имен std, и там такого синуса, очевидно, нет.
Но давайте поменяем местами объявление синуса и заголовок cmath. (можем считать, что у нас есть какой-то локальный заголовок, куда такое объявление просочилось)
#include <iostream>
double sin(std::string x) { return 1.5; }
#include <cmath>
int main() {
std::cout << "string: " << std::sin(std::string{"0.5"}) << std::endl;
}
Program returned: 0 string: 1.5А все почему? Правильно, потому что в заголовке cmath (во многих реализациях на linux) есть вот такая строчка:
using ::sin;
