C++ *

Как известно, C++ позволяет глобально переопределять операторы new и delete. Обычно такое переопределение используется для диагностики, поиска утечек памяти и более эффективного распределения памяти.

Все это мы используем в нашем крупном проекте. Однако у нас есть часть, написанная на C#, которая с помощью C++/CLI взаимодействует с основной частью на C++. И вот тут появились проблемы. У нас получались утечки памяти там, где их быть ну никак не могло.

Придумал простой итератор для обхода произвольного дерева:
(для облегчения кода прежде всего)

struct Document
{
    Concept *root;
    struct Iter
    {
        Concept *start;
        Concept *cur;
        Concept *bottom;
    }iter;
 
    Concept* Begin(Concept *c)
    {
        iter.start = c;
        iter.cur = c;
        iter.bottom =  0;
        return Next();
    }
    Concept * Next()
    {


Исходные данные: язык С, gcc4.4, x86, GNU/Linux

struct.h:

struct S
{
    int *a;
    int *b;
};

a.c:

#include <stdio.h>
#include "struct.h"

struct S f(struct S v)
{
    printf("v.a = %d, v.b = %d\n", *v.a, *v.b);
    return v;
}

b.c:

#include <stdio.h>
#include "struct.h"

int main()
{
    int a = 1, b = 2;
    struct S v = {&a, &b};
    f(v);
    printf("a = %d, b = %d\n", a, b);
    return 0;
}

makefile:

all: test
        ./test

test: a.c b.c struct.h
        gcc a.c b.c -g -o test

Вопрос: что будет напечатано во время выполнения? Подумайте хотя бы минуту. А лучше возьмите отладчик и походите по этой нехитрой программе.

Пару дней назад вышла новая версия (после 2 лет разработки) достаточно популярной открытой IDE, написанной на С++ и wxWidgets — Code::Blocks. Основной язык разработки — C++. Существует система плагинов для расширения возможностей среды.

Весь нижеприведенный код — выдержка из одного моего недавнего проекта, в рамках которого было необходимо определять скорость download и upload. Изобретать велосипед было неохота, посему возникло желание воспользоваться сервисом www.speedtest.net, как наиболее уважаемым и работоспособным из сервисов такого типа. Впрочем, как показала практика, он оказался вполне недружелюбным и некий велосипед таки пришлось изобрести.

Чем не устраивает ArtMoney

Часто возникает необходимость найти и поменять какие-либо строки/числа в чужой программе. С этой задачей лучше всего справляется ArtMoney. Для тех, кто не умеет или не хочет использовать отладчики, это на сегодня, наверное, единственный вариант, так как нормальных аналогов просто нету. Хотя ArtMoney и поддерживает очень много возможностей для работы с памятью, весь процесс происходит вручную, без возможности создания действий по алгоритму. Если значений много и их надо, например, менять при каждом запуске программы, то время, затрачиваемое на эту работу, превышает всякие допустимые пределы. Выход один — написать свой редактор памяти!

Статья рассказывает об опыте знакомства с IoC-контейнером PocoCapsule (C++), возникших трудностях и способах их преодоления. Помимо прочего статья включает небольшой пример для быстрого старта с PocoCapsule (упрощенный проект «Hello World» с официального сайта).

Ниже по тексту термином «платформа» будем называть любой заданный набор из процессора, компилятора и операционной системы, под которой скомпилированный код будет запускаться.

Исторически язык C создавался таким, что среди главных целей, положенных в его основу есть такие:

• быть максимально независимым от какой-то конкретной платформы,
• быть максимально эффективным на всех платформах. В идеале — на всех.

Немножко о разнообразии платформ. Их (платформ) существует огромное количество — среди процессоров есть и 16-битные, и 32-битные, и 64-битные. Есть такие, которые умеют выполнять операции с плавающей точкой на аппаратном уровне, какие-то поддерживают операции с двойной точностью, а в каких-то процессорах FPU отсутствует полностью. Процессоры отличаются также внутренним порядком следования байт в слове (big/little endian), как именно процессор работает с внешней памятью, и т.д. и т.п.

И на весь этот зоопарк существует один-единственный Стандарт языка C. Как же это удалось? Вот тут и начинается самое интересное.

Когда я только начинал использовать С++, то всё время забывал синтаксис определения указателей на функции и особенно указателей на функции члены.

Позже узнал об одном небольшом lifehack'e, который помог мне избавиться от того что-бы держать в голове синтаксис определения указателей на ф-ции. Правда чуть позже этот всё само как-то осело у меня в голове и даже стало очевидно.

На днях показывал этот lifehack одному программисту и решил поделиться им здесь.

— Папа, я бежал за троллейбусом и сэкономил пять копеек!
— Сынок, бежал бы за такси — сэкономил бы пять рублей!


Сегодня я хочу рассказать вам, как сэкономить 10 тысяч долларов. А заодно, что гораздо менее интересно – научить перехватывать вызовы Win32 API функций, и не только. Хотя, в первую очередь – конечно, именно их.

Вступление

Каждый из нас, конечно же, сталкивался с ситуацией, когда меню требуется сгенерировать динамически, непосредственно во время выполнения программы. Это может требоваться по разным причинам, например, из-за наличия нескольких локализаций ресурсов или из-за слишком большого разнообразия вариантов меню.

Вступление

Всякому известно, что Win32 API не отличается чрезмерным удобством. Например, для вызова функции частенько приходится заполнять большую структуру с полями вроде cbSize, dwFlags и т. д. Или для получения строки сначала узнавать размер ее, готовить буфер и затем лишь получать саму строку. Далее пойдет речь про функцию ::HttpQueryInfo() и применение идиомы «traits» для упрощения работы с ней.

Недавно на профильном ресурсе один программист задал вопрос: «Что использовать в сервере ММО для работы с потоками?». Программист склонялся к Intel TBB, но даже не к базовым примитивам, а к кастомному планированию задач (task scheduling). Ну нравится TBB — ну и ладно. А немного позже я увидел исходники сервера ММО другого программиста, который недавно начал переписываться его с нуля для улучшения архитектуры. И там было очень много велосипедов, которые писались самим программистом вместо того что бы использовать сторонние компоненты такие как boost (к примеру класы обертки над pthread-ом, и это в 2010 году, когда boost.thread уже почти в стандарте). Была там реализована и поддержка пула потоков с планировщиком задач. Тема эта мне очень интересна и я начал копать информацию о готовых решениях планировки задач (как в TBB) и нашел boost.task, про что и решил написать.

Мой перевод:

Вчера Google выпустил новую библиотеку регулярных выражений — RE2. Библиотека написана на C++.

Существует два подхода к реализации регулярных выражений: недетерминированные конечные автоматы (NFA) и детерминированные конечные автоматы (DFA). Первый механизм регулярных выражений используется, например, в Perl, Python, Ruby и .NET. К сожалению, в этом случае время работы программы может расти экспоненциально, а также может неограниченно расти использование стека. Такое поведение оказалось неприемлемым для таких проектов Google, как Code Search, Sawzall и Bigtable, поэтому программисты компании написали библиотеку на основе детерминированных конечных автоматов. RE2 гарантирует линейную скорость выполнения поиска и ограниченное использование стека. DFA также используется, например, в lex и egrep. В отличие от большинства подобных реализаций RE2 поддерживает почти все основные возможности PCRE.

Библиотека распространяется под BSD лицензией.

UPD: Убрал Tcl из примеров NFA, сейчас там используются DFA.

Я заметил, у разработчиков совершенно полярное отношение к библиотеке Boost.Spirit: либо она им жутко не нравится, либо они фанатеют от нее. Конечно, описывать грамматику на C++ – занятие на любителя. Таким любителем оказался и я, когда познакомился со Спиритом. Хочу показать, как с помощью Спирита можно довольно просто решать повседневные задачи разбора текста.

Простая задача – как два пальца

На Спирите очень удобно писать маленькие парсеры «не отходя от кассы» – прямо в C++ коде. Вот например, как вы поступите если нужно распарсить строку вида «число-число», которая задает диапазон страниц для печати? На Спирите – одна строчка:

bool ok = parse(First, Last, (uint_ >> L"-" >> uint_), MinMax) && (First == Last);

Посложнее…

Более того – можно ненамного сложнее создавать и парсеры побольше. В качестве примера рассмотрю парсер мини-языка, который я делал для API Яндекс.Бара. Задача была такова: для облегчения загрузки плагинов в баре используется XML, который довольно избыточный сам по себе. Но зато XML легче грузить из JavaScript-а, чем парсить произвольный формат (на JS пишутся расширения под FireFox, в том числе и Я.Бар).

Итак, что мне было нужно – имея на входе обычную инфиксную нотацию:

Краткое содержание статьи (для тех кто знаком с boost::mpl), typename опущены для ясности:

a = b;				==>		typedef b a;
f(x)				==>		f<x>::type
f(x) { return x*; }		==>		template<typename x> struct x { typedef x* type; };
f()(x)				==>		f::apply<x>::type
a[x]				==>		mpl::at<a, x>::type
(x ? y : z)			==>		mpl::if_<x, y, z>::type
switch (if_<x, y, z>)		==>		*Уфф*, общая (default) и частичные специализации
{
	case if_<bool_<false>, y, z>: return y;
	default: return z;
}

Под хабракатом есть немного пояснений :)

Покажет ли ваш редактор/IDE, что «a++;» в этом C/C++ коде — часть комментария?
int a=1;
//some comment \
a++;
printf("%d\n",a);

А такой вариант?
int a=1;
//some comment ??/
a++;
printf("%d\n",a);

Всем привет. А особенно тем, кто пишет на плюсах и интересуется грядущими изменениями языка.
Для исследования фич нового стандарта С++ я сделал забавную штуку — функцию для превращения простого функтора в ленивый. Т.е. вычисляемый не более одного раза, и только при первом обращении.
Для использования вам понадобится простой функтор, без аргументов, возвращающий значение.
Применяете к нему calc_once(some_func) — и он становится ленивым.

auto my_func = calc_once([]{ return SomeHugeCalculation(); });
if ((my_func() && some_case) || (!my_func() && some_other_case))
{
}

* This source code was highlighted with Source Code Highlighter.

Под хабракатом код, там и auto, и decltype, и лямбды.

UPD. Спасибо за карму. Перенес в блог С++.

В виду ограничения на размер, публикую заметку в виде статьи, а не как ссылку с аннотацией.

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