Грокаем C++
Відкрити в Telegram
Два сеньора C++ - Владимир и Денис - отныне ваши гиды в этом дремучем мире плюсов. По всем вопросам (+ реклама) @ninjatelegramm Менеджер: @Spiral_Yuri Реклама: https://telega.in/c/grokaemcpp Мы на TGstat: https://tgstat.ru/channel/@grokaemcpp/stat
Показати більше9 357
Підписники
-124 години
+147 днів
+1430 днів
Архів дописів
9 357
std::allocate_shared
#опытным
В одном из прошлых постов мы упоминали, что одним из недостатков std::make_shared является то, что с ней нельзя использовать кастомный менеджмент памяти.
Причиной является то, что для выделения памяти она использует глобальный new. Поэтому и для освобождения памяти должна использовать глобальный delete. Здесь нет места кастомщине.
Но что, если нам очень нужно по-особенному работать с памятью для объекта? Даже хотя бы просто отслеживать выделение и разрушение без влияния на глобальный delete?
Тут на помощью приходит функция std::allocate_shared. Первым аргументом она принимает аллокатор, который и будет ответственен за выделение и освобождение памяти.
Вот вам простой примерчик с простым STL-совместимым аллокатором, логирующим операции выделения и освобождения памяти:
template <typename T>
class LoggingAllocator {
public:
using value_type = T;
using pointer = T *;
using const_pointer = const T *;
using reference = T &;
using const_reference = const T &;
using size_type = std::size_t;
using difference_type = std::ptrdiff_t;
template <typename U>
struct rebind {
using other = LoggingAllocator<U>;
};
LoggingAllocator() noexcept = default;
template <typename U>
LoggingAllocator(const LoggingAllocator<U> &) noexcept {}
pointer allocate(size_type n) {
size_type bytes = n * sizeof(T);
std::cout << "Allocating " << n << " elements ("
<< bytes << " bytes)\n";
return static_cast<pointer>(::operator new(bytes));
}
void deallocate(pointer p, size_type n) noexcept {
size_type bytes = n * sizeof(T);
std::cout << "Deallocating " << n << " elements ("
<< bytes << " bytes)\n";
::operator delete(p);
}
};
template <typename T, typename U>
bool operator==(const LoggingAllocator<T> &,
const LoggingAllocator<U> &) noexcept { return true; }
template <typename T, typename U>
bool operator!=(const LoggingAllocator<T> &,
const LoggingAllocator<U> &) noexcept { return false; }
class MyClass {
public:
MyClass(int value) : value(value) {
std::cout << "Constructed with " << value << "\n";
}
~MyClass() {
std::cout << "Destroyed with " << value << "\n";
}
void print() const {
std::cout << "Value: " << value << "\n";
}
private:
int value;
};
int main() {
LoggingAllocator<MyClass> alloc;
auto ptr = std::allocate_shared<MyClass>(alloc, 42);
ptr->print();
return 0;
}
// OUTPUT:
// Allocating 1 elements (24 bytes)
// Constructed with 42
// Value: 42
// Destroyed with 42
// Deallocating 1 elements (24 bytes)
Стандартом на аллокаторы накладываются определенные требования: нужно определить нужные алиасы, методы allocate и deallocate, структуру rebind и соответствующий конструктор копирования и операторы сравнения. Полный список требований можно прочитать тут.
По консольному выводу видно, что аллокатор выделяет немного больше памяти, чем должен занимать объект. Это сделано в том числе для того, чтобы хранить в выделенном куске еще и контрольный блок std::shared_ptr. Так что касаемо особенностей аллокации и деаллокации тут похожая ситуация с std::make_shared.
Аллокатор кстати хранится в том же контрольном блоке, так что информация о способе деаллокации берется оттуда.
Customize your solutions. Stay cool.
#cppcore #STL #memory12 вер 2025, 04:10
9 357
Выгорание, кризис, конец карьеры – оно вам надо?
Из рубрики «невыдуманные истории»: работал 24/7, терпел негатив дома, а потом остался без всего.
По статистике, 90% IT-специалистов сталкиваются с выгоранием. Живут, сжав зубы, пока не становится тошно вообще от всего.
📍 Чтобы не доводить себя до такого состояния или выбраться из него, если уже накрыло, подписывайтесь на канал Психолог взрослого человека.
Рабочие методы по выходу из кризисов, выгорания и вытекающих из этого проблем для тех, кто забывает про себя.
— Для опытных сотрудников, которые взвалили на себя непосильный груз задач
— Для сильных руководителей, которые забыли, что, вообще-то, тоже живые люди
Подписывайтесь на @vadimpetrovpsi и начните с закрепа.
Там вас ждет бесплатный мини-курс «Саморегуляция». Он поможет начать работать с апатией и сделать первый шаг по возвращению к жизни.
12 вер 2025, 02:10
14 вер 2025, ~02:10
9 357
Zero-Cost Abstraction. Или нет?
#опытным
Концепция бесплатных абстракций-то есть. Но концепции они обычно в банках-консервах хранятся. В реальности все немного сложнее и бесплатный только труд стажеров в современном IT.
Вот как много из вас думает, что уникальный указатель - это бесплатная абстракция? Думаю, что очень многие. Но давайте посмотрим на реальность.
Для чего используется уникальный указатель? Чтобы избавиться от сырых указателей, снять головную боль по освобождению памяти и четко показать в коде передачу владения. То есть такой код:
void bar(int *ptr);
// Takes ownership
void baz(int ptr);
void foo(int ptr) {
if (ptr > 42) {
bar(ptr);
ptr = 42;
}
baz(ptr);
}
хорошо бы переписать с использованием std::unique_ptr:
void bar(int ptr);
// Takes ownership.
void baz(std::unique_ptr<int> ptr);
void foo(std::unique_ptr<int> ptr) {
if (ptr > 42) {
bar(ptr.get());
ptr = 42;
}
baz(std::move(ptr));
}
Будет ли здесь оверхэд рантайма? Ох-ох-ох, еще как!
Вот асм для первого сниппета:
foo(int):
cmpl $43, (%rdi)
jl baz(int)@PLT
pushq %rbx
movq %rdi, %rbx
callq bar(int)@PLT
movq %rbx, %rdi
movl $42, (%rbx)
popq %rbx
jmp baz(int)@PLT
А вот для второго:
foo(std::unique_ptr<int, std::default_delete<int>>):
pushq %rbx
subq $16, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
cmpl $43, (%rdi)
jl .LBB0_2
callq bar(int)@PLT
movq (%rbx), %rdi
movl $42, (%rdi)
.LBB0_2:
movq %rdi, 8(%rsp)
movq $0, (%rbx)
leaq 8(%rsp), %rdi
callq baz(std::unique_ptr<int, std::default_delete<int>>)@PLT
movq 8(%rsp), %rdi
testq %rdi, %rdi
je .LBB0_5
movl $4, %esi
callq operator delete(void, unsigned long)@PLT
.LBB0_5:
addq $16, %rsp
popq %rbx
retq
movq %rax, %rbx
movq 8(%rsp), %rdi
testq %rdi, %rdi
je .LBB0_8
movl $4, %esi
callq operator delete(void, unsigned long)@PLT
.LBB0_8:
movq %rbx, %rdi
callq _Unwind_Resume@PLT
Он в 4 раза больше! Если внимательно присмотреться, то можно увидеть, что значительная часть кода здесь тратится на подчищение памяти и обработку исключений. Да, исключения - это вещь, где RAII очень сильно помогает. Вот вам ссылочки на годболт: тык и тык
Но предположим, что изначальный код был корректным и там не вылетало никаких исключений. Пометим функции как noexcept:
void bar(int *ptr) noexcept;
void baz(std::unique_ptr<int> ptr) noexcept;
void foo(std::unique_ptr<int> ptr) {
if (ptr > 42) {
bar(ptr.get());
ptr = 42;
}
baz(std::move(ptr));
}
Вот асм:
foo(std::unique_ptr<int, std::default_delete<int>>):
pushq %rbx
subq $16, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
cmpl $43, (%rdi)
jl .LBB0_2
callq bar(int)@PLT
movq (%rbx), %rdi
movl $42, (%rdi)
.LBB0_2:
movq %rdi, 8(%rsp)
movq $0, (%rbx)
leaq 8(%rsp), %rdi
callq baz(std::unique_ptr<int, std::default_delete<int>>)@PLT
movq 8(%rsp), %rdi
testq %rdi, %rdi
je .LBB0_4
movl $4, %esi
callq operator delete(void, unsigned long)@PLT
.LBB0_4:
addq $16, %rsp
popq %rbx
retq
Стало чуть меньше, но это явно не zero-cost.
Любую проблему можно решить с помощью введения дополнительного уровня индирекции, но эти индирекции накладывают свои косты.
Этот пост не для того, чтобы не пользоваться абстракциями. Просто у всего есть цена и надо это осознавать и в жизни, и при написании программ.
Be aware about costs. Stay cool.11 вер 2025, 05:00
9 357
Zero-Cost Abstractions
#новичкам
Нельзя в промышленных масштабах писать код без абстракций. Вряд ли вы за обозримое время напишите даже эхо-сервер на ассемблере. Даже сам язык программирования - это абстракция. Он позволяет писать программы более-менее на английском языке(или на патриотическом Русском на 1С).
Абстракции упрощают программирование. А что с перфомансом?
Гипотеза такова, что чем выше уровень абстракции, тем выше косты производительности в рантайме.
Это например четко видно на примере ООП. ООП и ООДизайн позволили нам создать почти весь софт, которым мы пользуемся. Но на вызов виртуальных функций накладывается большой дебафф: компилятор во время компиляции не знает конкретных типов и приходится использовать индиректные вызовы с помощью таблицы виртуальных функций. Никакого инлайнинга да и хотя бы конкретных фиксированных адресов.
Однако есть и такие абстракции, которые не накладывают оверхэд на рантайм! Они называются Zero-Cost абстракциями.
И это чуть ли не основаная философия программирования на С++. Мы можем играться с уровнями абстракции, писать самый отдаленный от железа код и за все это мы ничего не платим! Компилятор своим мегамозгом анализирует на код, выполняет кучу оптимизаций и на выходе получаем быструю, высокопроизводительную конфетку.
За примерами долго ходить не надо. Можно сложить элементы вектора руками, а можно использовать std::accumulate:
void foo(std::vector<int>& vec) {
int sum = 0;
for(int i = 0; i < vec.size(); i++) {
sum += vec[i];
}
std::cout << sum;
}
void bar(std::vector<int>& vec) {
int sum = std::accumulate(vec.begin(), vec.end(), 0);
std::cout << sum;
}
При этом для обоих вариантов генерируется почти идентичный код. И это с использованием итераторов и прочих прелестей стандартных контейнеров.
На каких китах стоит возможность использовать "бесплатные" абстракции в С++?
🐳 Полиморфизм времени компиляции, compile-time вычисления и метапрограммирование. Тут все просто: переносим вычисления с рантайма в компайл тайм с помощью шаблонов, constexpr и меты и радуемся жизни. Параллельно можно еще и кофеек себе заваривать, пока проект билдится.
🐳 Инлайнинг. Одна из основных оптимизаций компилятора. Позволяет встраивать код функции в вызывающий код. С помощью инлайнинга 4 вложенных вызова функций могут превратиться в одну сплошную портянку низкоуровневого кода без дорогостоящих инструкций call.
🐳 Другие оптимизации. Компилятор дополнительно выполняет кучу оптимизаций: переставляет инструкции, подставляет известные значения сразу в код, обрезает ненужные инструкции, векторизует циклы и тд. Все они нужны для одной цели - ускорение кода.
Объединяя эти механизмы, C++ стремится обеспечить абстракции высокого уровня, которые можно использовать для написания выразительного и читаемого кода, сохраняя при этом производительность сравнимую с более низкоуровневым кодом, написанным например на С.
Don't pay for abstraction. Stay cool
#cppcore #compiler09 вер 2025, 06:00
9 357
🚀 Хотите писать надежный C++-код без утечек и с грамотной работой с ресурсами? Приглашаем на открытый вебинар:
«Поддержка идиомы RAII средствами стандартной библиотеки C++»
📅 11 сентября в 20:00 (МСК)
На вебинаре от курса «C++ Developer. Basic» разберёмся, как использовать идиому RAII (Resource Acquisition Is Initialization) для автоматического управления ресурсами:
- Что такое идиома RAII и зачем она нужна
- Как применять её для работы с памятью, файлами и потоками
- Как избежать утечек и упростить обработку исключений
- Практика: использование средств стандартной библиотеки для управления ресурсами
📈 Вы научитесь использовать стандартные инструменты C++ для более безопасной и предсказуемой работы с ресурсами - без лишнего кода и с максимальной эффективностью.
Узнайте, как писать чистый и надёжный C++-код с первого дня.
📲 Регистрируйтесь - участие бесплатно: https://otus.pw/rHKE/
Реклама. ООО «Отус онлайн-образование», ОГРН 1177746618576, www.otus.ru
09 вер 2025, 03:00
15 вер 2025, ~14:48
9 357
Inline виртуальные методы
#опытным
В догонку предыдущего поста. Если можно сделать обычные методы inline, то можно и виртуальные сделать. Что это изменит?
Ну то есть такая иерархия:
class Base {
public:
virtual int foo() = 0;
protected:
int x = 2;
};
class Derived : public Base {
public:
int foo() override {
x *= 2;
return x;
}
};
Получим ли мы какой-то профит от того, что виртуальные методы теперь inline?
Посмотрим на такой код:
void simple() {
Derived d;
std::cout << d.foo();
}
Конечно же метод будет встраиваться в вызывающий код. Компилятор на этапе компиляции четко знает тип, с которым он работает, и может проводить оптимизации.
Но вообще говоря, это далеко не основной кейс использования виртуальных методов. Давайте ближе к реальной задаче:
void vec_base(std::vector<std::unique_ptr<Base>>& my_vec) {
for (auto &p : my_vec) {
std::cout << p->foo();
}
}
// другая TU
std::vector<std::unique_ptr<Base>> my_vec;
my_vec.push_back(new Derived());
vec_base(my_vec);
Здесь все понятно. Компилятор реально не знает, какие типы находятся внутри my_vec в функции vec_base. Поэтому все, что он может сделать - это использовать указатель на таблицу виртуальных функций и пусть рантайме уже решается, какой конкретно метод вызвать.
Теперь посмотрим такой код:
void vec_derived(std::vector<std::unique_ptr<Derived>>& my_vec) {
for (auto &p : my_vec) {
std::cout << p->foo();
}
}
// другая TU
std::vector<std::unique_ptr<Derived>> my_vec;
my_vec.push_back(new Derived());
vec_base(my_vec);
И здесь тоже не инлайнится код! Хотя компилятор же видит, что Derived - это единственный наследник.
Но на деле это может быть не так. Единица трансляции с vec_derived может не знать о наследниках уже Derived класса, которые определены отдельно. Компилятор не может достоверно доказать, что у Derived нет наследников, поэтому и не может инлайнить код. Опять vtable и оверхэд.
И здесь в игру вступает ключевое слово final и девиртуализация вызовов, о которой мы говорили тут и тут. Пометив класс как final, мы можем ожидать, что компилятор поймет, что никаких наследников у него нет. Поэтому он может встраивать вызов метода foo для Derived класса в последнем примере.
Вот код на годболте с последними примерами и final девиртуализацией. Немного упростил его, чтобы легче было ассемблер читать.
Правды ради стоит сказать, что для девиртуализации нужны очень особенные условия, которых сложно достичь, используя стандартные практики программирования и паттерны ООП.
Учитывая, что
1️⃣ виртуальные функции обычно довольно громоздкие(их код будет генерится во всех единицах трансляции, что раздувает бинарь)
2️⃣ операции над непосредственно типами наследниками не распространены
3️⃣ а для девиртуализации нужно танцевать с бубнами
от определения чуть сложных виртуальных методов внутри класса могут быть только проблемы. Поэтому например в Chromium гайдлайнах четко прописано, что запрещены инлайн определения виртуальных методов. Все уносим в цпп.
Be useful. Stay cool.
#cppcore #OOP #design08 вер 2025, 07:00
9 357
Repost from Карьера в Bell Integrator
+5
Они про скорость и многозадачность: асинхронные сетевые фреймворки для C++ 🚀
Когда дело доходит до обработки тысяч запросов, в бой вступает асинхронное программирование. Здесь потоки не блокируются при сетевых запросах или работе с файлами — они продолжают выполнять другие задачи.
Сравнительный анализ популярных С++ фреймворков, работающих как раз по такой парадигме, уже в карточках. Сделали, кстати, совместно с каналом Грокаем C++: там много полезного для разработчиков си-плюс-плюс, так что заходите!
#BellintegratorTeam #советыBell
06 вер 2025, 07:09
9 357
Методы, определенные внутри класса
#новичкам
Вы хотите написать header-only библиотеку логирования и собственно пишите:
// logger.hpp
namespace SimpleLogger {
enum class Level { Debug, Info, Warning, Error };
class Logger {
public:
Logger(const Logger &) = delete;
Logger &operator=(const Logger &) = delete;
static Logger &GetInstance() {
static Logger instance;
return instance;
}
void SetMinLevel(Level level) {
std::lock_guard lock(m_mutex);
m_minLevel = level;
}
void Log(Level level, const std::string &message) {
if (level < m_minLevel)
return;
auto time = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
std::lock_guard lock{m_mutex};
std::cout << "[" << std::put_time(std::localtime(&time), "%Y-%m-%d %H:%M:%S") << "] " << "["
<< levelToString(level) << "] " << message << std::endl;
}
private:
Logger() : m_minLevel(Level::Info) { Log(Level::Info, "Logger initialized"); }
Level m_minLevel;
std::mutex m_mutex;
std::string levelToString(Level level) {
switch (level) {
case Level::Debug: return "DEBUG";
case Level::Info: return "INFO";
case Level::Warning: return "WARN";
case Level::Error: return "ERROR";
default: return "UNKNOWN";
}
}
};
} // namespace SimpleLogger
Ваши пользователи вызывают из одной единицы трансляции метод Log:
...
#include <logger.hpp>
...
using namespace SimpleLogger;
Logger::GetInstance().Log(Level::Info, "Select recent items");
db->Execute("Select bla bla");
...
И из второй:
...
#include <logger.hpp>
...
using namespace SimpleLogger;
if (!result) {
Logger::GetInstance().Log(Level::ERROR, "Result is empty");
throw std::runtime_error("Result is empty");
}
...
А потом это все успешно линкуется в один бинарник. Как так? Должно же было сработать One Definition Rule, которое запрещает иметь более одного определения функции на всю программу? А у нас как раз все единицы трансляции видят определение метода Log.
Дело в том, что все методы, определенные внутри тела класса, неявно помечены как inline. Это не значит, что компилятор встроит код этих методов в вызывающий код. Это значит, что для таких методов разрешается иметь сколько угодно одинаковых определений внутри программы. На этапе линковки выберется одна любая реализация и везде, где будет нужен адрес метода для вызова будет подставляться адрес именно этой реализации.
Так что явно использовать ключевое слово inline в этом случае бессмысленно.
Но и в обычном, не херед-онли коде, можно определять методы внутри класса. Когда это стоит делать?
Каждая единица трансляции должна сгенерировать свой код для inline метода. Это значит, что обильное использование inline методов может привести к увеличенному времени компиляции.
Однако наличие определения метода внутри класса может быть использовано компилятором для встраивания его кода в caller. Это снижает издержки на вызов метода.
Противоречивые последствия. Либо быстрый рантайм и медленный компайл-тайм, либо наоборот. Как быть?
Обычно inline делают простые и короткие методы, типа сеттеров и геттеров, а длинные методы, которые менее вероятно будут встраиваться, выносят в цпп. Короткие функции сильнее всего страдают от оверхеда на вызов, который может быть сравним с временем выполнения самой функции. Но они не засоряют собой интерфейс класса, хэдэр также легко и быстро читается. Вот такой компромисс.
Look for a compromise. Stay cool.
#cppcore #goodpractice04 вер 2025, 06:00
9 357
Как использовать std::unordered_map с ключом в виде std::pair?
#опытным
При работе над задачами C++ часто необходимо использовать сложные ключи в контейнерах на основе хэша - std::unordered_map. Распространенным подходом является использование std::pair<int, int> в качестве типа ключа. Однако попытка объявить unordered_map следующим образом:
std::unordered_map<std::pair<int, int>, int> map;
приводит к подобной ошибке компиляции:
error: call to implicitly-deleted default constructor of 'unordered_map<std::pair<int, int>, int>'Происходит это, потому что для std::pair не определена хэш-функция. Она нужна для превращения значение объекта-ключа в число, которое используется для индексации элемента в хэш-таблице. STL предоставляет нам хэш-функции для тривиальных типов данных и, например, std::string. Но для сложных шаблонных типов непонятно в общем случае, как реализовать хэш-функцию. Поэтому эту задачу и возложили на самих программистов. Нужно самим определять хэш-функцию для объекта так, как того требует конкретная задача. Ну хорошо. Определять надо. Но как это сделать? В азбуке не написано, как написать хэш для пары... Давайте по порядку. Самый тривиальный подход - просто ксорим два хэша типов пары(в предположении, что они уже есть):
namespace std {
template <typename T1, typename T2>
struct hash<pair<T1, T2>> {
size_t operator()(const pair<T1, T2>& p) const {
size_t h1 = hash<T1>{}(p.first);
size_t h2 = hash<T2>{}(p.second);
return h1 ^ h2;
}
};
}
std::unordered_map<std::pair<int, std::string>, double> map;
map[{42, "foo"}] = 3.14;
Отлично, заработало! Или нет?
Это компилируется, но есть проблема с коллизиями. Если ключом будет std::pair<int, int>, то для двух разных ключей {1, 2} и {2, 1} будут одинаковые хэши. Не очень хорошо.
Сделаем ход конем:
namespace std {
template <typename T1, typename T2>
struct hash<pair<T1, T2>> {
size_t operator()(const pair<T1, T2>& p) const {
size_t h1 = hash<T1>{}(p.first);
size_t h2 = hash<T2>{}(p.second);
return h1 ^ (h2 << 1);
}
};
}
std::unordered_map<std::pair<int, int, double> map;
Побитово сдвинем второй хэш на один бит влево. Так мы не сильно ухудшим распределение(всего один бит заменим на нолик), но уберем коллизии.
Но это конечно все на коленке сделаный велосипед. В бусте есть функция hash_combine, которая делает ровно то, что мы хотим:
namespace std {
template <typename T1, typename T2>
struct hash<std::pair<T1, T2>> {
size_t operator()(const std::pair<T1, T2>& p) const {
size_t seed = 0;
boost::hash_combine(seed, p.first);
boost::hash_combine(seed, p.second);
return seed;
}
};
}
Если хочется узнать, что там у этой штуки под капотом, что в сущности код выше будет эквивалентен следующему коду:
namespace std {
template <typename T1, typename T2>
struct hash<pair<T1, T2>> {
size_t operator()(const pair<T1, T2>& p) const {
size_t h1 = hash<T1>{}(p.first);
size_t h2 = hash<T2>{}(p.second);
return h1 ^ (h2 + 0x9e3779b9 + (h1 << 6) + (h1 >> 2));
}
};
}
Магические числа во всей красе. Но это нормально, когда мы имеем дело с математикой: генераторы случайных чисел, шифрование, хэш-функции.
Кстати, естественно, что такой подход можно использовать и для кастомных структур, и для туплов. В общем, можно пользоваться. Хотите тяните буст, хотите сами пишите, там все равно не так сложно.
Use ready-made solutions. Stay cool.
#cppcore #STL #template03 вер 2025, 06:00
9 357
📂 Ввод-вывод в C: от fopen до системных вызовов
📅 4 сентября | 20:00 мск | бесплатно
На вебинаре разберём:
📜 Стандартные функции C: fopen, fread, fwrite, printf, scanf
⚡️ Буферизацию и почему fflush() не всегда срабатывает
🛠 Системные вызовы: read, write, open vs стандартная библиотека
🚫 Как избежать типичных ошибок при работе с файлами и потоками
Полезно для:
💡 Junior-разработчиков и тех, кто хочет глубже понять подсистему I/O в C и ОС
👉 Регистрируйтесь:
https://otus.pw/Nwyv/
Занятие приурочено к старту курса "Программист С", обучение на котором позволит не только глубоко погрузиться в возможности языка С, но и изучить низкоуровневые особенности устройства UNIX-совместимых ОС и ОС семейства Windows
Реклама. ООО «Отус онлайн-образование», ОГРН 1177746618576
03 вер 2025, 03:00
06 вер 2025, ~04:43
9 357
Бага обнаружена!
#опытным
Проблема в текущей реализации
template <typename T>
class Vector {
private:
T *m_data;
T *m_endSize;
T *m_endCapacity;
public:
// Use a different type "U to support const and non-const
template <typename U>
class Iterator {
private:
U *m_ptr;
public:
Iterator(U *ptr) : m_ptr{ptr} {}
U &operator*() const { return m_ptr; }
};
template <typename Self>
auto begin(this Self &&self) {
return Iterator(self.m_data);
}
};
заключается в том, что константность не правильно распространяется через итератор при работе с const-объектами Vector. Давайте по порядку
Когда мы имеем const Vector<T>, поле m_data становится T* const (константный указатель на T), а не const T* (указатель на константный T). Так называемая синтаксическая или поверхностная константность.
В текущей реализации, когда вызывается begin() на const-объекте:
Self выводится как const Vector<T>&
self.m_data имеет тип T const
Шаблонный вывод типов в форме CTAD отбрасывает верхнеуровневую константность: для Iterator создает Iterator<T>, а не Iterator<const T>
В результате мы получаем итератор, который позволяет изменять элементы, даже когда Vector константный.
То есть, такой код становится вполне валиден:
const Vector<int> vec{1, 2, 3};
auto it = vec.begin();
*it = 2;
Что не есть хорошо.
Выходом тут будет не использовать CTAD, а явно и гибко задавать тип шаблонного параметра на основе константности self и нескольких трейтов:
template<typename Self>
auto begin(this Self&& self)
{
using value_type = std::conditional_t<
std::is_const_v<std::remove_reference_t<Self>>,
const T,
T>;
return Iterator<value_type>(std::forward<Self>(self).m_data);
}
По пути еще чуть-чуть причесываем передачу универсальной ссылки через std::forward.
Fix the problem. Stay cool.
#template #cppcore02 вер 2025, 06:01
9 357
⚓️ Стажировка C++ в Kaspersky — набор открыт!
Пишешь на С++ и ищешь стажировку, где твой код будет влиять на реальный мир?
Мы строим не просто софт, а целые флотилии систем безопасности. Наши стажеры сразу попадают на капитанский мостик и под руководством опытных штурманов решают задачи, которые определяют будущее кибербезопасности:
🚀 Разрабатываем Next Generation Firewall (NGFW)
🛡 Создаем кибериммунную KasperskyOS
⚔️ Анализируем сетевой трафик в режиме реального времени
Если ты готов не просто учиться, а сразу брать на себя ответственность и строить технологии, которые по-настоящему защищают, — бросай якорь в нашей бухте.
Откликнись на стажировку по С++ и начни карьеру с покорения цифровых морей!
Регистрируйся здесь https://kas.pr/n6hd?erid=2W5zFHos9Pv
02 вер 2025, 03:00
11 вер 2025, ~05:00
9 357
Помогите Доре найти ошибку
#опытным
А у нас новая рубрика #бага, где мы пытаемся найти нетривиальные ошибки в коде. Коллективные усилия и жаркие обсуждения в комментариях приветствуются.
Вот такой код:
template <typename T>
class Vector {
private:
T *m_data;
T *m_endSize;
T *m_endCapacity;
public:
// Use a different type "U to support const and non-const
template <typename U>
class Iterator {
private:
U *m_ptr;
public:
Iterator(U ptr) : m_ptr{ptr} {}
U &operator() const { return *m_ptr; }
};
template <typename Self>
auto begin(this Self &&self) {
return Iterator(self.m_data);
}
};
Это доморощенная и обрезанная версия вектора. Понятное дело, что здесь многого не хватает и этим нельзя пользоваться. Но зато это уже компилируется.
Тем не менее даже в таком маленьком кусочке кода есть принципиальная бага.
Сможете найти? Пишите свои варианты в комментариях.
Правильный ответ с пояснениями и фиксом будет завтра.
Deduce the error. Stay cool.01 вер 2025, 05:00
9 357
Одно значимое улучшение С++17
#опытным
У компилятора большая свобода в том, что и как он может делать с исходным кодом при компиляции.
Возьмем, например, вызов функции:
f( g(expr1, expr2), h(expr3) );В каком порядке вызываются expr1, expr2, expr3, g, h и f? Культурно западный человек интуитивно будет представлять обход в глубину слева направо. То есть порядок вычисления будет примерно такой: expr1 -> expr2 -> g -> expr2 -> h -> f. Однако это абсолютно не совпадает с тем как поступает компилятор в соответствии со стандартом. Что было до С++17? Было единственное правило: все аргументы функции должны быть вычислены до вызова функции. Все! То есть могло теоретически мог бы быть такой порядок: expr2 -> expr3 -> h -> expr1 -> g -> f. Полный бардак! И это приводило на самом деле к неприятным последствиям. Что если мы принимаем в функцию два умных указателя и попробуем вызвать ее так:
void bar(std::unique_ptr<SomeClass1> a, std::unique_ptr<SomeClass2> b) {}
bar(new SomeClass1{}, new SomeClass2{});
Какие тут могут быть проблемы?
Итоговый порядок вычислений может быть следующий:
new SomeClass1{} -> new SomeClass2{} -> std::unique_ptr<SomeClass1> -> std::unique_ptr<SomeClass2>
Что произойдет, если SomeClass2 выкинет исключение? Правильно, утечка памяти. Для объекта, созданного как new SomeClass1{}, не вызовется деструктор.
Эту проблему решали с помощью std::make_* фабрик умных указаателей:
bar(std::make_unique<SomeClass1>(), std::make_unique<SomeClass2>());
Нет сырого вызова new, а значит если из второго конструктора вылетит исключение, то первый объект будет уже обернут в unique_ptr и для него вызовется деструктор.
Это было одной из мощных мотиваций использования std::make_* функций для умных указателей.
Что стало с наступлением С++17?
f(e(), g(expr1, expr2), h(expr3));До сих пор неопределено в каком порядке вычислятся e, f и h. Или expr1 и expr2. Но четко прописано, что если компилятор выбрал вычислять expr1 первым, то он обязан полностью вычислить g прежде чем перейти у другим аргументам. Это уже примерно как обход в глубину, только порядок захода в ветки неопределен. Теперь такой код не будет проблемой:
void bar(std::unique_ptr<SomeClass1> a, std::unique_ptr<SomeClass2> b) {}
bar(new SomeClass1{}, new SomeClass2{});
потому что на момент вызова конструктора второго параметра уже будет существовать полностью созданный объект уникального указателя, для которого вызовется деструктор при исключении.
Это немного обесценило использование std::make_* функций. Но их все равно предпочтительно использовать из-за отсутствия явного использования сырых указателей.
Fix problems. Stay cool.
#cppcore #memory #cpp1730 серп 2025, 11:00
9 357
Недостатки std::make_shared. Кастомные делитеры
#новичкам
Заходим на cppreference и видим там такие слова:
This function may be used as an alternative to std::shared_ptr<T>(new T(args...)).
Также видим ее сигнатуру:
template< class T, class... Args >
shared_ptr<T> make_shared( Args&&... args );
И понимаем, что make_shared не предоставляет возможности указывать кастомный делитер. Все аргументы функции просто перенаправляются в конструктор шареного указателя.
Опустим рассуждения об оправданных кейсах применения кастомных делитеров для шареных указателей. Можете рассказать о своих примерах из практики в комментариях.
Мы же попытаемся ответить на вопрос: "А почему нельзя указать делитер?".
Одной из особенностей make_shared является то, что она аллоцирует единый отрезок памяти и под объект, и под контрольный блок. И использует базовый оператор new для этого.
Получается и деаллокация для этих смежных частей одного отрезка памяти должна быть совместная, единая и через базовый оператор delete.
Если бы мы как-то хотели бы встроить делитер в эту схему, получился бы конфликт: делитер хочет удалить только объект, но им придется пользоваться и для освобождения памяти под контрольный блок. Это просто некорректное поведение.
Да и скорее всего, если вас устраивает помещать объект в шареный указатель вызовом дефолтного new, то устроит и использование дефолтного delete. Поэтому эта проблема тесно связана с проблемой из первой части серии, но не добавляет особых проблем сверх этого.
Customize your solutions. Stay cool.
#cppcore #cpp11 #memory28 серп 2025, 06:00
9 357
Недостатки std::make_shared. Непубличные конструкторы
#новичкам
std::make_shared - это сторонний код по отношению к классу, объект которого он пытается создать. Поэтому на принципиальную возможность создания объекта влияет спецификатор видимости конструктора.
Если конструктор публичный - проблем нет, просто вызываем std::make_shared.
Но things get trickier, если конструктор непубличный. Его тогда не может вызывать никакой чужой код.
Для определенности примем, что конструктор приватный. Это может делаться по разным причинам. Например у нас есть необходимость в создании копий std::shared_ptr, в котором находится исходный объект this. Тогда класс надо унаследовать от std::enable_shared_from_this и возвращать из фабрики std::shared_ptr. Если создавать объект любым другим путем, то будет ub. Поэтому, как заботливые нянки, помогает пользователям не изменять количество отверстий в ногах:
struct Class: public std::enable_shared_from_this {
static std::shared_ptr<Class> Create() {
// return std::make_shared<Class>(); // It will fail.
return std::shared_ptr<Class>(new Class);
}
private:
Class() {}
};
Использовать make_shared здесь не выйдет. Хоть мы и используем эту функцию внутри метода класса, это не позволяет ей получить доступ к приватным членам.
В таком случае мы просто вынуждены использовать явный конструктор shared_ptr и явный вызов new.
А как вы знаете, в этом случае будут 2 аллокации: для самого объекта и для контрольного блока. Если объект создается часто, то это может быть проблемой, если вы упарываетесь по перфу.
Hide your secrets. Stay cool.
#cppcore #cpp1126 серп 2025, 06:00
9 357
🚀 Начинаете путь в C++ или хотите разобраться в основах надежной разработки? Приглашаем на открытый вебинар:
«Обработка ошибок в C++: исключения, ожидания и исключения из правил»
📅 28 августа в 19:00 (МСК)
Чем сложнее становится приложение, тем важнее правильно обрабатывать ошибки. На вебинаре от курса «C++ Developer. Basic» вы разберётесь, какие подходы существуют в C++ и когда стоит применять каждый из них:
- Классические коды ошибок - плюсы и минусы
- Современные инструменты: std::error_code, std::optional, std::variant, std::expected
- std::exception - особенности и паттерны использования
📌 Вебинар подойдёт начинающим C++ разработчикам, а также тем, кто хочет обновить или систематизировать знания.
По итогу вы получите рекомендации по выбору подхода к обработке ошибок в зависимости от проекта.
Начните разбираться в языке правильно - с опытом и поддержкой OTUS.
📲 Успейте зарегистрироваться - количество мест ограничено: https://otus.pw/RiaJ/
Реклама. ООО «Отус онлайн-образование», ОГРН 1177746618576, www.otus.ru
26 серп 2025, 03:01
30 серп 2025, ~14:25
9 357
Недостатки std::make_shared. Кастомный new и delete
#новичкам
В этой небольшой серии будем рассказывать уже о различных ограничениях при работе с std::make_shared.
И начнем с непопулярного.
Внутри себя она создает объект с помощью ::new. Это значит, что если вы для своего класса переопределяете операторы работы с памятью, то make_shared не будет учитывать это поведение, а вы будете гадать, почему не видите нужных спецэффектов:
class A {
public:
void *operator new(size_t) {
std::cout << "allocate\n";
return ::new A();
}
void operator delete(void *a) {
std::cout << "deallocate\n";
::delete static_cast<A *>(a);
}
};
int main() {
const auto a =
std::make_shared<A>(); // ignores overloads
//const auto b =
// std::shared_ptr<A>(new A); // uses overloads
}
// OUTPUT:
// Пусто!
В общем, если нужный кастомный менеджент памяти, то std::make_shared - не ваш бро.
Customize your solutions. Stay cool.
#cppcore #cpp11 #memory24 серп 2025, 08:00
9 357
Преимущества std::make_shared
#новичкам
Попсовая тема, которая часто спрашивается на собеседованиях. Краем касались ее в других постах, но пусть будет и отдельно, для удобной пересылки.
Коротко о том, что это за функция.
template< class T, class... Args >
shared_ptr<T> make_shared( Args&&... args );
Это по сути фабрика для создания шаред поинтеров из параметров конструктора разделяемого объекта. Внутри себя она производит аллокацию памяти и вызов конструктора с помощью переданных аргументов на этой памяти.
В чем же преимущества этой функции по сравнению с явным вызовом конструктора shared_ptr?
Ну для начала, она не предполагает явного использования сырых указателей. Никакого вызова new!
Сами по себе сырые указатели - это неплохо. Просто на душе спокойнее, когда их как можно меньше в современном С++ коде.
Но если new не вызывает программист, это не значит, что функция его не вызывает. Еще как вызывает. И в том, как она это делает кроется главное преимущество std::make_shared над явным вызовом конструктора.
ОООчень упрощенно внутреннее устройство std::shared_ptr выглядит вот так:
template <typename T>
struct shared_ptr {
T * obj_ptr;
ControlBlock * block_ptr;
}
Это два указателя: на сам объект и на контрольный блок, в котором находятся счетчики ссылок и некоторая другая информация.
Память под объекты, на которые указывают эти указатели, обычно выделяется раздельно:
std::shared_ptr<Foo> ptr(new Foo(arg1, arg2));
Память под объект Foo выделяется при вызове new, а память под контрольный блок выделяется внутри конструктора shared_ptr.
При явном вызове конструктора невозможно по-другому: будет две аллокации.
Но когда make_shared забирает у пользователя возможность самому вызывать конструктор, у нее появляется уникальная возможность: за один раз выделить один большой кусок памяти, в который влезет и объект, и контрольный блок:
template <typename T, typename... Args>
shared_ptr<T> my_make_shared(Args&&... args) {
// Выделяем память для ControlBlock и объекта T одним блоком
char* memory = new char[sizeof(ControlBlock) + sizeof(T)];
// Инициализируем ControlBlock в начале памяти
ControlBlock* block = new (memory) ControlBlock();
// Инициализируем объект T после ControlBlock
T* object = new (memory + sizeof(ControlBlock)) T(std::forward<Args>(args)...); // Placement new
shared_ptr<T> ptr;
ptr.obj_ptr = object;
ptr.block_ptr = block;
return ptr;
Это очень упрощенная реализация, которая показывает главный принцип: выделяется один кусок памяти под два объекта.
Отсюда повышение производительности за счет уменьшения количества аллокаций и за счет большей локальности данных и кеш-френдли структурой.
Ну и на последок.
std::shared_ptr<Foo> ptr(new Foo(arg1, arg2));
В этой записи два раза повторяется имя класса. В коде могут быть довольно длинные названия сущностей, даже при использовании алиасов. Получается в каком-то смысле явный вызов конструктора приводит к дублированию кода.
Это не происходит с std::make_shared, потому что у нас есть волшебное слово auto:
auto ptr = std::make_shared<Foo>(arg1, arg2);
Есть(было) и еще одно преимущество make_shared. Но его разберем уже отдельно, там ситуация непростая.
А на этом у нас все)
Make better tools. Stay cool.
#cppcore #memory22 серп 2025, 08:17
