static void call()
{
    Holder h0;
    exceptions<iter-1>::call(); // may throw

    Holder h1;
    exceptions<iter-1>::call(); // may throw
    // ...
}

static bool call()
{
    bool result = true;
    void *d0;
    void *d1;
    // ...

    d0 = mallocator();
    if(! (result=ifgoto<iter-1>::call()) ) // may fail
        goto ERROR0;

    d1 = mallocator();
    if(! (result=ifgoto<iter-1>::call()) ) // may fail
        goto ERROR1;
    // ...

    // ...
    ERROR1: free(d1);
    ERROR0: free(d0);

    return result;
}

#include <boost/range/algorithm/nth_element.hpp>
#include <boost/preprocessor/arithmetic/sub.hpp>
#include <boost/preprocessor/repeat.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/noncopyable.hpp>
#include <boost/timer/timer.hpp>
//#include <boost/timer.hpp>

#include <iostream>
#include <ostream>
#include <cstdlib>
#include <vector>
#include <ctime>

using namespace std;
using namespace boost;

// ______________________________ //

const int series = 33;
const int deepness = 5;
#define REPEATS 32

// ______________________________ //

bool error_check()
{
    //return time(0) < 1;
    static volatile bool t = false;
    return t;
}
void *mallocator()
{
    return malloc(4);
}

// ______________________________ //

class Holder : private noncopyable
{
    void *data;
public:
    Holder()
        : data(mallocator())
    {}
    ~Holder()
    {
        free(data);
    }
};
template<int iter> struct exceptions
{
    static void call()
    {
        #define EXP_REP(z, i, _) Holder h##i; exceptions<iter-1>::call();
            BOOST_PP_REPEAT(REPEATS,EXP_REP,t)
    }
};
template<> struct exceptions<0>
{
    static void call()
    {
        if(error_check()) throw false;
    }
};

// ______________________________ //

template<int iter> struct ifgoto
{
    static bool call()
    {
        bool result = true;

        #define IFG_REP0(z, i, _) void *d##i;
            BOOST_PP_REPEAT(REPEATS,IFG_REP0,t)

        #define IFG_REP1(z, i, _) d##i = mallocator(); if(! (result=ifgoto<iter-1>::call()) ) goto ERROR##i;
            BOOST_PP_REPEAT(REPEATS,IFG_REP1,t)

        #define IFG_REP_AUX(i) BOOST_PP_CAT(ERROR,i): free(BOOST_PP_CAT(d,i));
        #define IFG_REP2(z, i, _) IFG_REP_AUX( BOOST_PP_SUB(BOOST_PP_SUB(REPEATS,1),i) )
            BOOST_PP_REPEAT(REPEATS,IFG_REP2,t)

        return result;
    }
};
template<> struct ifgoto<0>
{
    static bool call()
    {
        return error_check() == false;
    }
};

// ______________________________ //

template<template<int> class test_case>
void test(const char *name)
{
    cout << name;
    vector<double> times;
    for(int i=0;i!=series;++i)
    {
        //timer t;
        timer::cpu_timer t;
        test_case<deepness>::call();
        times.push_back(double(t.elapsed().user));
    }
    vector<double>::iterator median = times.begin() + times.size()/2;
    nth_element(times,median);
    cout << "\tmedian is " << (*median)*1e-6 << "ms" << endl;
}

int main()
{
    try
    {
        for(int i=0;i!=2;++i)
        {
            test<exceptions>("exceptions");
            test<ifgoto>("if-error-goto");
        }
    }
    catch(...){}
}

exceptions      median is 1731.61ms
if-error-goto   median is 1762.81ms
exceptions      median is 1731.61ms
if-error-goto   median is 1747.21ms

exceptions      median is 1326.01ms
if-error-goto   median is 1716.01ms
exceptions      median is 1326.01ms
if-error-goto   median is 1716.01ms

mt@mint14 ~/Desktop $ g++ exceptions.cpp -O3
mt@mint14 ~/Desktop $ time ./a.out

real 0m53.612s
user 0m49.559s
sys 0m0.028s
mt@mint14 ~/Desktop $ gcc error_code.c -O3 -std=c99
mt@mint14 ~/Desktop $ time ./a.out

real 0m53.730s
user 0m49.647s
sys 0m0.024s

const int MAX_COUNT = 100000000;

char buf;
int count = 0;

void open()
{
    if (++count == MAX_COUNT)
    {
        count = 0;
        throw 1;
    }
}

void read(char* c)
{
    *c = buf;
    if (++count == MAX_COUNT)
    {
        count = 0;
        throw 1;
    }
}

void send(char* c)
{
    buf = *c;
    if (++count == MAX_COUNT)
    {
        count = 0;
        throw 1;
    }
}

int main()
{
    for (int i = 0; i != 1000; ++i)
    {
        try
        {
            open();
            char c;
            for (int j = 0; j != MAX_COUNT + 1; ++j)
            {
                read(&c);
                send(&c);
            }
        }
        catch (const int&)
        {
        }
    }
}

#define MAX_COUNT 100000000

char buf;
int count = 0;

int open()
{
    if (++count == MAX_COUNT)
    {
        count = 0;
        return -1;
    }
    return 0;
}

int read(char* c)
{
    *c = buf;
    if (++count == MAX_COUNT)
    {
        count = 0;
        return -1;
    }
    return 0;
}

int send(char* c)
{
    buf = *c;
    if (++count == MAX_COUNT)
    {
        count = 0;
        return -1;
    }
    return 0;
}

int main()
{
    for (int i = 0; i != 1000; ++i)
    {
        if (open() == -1)
            continue;
        char c;
        for (int j = 0; j != MAX_COUNT + 1; ++j)
        {
            if (read(&c) == -1)
                break;
            if (send(&c) == -1)
                break;
        }
    }
}

map.Add(new String(L"Zero"), new Integer(0));
map.Add(new String(L"One"), new Integer(1));
map.Add(new String(L"Two"), new Integer(2));

IMapEnumerator* pMapEnum = map.GetMapEnumeratorN();
delete pMapEnum;