C++ *

Десять лет я пишу на С++. Первые пять лет моей задачей было писать эффективный код для компьютерных игр, потом основным требованием была стабильность, так как речь шла об автоматизации промышленных объектов. Я бы хотел поделиться своим личным опытом и практическими наработками, которые помогут создавать эффективные и в то же время стабильно работающие программы.


Материал разбит на части, от самых общих практических правил, интересных начинающим, до конкретных вопросов, актуальных опытным программистам.
В первой части я на практике дам свой ответ на самые базовые вопросы. Как вообще писать программу, в особенности — сложную программу? Что следует сделать в самом начале, чтобы потом не переделывать с нуля? Как создать оптимальную структуру программы?

Недавно разглядывал вакансии одной известной конторы, задумывался над вопросам (которые, кстати, на всех их вакансиях одинаковые). И решил написать заметку по самому интересному (на мой взгляд) аспекту первого же вопроса. Может быть доберусь и до других, а пока предлагаю задуматься, надо ли делать деструкторы виртуальными?

Ответ не так уж однозначен, и чтобы заманить вас под кат скажу, что в реализации STL вы обнаружите всего несколько виртуальных деструкторов.

Каким же должен быть полный ответ на вопрос про деструкторы?

Статья освещает реализацию бинарного web-протокола Hessian на стеке библиотек Qt. Целевая платформа С++.

Данная статья – результат моего первого опыта статического анализа достаточно большой программы (1665 файлов с исходными текстами на данный момент). Кроме того, это мой первый опыт использования среды Microsoft Visual Studio. Разработка анализируемой программы велась исключительно в Ubuntu, Eclipse CDT, компилятор GCC.

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

В новом стандарте C++0x появились зымыкания. Не вдаваясь в подробности, замыкания — это такие объекты, которые позволяют создавать функции прямо в теле других функций. Если подробнее — замыкания позволяют создавать функциональные объекты — то есть объекты, для которых определён operator(). На хабре уже писали о них: например тут.

Мне очень понравилось нововведение и я начал им пользоваться. Но только вот незадача: по смыслу, замыкания и функции — почти одно и то же, а использовать замыкания там, где должны использоваться указатели на функции, сходу не получается. По стандарту, замыкания без списка захвата должны свободно конвертироваться в указатели на функции, но на практике такого не наблюдалось, видимо ещё не реализовано. И я задался вопросом, можно ли использовать замыкания там, где используются указатели на функции?

Всем рано или поздно приходится работать с различными кодировками. Заметив в коде своей команды различные, порой странные, подходы к решению этих проблем, пришлось провести разъяснительную беседу. Ниже поделюсь своим видением правильной работы с не-ASCII символами в коде. Буду рад конструктивной критике.

Рассказывая про 64-битные ошибки, поджидающие программистов при миграции их программ, я часто слышу упреки: «Ну да, этот ваш Windows, он такой… Хорошо, что в Linux с 64-битным кодом проблем да-а-а-авно уже нет».

«А вот и нет, мой любознательный читатель».

Сегодняшний пост про 64-битную ошибку в ядре Linux.

Автор языка C++, один из идеологов объектно-ориентированной парадигмы программирования, да достаточно просто сказать Бьярн Страуструп — впервые (?) приедет в Москву, на конференцию «Разработка ПО 2010», где примет участие в качестве одного из ключевых докладчиков. Конференция пройдёт c 11 по 15 октября 2010 года.
Для многих программистов его книги The C++ Programming Language, The Design and Evolution of C++, The Annotated C++ Reference Manual были и остаются настольными, и бережно сохраняются в личных библиотеках.
Я не смог пройти мимо этой новости, надеюсь многим будет интересно принять участие в конференции.

Еще давно очень многих интересовал один вопрос: «Эта программа занимает всего 100 кб, что за музыку она воспроизводит? Как это работает?»

Так вот, называется это чудо – Трекерная музыка. И что самое главное – она занимает очень мало места, в отличие от .mp3 или .wav. В современных популярных ОС трекерные файлы (MOD, XM, S3M, IT и пр.) проигрываются большинством медиаплееров, например, Winamp, VLC, Amarok, Audacious и другими.

Скачать такую музыку можно, например отсюда — keygenmusic.net, или отсюда www.modarchive.org. Это отнюдь не единственные ресурсы, стоит только обратиться к поиску.

Для того, чтобы воспроизвести такую музыку в своей программе, нам потребуется минимальное знание C++, а также minifmod, доступный в исходниках. Как заявляют разработчики, minifmod добавит всего 50 кб к вашему exe-файлу (без учета сжатия).

