struct psm_callback {
  virtual void on_element_start(tag,attributes);
  virtual void on_element_end(tag,attributes);
  virtual void on_text(text);
  virtual void on_comment(text);
  ...
};

void main() {

  psm_callback* pcb = ...

  parsing_state_machine psm( pcb );

  auto on_data_available = [](chars data) {
    while(!!data)
      psm.push_char(*data++);
  }

  stream.async_read( on_data_available );

  ...
}

std::cout << "Hello " << 10 << " world" << std::endl;

printf("%s %d %s\n", "Hello", 10, "world");

class data
{
    [ASN.tag:1] uint32 i;
    [ASN.tag:2] string s;
    [ASN.tag:3; max:10; composite] string s2;
};

недели две назад закончил реализацию некоторого механизма зеркалирования и отката состояния группы игровых серверов.

#include <cstdio>
#include <iostream>
#include <chrono>

enum io_type { test_printf, test_stdio };

template<io_type>
struct test;

template<>
struct test<test_printf> {
    template<typename T>
    static std::chrono::milliseconds
    run(const T *arr, std::size_t size) {
        auto start = std::chrono::system_clock::now();
        for ( ; size; --size ) {
            printf("%d", *arr++);
        }
        return std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now()-start);
    }
};

template<>
struct test<test_stdio> {
    template<typename T>
    static std::chrono::milliseconds
    run(const T *arr, std::size_t size) {
        auto start = std::chrono::system_clock::now();
        for ( ; size; --size ) {
            std::cout << *arr++;
        }
        return std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now()-start);
    }
};

int main() {
    enum { size = 1024*1024*4 };
    int *ia = new int[size];
    auto t1 = test<test_printf>::run(ia, size);
    std::cerr << "printf time =" << t1.count() << std::endl;
    auto t2 = test<test_stdio >::run(ia, size);
    std::cerr << "stdio  time =" << t2.count() << std::endl;
}

./iospeed 1>/dev/null

printf time =323
stdio time =183

container type data;
oarchive oa;
for ( const auto &it: data ) {
   oa & it;
   yield();
}

template<typename Archive>
void serialize(Archive &ar, Widget &x)
{
    ar & x.a;
    ar & x.b;
    ar & x.c;
    ar & x.d;
}

array<char, 1024> fixed_buffer;

struct my_oarchive {
   template<typename T>
   my_oarchive& operator& (const T &o) {
      yas::*_oarchive::operator& (o);
      yield();
      return *this;
   }
};

async_write(buf1, ...);
async_write(buf2, ...);
async_write(buf3, ...);

template<typename I, typename P>
I find_if(I first, I last, P p)
{
    while(first != last)
    {
        if(p(*first))
            return first;
        ++first;
    }
    return first;
}

L>Это уже вопрос культурных различий

L>Вполне возможно, этот шаблон будет инстанциирован для двух-трех разных типов и его вполне возможно написать на Си несколько раз

GTree *             g_tree_new_full                     (GCompareDataFunc key_compare_func,
                                                         gpointer key_compare_data,
                                                         GDestroyNotify key_destroy_func,
                                                         GDestroyNotify value_destroy_func);

L>Для С++ программиста это звучит странно, но тем не менее, так написано большое количество хорошего кода.

void foo(any_iterator x);

L>Иногда -Os (и -Oa, за компанию) бывает даже быстрее чем -O3, у меня так было в одном из проектов

произвольного типа элемента (а не только POD, который можно swap-byte-ить)

EP>>Конечно же правильный выбор алгоритмов это отличительная особенность C программистов. "Ну и что, что язык медленный — мы вас меньшей сложностью заборим!"
L>Я не троллю, просто типичный обитатель С++ тредов как правило любит рассказывать о том как все круто инлайнится и от этого все быстро работает, а в этом вашем Си quicksort указатель на функцию вообоще дергает, это common sense.

Так действительно всё круто инлайнится, сам неоднократно убеждался И сортировка это лишь конкретный пример.

L>Но при этом, наш гипотетический гуру программирования ни разу в жизни не пытался оптимизировать сортировку, выбором алгоритма под конкретные данные

Я понятия не имею о каком "гипотетическом гуру" ты говоришь.
Это выглядит как: "вот я знаю сиплюсплюскинка — так он вообще сортировки выбирать не умеет. а вот сишники — другое дело, их медленный qsort буквально подталкивает к правильному выбору алгоритма"

