call wrapper overhead, C++ (vc++)

Language: Layout:

#include <iostream>
#include <functional>
#include <ctime>
#include <cassert>

template < typename CALLABLE > struct A
{
    explicit A( CALLABLE callable ) : fn(callable) {}

void call_it() const { fn() ; }

CALLABLE fn ;
};

struct B
{
    long long foo( int a ) { return x += a ; }
    volatile long long x = 0 ;
};

template < typename T > struct C
{
    explicit C( T& obj, long long (T::*f)(int), int a )
        : object(obj), fn(f), arg(a) {}

void call_it() const { (object.*fn)(arg) ; }

T& object ;
    long long (T::*fn)(int) ;
    int arg ;
};

int main()
{
    B b ;
    const int INCR = 3 ;
    const std::function< void() > fn = std::bind( &B::foo, std::addressof(b), INCR ) ;

const int N = 100'000'000 ;

{
        A< decltype(fn) > a(fn) ;
        const auto start = std::clock() ;
        for( int i = 0 ; i < N ; ++i ) a.call_it() ;
        const auto finish = std::clock() ;

std::cout << "call through call wrapper: "
                  << N << " calls in " << (finish-start) * 1000.0 / CLOCKS_PER_SEC
                  << " millisecs.\n" ;

assert( b.x == (long long)N*INCR ) ;
    }

b.x = 0 ;

{
        C<B> c( b, &B::foo, INCR ) ;
        const auto start = std::clock() ;
        for( int i = 0 ; i < N ; ++i ) c.call_it() ;
        const auto finish = std::clock() ;

std::cout << "              direct call: "
                  << N << " calls in " << (finish-start) * 1000.0 / CLOCKS_PER_SEC
                  << " millisecs.\n" ;

assert( b.x == (long long)N*INCR ) ;
    }
}

Show compiler warnings [ + ] Compiler args [ + ] Show input
Compilation time: 2,26 sec, absolute running time: 0,98 sec, absolute service time: 3,26 sec