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

if(error)
   throw something();

#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

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;
}

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

X>enum io_type { test_printf, test_stdio };

X>template<io_type>
X>struct test;

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

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

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

X>

X>да и как вообще может быть такое, чтоб printf() который вообще ничего не знает о типе, выполнялся быстрее типизированного кода?

for (i = 0; i < n; i++) std::cout << a[i];

std::cout << "Привет " << name << "! Как у тебя дела? Что делал " << day << "? Какие планы на " << next_day ....

printf("Привет %s! Как у тебя дела? Что делал %s? Какие планы на %s? " .... "", name, day, next_day ...);