Рано или поздно все сталкиваются с проблемами связанными с языковым и культурным разнообразием при написании программ. Я был сильно удивлен узнав, что часть моих знакомых, пишущих на C++, решают эти проблемы своими велосипедами. Для тех, кто еще не знает что такое std::locale я хотел бы кратко на примере показать как c ним работать и что бывает, если о нем забыть…

Введение

До начала работы с библиотекой Qt я программировал различные задачки на С++ в университете, а на работе использовал Delphi. И конечно же, в процессе работы создавались различные библиотеки. Создавались, можно сказать, с трудом. Не хватало в повседневной жизни тех плюсов, которые давало ООП. Всегда хотелось экспортировать из библиотек целые классы, причем делать это просто, быстро и беззаботно. При этом вопросы о создании библиотек на С++ и дальнейшем их использовании в проектах на Delphi или C возникали очень редко.

В данной статье я расскажу об одном из способов, позволяющих с наименьшими усилиями трансформировать программный код на C/C++ в код, написанный на C#. Впрочем, рассказанные принципы подойдут и для других пар языков. Хочу сразу оговориться, что способ не рассчитан на трансформацию кода, реализующего GUI.

Для чего это делать? К примеру, я таким образом портировал известную графическую библиотеку LibTiff (и LibJpeg заодно) на C#. Это позволило использовать наработки многих людей, создававших LibTiff, в моей программе вместе с библиотекой классов .NET Framework. Примеры кода в статье будут в основном из LibTiff и LibJpeg.

Те, кто читал книгу Андрея Александреску «Современное программирование на C++» знают, что существует обширный класс задач (в области метапрограммирования с использованием шаблонов), когда шаблону при инстанцировании необходимо указать переменное (заранее неизвестное) количество аргументов. Типичные примеры таких задач:
— Описание кортежей (tuples)
— Описание типов наподобие вариантов (variants)
— Описание функторов (в этом случае перечень типов аргументов зависит от сигнатуры функции)
— Классификация типов по заранее заданным множествам
— и т. п.

В каждой такой задаче точное количество типов, передаваемых соответствующему шаблону в качестве аргументов, заранее определить сложно. И, вообще говоря, зависит от желания и потребностей того, кто намеревается использовать соответствующий шаблонный класс.
В рамках действующего стандарта С++ сколь-нибудь удобного решения таких задач не существует. Шаблоны могут принимать строго определённое количество параметров и никак иначе. А. Александреску (в упомянутой выше книге) предлагает общее решение, основанное на т. н. «списках типов», в котором типы представлены в виде односвязного списка, реализованного посредством рекурсивных шаблонов. Альтернативным решением (используемом, например, в boost::variant и boost::tuple) является объявление шаблонного класса с большим количеством параметров, которым (всем, кроме первого) присвоено некоторое значение по умолчанию. Оба этих решения являются половинчатыми и не охватывают весь спектр возможных задач. По этому, для устранения недостатков существующих решений и упрощения кода новый стандарт предлагает С++-разработчикам новый вариант объявления шаблонов? «шаблоны с переменным количеством параметров» или, в оригинале, «variadic templates».

В моделях данных очень часто требуется хранить некоторые переключаемые состояния. Классический способ в С++ для этого — использование перечислимых типов enum.

Например, если у вас в программе пользователь может переключаться между двумя экранами, вы заводите enum screen { screen_one, screen_two }; и переменную screen cur_screen_. Отрисовщик должен получить у модели «текущий выбранный экран», и затем отрисовать его, запрашивая у модели дополнительные данные, относящиеся именно к этому экрану. Что-то вроде:

switch (model.cur_screen())
{
case screen_one:
  model.get_screen_one_elements();
  ...
case screen_two:
  model.get_screen_two_elements();
  ...
}


При использовании такой модели, программист может запрашивать данные, которые для текущего состояния совершенно не актуальны. Например, вызвать метод get_screen_two_elements() для получения списка элементов второго экрана, когда текущий экран — первый. Хорошей практикой является использование ассертов вида ASSERT(cur_screen_ == screen_one) в методах, зависимых от конкретного экрана. Это обеспечивает некоторый контроль времени выполнения.

Но есть способ обеспечить контроль времени компиляции и более явное разделение состояний с помощью boost::variant.

Введение

Как известно, многие С-библиотеки используют обратные вызовы для обеспечения какого-либо функционала. Так поступает, например, библиотека expat для реализации SAX модели. Обратный вызов или callback используется для возможности выполнить пользовательский код на стороне библиотеки. Пока такой код не несет побочных эффектов — все нормально, но как только на арене появляется С++, все, как всегда, становится нетривиальным.

Техника, известная как «Чтение по спирали/по часовой стрелке» (“Clockwise/Spiral Rule”) позволяет любому программисту разобрать любое объявление языка Си.

Следуйте этим простым шагам:

Как известно, 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++. Существует система плагинов для расширения возможностей среды.