L>Стандартную библиотеку С++ писали лучшие умы человечества, поэтому мы будем использовать ее и только ее везде, чтобы было быстро

Не скажу за всю стандартную библиотеку, но STL действительно писали лучшие умы. По крайней мере это самая лучшая стандартная алгоритмическая библиотека, с самым лучшим интерфейсом и набором алгоритмов.
Тех же сортировок там три штуки: интроспективная (которая сочетает в себе три типа сортировки), пирамидальная, сортировка слиянием (причём адаптивная, а не в лоб).
Плюс алгоритмы связанные с сортировкой: разбиение множества (три штуки — разбиение Энтони Хоара, Нико Ломуто и адаптивное стабильное), слияние (две штуки: out-of-place и адаптивное in-place), поворот (out-of-place и in-place(привет Евклиду)), выбор k-го элемента (причём с полезной перестановкой остальных элементов), бинарный поиск (пять штук) и т.д.

EP>>Happy-path намного более вероятный — и оптимизировать нужно именно его. Кстати, с кодами ошибок будет засорение всего happy-path runtime проверками.
L>Если в коде куча конструкций вроде if (status != SUCCESS) ... и при этом вероятность happy path выше в разы, то branch predictor будет очень точно угадывать ветвления и обработка ошибок практически не будет оказывать влияния на время выполнения.

Естественно он будет угадывать, особенно после первого прогона.
Фишка в том, что в случае исключений ему даже угадывать ничего не придётся — cmp+je/whatever не будут разбросаны по всему happy path.

EP>>void foo(any_iterator x);
EP>>

L>>>Иногда -Os (и -Oa, за компанию) бывает даже быстрее чем -O3, у меня так было в одном из проектов

L>Ну это вряд ли Os это подмножество O2, без тех оптимизаций, которые могут привести к увеличению размера бинарника.

L>Никто не спорит с тем, что заинлайненная версия будет быстрее, просто она не будет сильно быстрее, по описанным мной причинам

L>И очень долго там небыло даже банальных хэш таблиц

L>insertion sort мне тоже недавно пришлось писать вручную

By the way, does STL have insertion sort inside? It has, of course it does.
So, what happend during standartization process: they took something which was in the library and was used by the library and threw it out. The argument was: "oh, we already have too many sorts".
Is it a good argument "too many sorts"? No, you need to have as many sorts as people might need when they do practical things.

gint                (*GCompareFunc)                     (gconstpointer a,
                                                         gconstpointer b);
void                g_array_sort                        (GArray *array,
                                                         GCompareFunc compare_func);

if(error)
   throw something();

EP>switch table будет медленнее оригинальных goto. Я вообще не вижу смысл в переводе безусловного goto на switch в контексте обсуждения производительности

L>>Т.е. код, выбирающий обработчик для кода ошибки у компилятора получится более быстрым, нежели код для try catch.. catch.. catch, причем намного. Я уже молчу про локальность этого кода

#include <iostream>
#include <boost/timer.hpp>

using namespace std;

int main()
{
    const int num_samples = 200000000;
    float* A = new float[num_samples];
    float* B = new float[num_samples];
    float* C = new float[num_samples];
    boost::timer timer;
    for (int i = 0; i < num_samples; i++) {
        A[i] = 0.f;
        B[i] = 1.f;
        C[i] = 0;
    }
    double result = timer.elapsed();
    std::cout << "rewrite of " << (3*num_samples*sizeof(float)/(1024*1024)) << " Mb takes " << result << std::endl;

    timer.restart();
    for (int i = 0; i < num_samples; i++) {
        C[i] += A[i] + B[i];
    }
    result = timer.elapsed();
    std::cout << "without branch: " << result << std::endl;

    timer.restart();
    for (int i = 0; i < num_samples; i++) {
        if (i == -1)
            break;
        if (i == -2)
            break;
        if (i == -3)
            break;
        if (i == -4)
            break;
        if (i == -5)
            break;
        if (i == -6)
            break;
        if (i == -7)
            break;
        if (i == -8)
            break;
        if (i == -9)
            break;
        C[i] += A[i] + B[i];
    }
    result = timer.elapsed();
    std::cout << "with branch: " << result  << std::endl;
}