// Simple no-op cache
template <class R>
struct cache {
    cache(int size) 
    {
    }
    // 1 arg
    template <class  A1>
    boost::optional<R> get(A1 a1)
    {
        return boost::optional<R>(); // not implemented
    }
    template <class  A1>
    void set(A1 a1, R value)
    {
        // not implemented
    }
    // 2 args
    template <class  A1, class A2>
    boost::optional<R> get(A1 a1, A2 a2)
    {
        return boost::optional<R>(); // not implemented
    }
    template <class  A1, class A2>
    void set(A1 a1, A2 a2, R value)
    {
        // not implemented
    }
    // ... n args
};

// Caching function object
template <class R, class F>
struct memoizer {
    typedef R result_type;
    cache<result_type> m_cache;
    F m_func;
    memoizer(int cache_size, F func): m_cache(cache_size), m_func(func) {}
    // 1 arg
    template <class A1> result_type operator() (A1 a1)
    {
        boost::optional<result_type> res = m_cache.get(a1);
        if (!res) {
            res = m_func(a1);
            m_cache.set(a1, res.get());
        }
        return res.get();
    }
    // 2 args
    template <class A1, class A2> result_type operator() (A1 a1, A2 a2)
    {
        boost::optional<result_type> res = m_cache.get(a1, a2);
        if (!res) {
            res = m_func(a1, a2);
            m_cache.set(a1, a2, res.get());
        }
        return res.get();
    }
    // ... n args
};

// Function object generators:
// ptr fun overloads
template <class R, class A1>
memoizer<R, boost::function<R (A1)> > memoize(int cache_size, R func(A1)) 
{
    return memoizer<R,boost::function<R (A1)> >(cache_size, boost::bind(func, _1));
}
template <class R, class A1, class A2>
memoizer<R, boost::function<R (A1, A2)> > memoize(int cache_size, R func(A1, A2)) 
{
    return memoizer<R,boost::function<R (A1, A2)> >(cache_size, boost::bind(func, _1, _2));
}
// ...
// mem fun overloads 
// ...


// Usage:
int fact(int n)
{
    int f =  1 ;
    while (n >  1 ) {
        f *= n --;
    }
    return f;
}

int gcd(int a, int b)
{
    if (b ==  0 )
        return a;
    return gcd(b, a % b);
}

int main(int argc, char* argv[])
{
    boost::function<int (int)> fast_fact = memoize( 10 , fact);
    cout << fast_fact( 10 ) << endl;
    boost::function<int (int, int)> fast_gcd = memoize( 10 , gcd);
    cout << fast_gcd( 10 ,  15 ) << endl;
	return  0 ;
}

int main()
{
    string a = "test";
    string b = a;
    cout << (void*)a.c_str() << endl;
    cout << (void*)b.c_str() << endl;
    return  0 ;
}