C++ *

Определение

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

• блокировки (mutex);
• алгоритмы без блокировки (lockless, lock-free);
• транзакционная память.

Транзакционная память — технология синхронизации конкурентных потоков. Она упрощает параллельное программирование, выделяя группы инструкций в атомарные транзакции. Конкурентные потоки работают параллельно¹, пока не начинают модифицировать один и тот же участок памяти. К примеру, операции добавления узлов в красно-чёрное дерево (анимация в заголовке) способны работать параллельно в нескольких потоках.

Поддержка проектов, написанных на C++/CLI не является приоритетным направлением в PVS-Studio. Таких проектов достаточно мало, но тем не менее время от времени мы сталкиваемся с ними. Компания Microsoft на данный момент не планирует прекратить поддержку языка C++/CLI, поэтому мы решили всё-таки поддержать эту разновидность языка.

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

Привет, Хабрахабр!

Последнее время я не мог не обратить внимание на популярность темы Qt на хабрике, но тем не менее, в комментах продолжают встречаться люди, которые говорят откровенно лживые и непонятные вещи. Этим постом я хотел развеять малость заблуждений о Qt и рассказать, почему же ты должен пересесть со своих Java/Obj-C/.NET на мягкий и пушистый Qt.

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

Ну, что, поехали?

Меня всегда интересовали прикладные задачи обработки видеоданных в реальном времени. На Хабре я прочитал серию статей о мультимедиа фреймвоке GStreamer:

• Знакомство с GStreamer: Введение
• Знакомство с GStreamer: Источники данных
• Знакомство с GStreamer: Устройства вывода
• GStreamer: кодеки с привкусом Linux

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

Частенько нет необходимости запускать тяжеловесную IDE Visual Studio для компиляции небольших приложений, проведения каких-либо тестов кода, не требующего полномасштабной отладки. В подобных случаях можно оперативно собрать приложение в консольном режиме, используя возможности предоставляемые компилятором от Microsoft (cl.exe) и запускными модулями IDE (devenv.exe, msdev.exe). Далее приводится код файлов сценариев (cmd) интерпретатора командной строки Windows, который с небольшими изменениями каждый может настроить под себя, с учётом путей к Visual Studio в своей системе.

Программам необходимы данные. Программы выдают лишь настолько хороший результат работы, насколько полны и валидны были входные данные. Для некоторых программ входными данными являются обычные файлы или полученная из сети информация (пример — ваш браузер). Другие программы оперируют исходными кодами. Эти вторые «мета-программы» тоже нуждаются в данных. Чем они будут качественнее — тем качественнее будет и результат.

Что же за данные мы «скармливаем» таким программам? Ну, в С++ более важным чем «что?» является вопрос «когда?» (помните Морфеуса?). Программа на С++ это всего-лишь последовательность битов, которые компилятор пытается прочитать и понять. И вот в процессе этого «понимания» компилятор преобразует код на С++ в машинные инструкции и (что особенно интересно!) выполняет некоторую часть кода вашей программы. Да, мы говорим о мета-программировании на этапе компиляции.

Возвращаемся к вопросу «что?». Мы хотим иметь доступ ко всем сущностям, которые только теоретически могут быть доступны на этапе компиляции: типы, члены классов, функции, аргументы, пространства имён, номера строк кода, имена файлов — и всё это хорошо бы иметь в «чистом виде», без каких-либо странных препроцессорных хаков или использования сторонних утилит. Кроме того, хорошо бы получить и менее очевидные вещи: информацию о конвертируемости одних типов в другие, отношениям наследования и агрегации, дружественных классах и функциях и т.д.

Компилятор языка С++ уже имеет всю эту информацию! Но, к сожалению, не в доступной для мета-программирования форме. Получается странная такая ситуация — мы можем выполнить кое-какой код на этапе компиляции — но вот большинства данных у нас нет. Ну и здесь было бы логично задаться вопросом «А как же мы можем эти данные получить?».

Применительно к с++03 существует “правило трех”, с появлением с++11 оно трансформировалось в “правило 5ти”. И хотя эти правила по сути являются не более чем неформальными рекомендациями к проектированию собственных типов данных, но тем не менее часто бывают полезны. “Правило ноля” продолжает ряд этих рекомендаций. В этом посте я напомню о чем, собственно, первые 2 правила, а также попробую объяснить идею, стоящую за “правилом ноля”.

Всем привет.

