Check for non-rigid feature with SFINAE

Question

I want to create proxies for member functions and operators. They should have the same type and return parameters and should be good for several classes that are set as template parameters. Even if the class does not have a specific member function or operator, I want it to compile instead of failing with an error, mainly SFINAE. If it Xhas a method f(), but Ydoes not have any method with a name f, I need to Proxy<X>have f()as well as calls X::f(), and I need Proxy<Y>to compile and instantiate without any problems.

Retrieving the return type from a known function is no longer a problem after the previous question . However, it does not work with an error if there is no such function.

I already know a few tricks of metaprogramming templates to determine if a given function exists and activate a certain function if they do, however, they all work only with the names of hard functions, and not with arbitrary ones, which strictly limits their use in this case how do i need the same design for multiple functions.

I only need to check if there is any function with the given name, if there are overloaded options, I do not need to check if there is any specific, automatic template subtraction decides that (or I hope)

My current code is as follows:

template <class T>
class Proxy
{

    //  using my resultof solution
    template <class... Args>
    resultof(T::f, Args...) f (Args... x)
    {
        return x.f(x...);
    }

    //  using another return type extraction solution
    template <class... Args>
    typeof(T::f(std::declval<Args>()...)) f (Args... x)
    {
        return x.f(x...);
    }

    T x;

};

, T f. , .

#define resultof(f, ...) typeof(Param<__VA_ARGS__>::Func(f))

template <class... Args>
class Param
{

    public:

        template <class R>
        static R Func (R (*) (Args...));

        template <class R, class C>
        static R Func (R (C::*) (Args...));

        template <class R, class C>
        static R Func (R (C::*) (Args...) const);

};

Answer 1

,

template<typename... Args>
decltype( std::declval<T&>().f(std::declval<Args>()...) )
f(Args&&... args)
{
    return x.f(std::forward<Args>(args)...);
}

SFINAE f, (, ) . , T proxy, f, ( 14.8.2, ). , , .

template<typename U = T&, typename... Args>
decltype( std::declval<U>().f(std::declval<Args>()...) )
f(Args&&... args)
{
    return x.f(std::forward<Args>(args)...);
}

proxy<int> p;, . p.f(); " ", SFINAE.

---

, :

template<typename T, typename U>
auto operator+(Proxy<T> const& lhs, Proxy<U> const& rhs)
-> decltype( std::declval<T const&>() + std::declval<U const&>() )
{
    return lhs.x + rhs.x;
}

- .

Answer 2

:

template <typename T> class Proxy : public T { };

++ Proxy<T> T T. , , - ctors, , , .

. , T . , .f() Proxy<T>, , , - .

Answer 3

f proxy . proxy<X>::f() , X::f():

template<typename T,typename ... Args>
struct f_result
{
    typedef decltype(std::declval<T&>().f(std::declval<Args&&>()...)) type;
};

template<typename T>
struct proxy
{
    T val;

    template<typename ... Args>
    typename f_result<T,Args...>::type
    f(Args&& ... args)
    {
        return val.f(static_cast<Args&&>(args)...);
    }
};

:

#include <iostream>

struct X
{
    void f()
    {
        std::cout<<"X::f()"<<std::endl;
    }

    int f(int i)
    {
        std::cout<<"X::f("<<i<<")"<<std::endl;
        return i;
    }
};

struct Y
{};

struct Z
{
    int f()
    {
        std::cout<<"Z::f()"<<std::endl;
        return 42;
    }
};

int main(int, char**)
{
    proxy<X> px;
    px.f();
    int i=px.f(3);
    std::cout<<"i="<<i<<std::endl;

    proxy<Y> py;
    proxy<Z> pz;
    int j=pz.f();
    std::cout<<"j="<<j<<std::endl;
}

g++ 4.5 g++ 4.6 -std = ++ 0x.