Re: deducing the return type of a function call...

From:

Michael Tsang <miklcct@gmail.com>

Newsgroups:

comp.lang.c++

Date:

Fri, 27 Nov 2009 20:00:58 +0800

Message-ID:

<heof1r$esb$1@news.eternal-september.org>

James wrote:

I am struggling to find a way to get around having to explicitly pass a
return type for the following callback scheme I am playing around with.
Here is some sample code:

#include <iostream>

template<typename T_return>
struct call_base
{
    virtual T_return execute() const = 0;
};

template<typename T,
         typename T_memfun,
         typename T_return>
class call1
: public call_base<T_return>
{
    T& m_object;
    T_memfun m_memfun;

    T_return execute() const
    {
        return (m_object.*m_memfun)();
    }

public:
    call1(T& object, T_memfun memfun)
    : m_object(object),
        m_memfun(memfun)
    {

    }
};

template<typename T,
         typename T_memfun>
class call1<T, T_memfun, void>
: public call_base<void>
{
    T& m_object;
    T_memfun m_memfun;

    void execute() const
    {
        (m_object.*m_memfun)();
    }

public:
    call1(T& object, T_memfun memfun)
    : m_object(object),
        m_memfun(memfun)
    {

    }
};

template<typename T_return>
struct call
{
    typedef call_base<T_return> const& handle;

    template<typename T, typename T_memfun>
    static call1<T, T_memfun, T_return>
    create(T& obj, T_memfun memfun)
    {
        return call1<T, T_memfun, T_return>(obj, memfun);
    }
};

#define CALL_CREATE(name, return_type, type, memfun) \
    call<return_type>::handle name = \
        call<return_type>::create((type), (memfun))

struct foo
{
    int display1()
    {
        std::cout << "("
                  << this
                  << ")->foo::display1()"
                  << std::endl;

        return 123456;
    }

    void display2()
    {
        std::cout << "("
                  << this
                  << ")->foo::display2()"
                  << std::endl;
    }
};

int
main()
{
    {
        foo f;

        CALL_CREATE(my_call1, int, f, &foo::display1);
        CALL_CREATE(my_call2, void, f, &foo::display2);

        std::cout << "my_call1 returned: "
                  << my_call1.execute()
                  << std::endl
                  << std::endl;

        std::cout << "my_call2 returns void"
                  << std::endl;

        my_call2.execute();
    }

    return 0;
}

As you can see, I am explicitly passing in the return type to the
CALL_CREATE function macro. Can anyone think of a way around this? I sure
can't!

:^(

Use the new function declaration syntax e.g.

template<class t, class u> auto func(const T &t, const U &u) -> decltype(t *
u);