В прошлую субботу — 19 апреля прошла очередная встреча C++ User Group. На этот раз мы встречались в Нижнем Новгороде.
На встречу пришло 82 человека, причём участники были не только из Нижнего Новгорода: Санкт-Петербург, Москва, Рязань, Саратов, Чебоксары, Екатеринбург, Великий Новгород. Меня немного пугает, что зарегистрировался, но не приехал участник из Иркутска. Надеюсь, с ним всё хорошо.

Мы постоянно проверяем открытые проекты на языке Си/Си++. Но почти всегда, это проекты, разрабатываемые в Visual Studio. А вот Embarcadero C++ Builder мы как-то обделили вниманием. Нужно исправляться и сегодня мы проверили проект WinSCP.

Захотелось, наконец-то(!), попробовать variadic templates, так как до сих пор привязан к 10й студии, где ничего этого нету. А чтобы долго не думать, где же можно бесполезно использовать variadic templates, пришла идея попробовать, как будет выглядеть Typelist. Для тех, кто ещё не знает, что это такое, я постараюсь объяснять по ходу дела, а тем, кому это скучно — может сразу пролистать вниз — попробуем написать подобие крестиков-ноликов с использованием Typelist.
Итак, TypeList:

В этой статье я объясню, как подключить к нашим индикаторам аргументы (часть1, часть2). За аргументы в динамической библиотеке MSX DLL программы Metastock отвечают две служебные функции: MSXNthArg и MSXNthCustomString.

Думаю многие кто работает с шаблонами, знакомы со следующей ситуацией. У нас есть некий шаблонный класс с кучей шаблонных параметров

struct deferred;
struct deadline;
struct disable;

template<class T, class Deferred = disable, class Deadline = disable>
struct some_container

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

typedef some_container<int, disable, deadline> deadline_container;
<source>
А хотелось бы 

<source lang=cpp>
typedef some_container<int, deadline> deadline_container;

А ещё лучше, что бы даже порядок задания не имел значение и следующие два, были бы эквивалентны

typedef some_container<int, deferred, deadline> full_container1;
typedef some_container<int, deadline, deferred> full_container1;

Но мы прекрасно понимаем, что как только мы поменяли два параметр у нас получится совершенно не то чего мы ожидали (это вам не tuple где порядок указание не имеет значении)
Думаю многие уже подумали о том, что всего этого можно добиться добавив прослойку между нашим типом и пользователем, для которой написать все возможные специализации. Если у вас только 2 шаблонных параметр то да, если 3 то уже сложно, а если добавится 4, 5 то пиши пропало. Да и как правило добавление нового параметра приводит к переделыванию всех предыдущих специализаций (так как в специализации мы не можем увеличивать число шаблонных параметров, а можем их только уменьшать).
Если вас заинтересовало, прошу под кат, я покажу вам как добиться этого

В этой статье будут подробно рассмотрены наша функция (часть1, часть3), правила получения данных из Metastock’а, их обработки и возврата результата обратно в Metastock. Эта информация поможет избежать ошибок в работе MSX DLL.

Metastock – наверное, самая известная программа для технического анализа рынка. Данная программа может подключать внешние библиотеки DLL, написанные пользователями для создания своих торговых стратегий, используя полную мощь традиционных языков программирования, таких как C или Паскаль.
Занявшись поиском в интернете, с удивлением обнаружил полное отсутствие информации по данной теме. Единственная статья, которая оказалась достойной внимания: “Что такое Metastock Developer's Kit?” (mdk), где описывается коротенький пример на Delphi, там же можно скачать MDK.
В данной статье я постараюсь заполнить этот пробел и описать процесс создания библиотеки внешних функций Metastock (MSX DLL) по шагам на языке C/C++. Все примеры писались в среде Visual Studio 2010 (часть2, часть3).

Как вы, наверное, догадались, эта статья посвящена lock-free очередям.

Очереди бывают разные. Они могут различаться по числу писателей (producer) и читателей (consumer) – single/multi producer — single/multi consumer, 4 варианта, — они могут быть ограниченными (bounded, на основе предраспределенного буфера) и неограниченными, на основе списка (unbounded), с поддержкой приоритетов или без, lock-free, wait-free или lock-based, со строгим соблюдением FIFO (fair) и не очень (unfair) и т.д. Подробно типы очередей описаны в этой и этой статьях Дмитрия Вьюкова. Чем более специализированы требования к очереди, тем, как правило, более эффективным оказывается её алгоритм. В данной статье я рассмотрю самый общий вариант очередей — multi-producer/multi-consumer unbounded concurrent queue без поддержки приоритетов.

19 марта 2014 года Unreal Engine 4 стал доступен для всех желающих. Цена подписки всего 19$ в месяц. Исходные коды также выложены на github репозиторий. С этого момента нам поступила масса сообщений на почту, в твиттер и так далее, с просьбой проверить этот игровой движок. Мы удовлетворяем просьбу наших читателей. Давайте посмотрим, что интересного можно найти в исходном коде с помощью статического анализатора кода PVS-Studio.

При написании юнит-тестов за правило хорошего тона считается проверка инвариантов класса посредством открытого интерфейса класса. В случае с Qt всё немного сложнее, так как функции-члены могут потенциально посылать сигналы, которые выходят «наружу» объектов и являются тем самым частью открытого интерфейса. Для этих целей в модуле QtTestLib имеется полезный класс QSignalSpy, который следит за определённым сигналом издаваемым тестируемым обьектом и скурпулёзно ведёт протокол, сколько раз и с какими значениями этот сигнал был вызван.

На Хабре недавно проскочила ещё одна статья про вычисления на шаблонах C++ от HurrTheDurr. В комментариях к ней лично я увидел вызов:

> С каждым новым релизом количество способов нетривиально вывихнуть себе мозг при помощи С++ продолжает увеличиваться)
> > Особенно, если не менять подход к реализации игрового поля и продолжать пытаться все вычисления выполнять не над константами, а над типами.

А так ли сложно будет написать универсальный вычислитель на типах, более удобный для программирования, чем клеточный автомат? Как оказалось, несложно; я в 30 раз больше времени потратил на эту статью, чем на написание и отладку собственно кода вычислителя.

Чуть раньше AveNat опубликовала введение в лямбда-исчисление в двух частях, так что вдохновение пришло мгновенно. Хотелось, чтобы можно было (образно) писать так:

#include <iostream>

#include <LC/kernel.h>
#include <LC/church_numerals.h>

int main()
{
    // Представление натуральных чисел в виде лямбда-абстракций
    typedef ChurchEncode<2> Two;    // 2 = λfx.f (f x)
    typedef ChurchEncode<3> Three;  // 3 = λfx.f (f (f x))

    // * = λab.λf.a (b f)
    typedef Lambda<'a', Lambda<'b', Lambda<'f',
                Apply<Var<'a'>, Apply<Var<'b'>, Var<'f'> > >
        > > > Multiply;

    // Вычисление (* 2 3)
    typedef Eval<Apply<Apply<Multiply, Two>, Three>> Output;

    // Переход обратно от лямбда-абстракций к натуральным числам
    typedef ChurchDecode<Output> Result;

    std::cout << Result::value;
}

А на выходе получать такое:

ilammy@ferocity ~ $ gcc cpp.cpp
ilammy@ferocity ~ $ ./a.out
6

Статья получилась несколько великоватой, так как мне хотелось рассказать обо всех интересных штуках, которые здесь используются. И ещё она требует базового набора знаний о лямбда-исчислении. Приведённых выше обзоров, среднего знания C++ (с шаблонами), и здравого смысла должно быть достаточно для понимания содержимого.

Под катом находится очередное прокомментированное конструктивное доказательство Тьюринг-полноты шаблонов C++ в виде compile-time интерпретатора бестипового лямбда-исчисления (плюс печеньки в виде макросов и рекурсии).

Зарекался больше не касаться эмуляции 3DO консоли, каюсь. Но тут у меня появилась возможность поработать с такой экзотической штукой как статический анализатор кода, а именно PVS-Studio. Первое на чем я решил опробовать анализатор конечно же стал мой эмулятор консоли 3DO (Phoenix Project). В начале 90-х была такая приставка, первая 32-х битная консоль с CD-приводом, помню нам с братом ее отец из Москвы привез, с тех пор никак оторваться не могу. Ну а раз подвернулся случай, то за одно и все основные проекты по эмуляции 3DO проверим. Итак, поехали…

Программируя на Си многие сталкивались с такими функциями как memcpy() и memmove(), по сути, функции делают одно и тоже, но вторая корректно отрабатывает ситуацию, когда области памяти перекрываются (на что появляются дополнительные накладные расходы).

В мире С++ никто не запрещает пользоваться этими функциями (часто эти функции используют различные механизмы оптимизации и могут статься быстрее своих собратьев из мира C++), но есть и более родное средство, работающее через итераторы: std::copy. Это средство применимо не только к POD типам, а к любым сущностям, поддерживающим итераторы. О деталях реализации в стандарте ничего не сказано, но можно предположить, что разработчики библиотеки не настолько глупы, что бы не использовать, оптимизированные memcpy()/memmove() когда это возможно.