Question

我有一些模板代码，这些代码需要共享指向类的指针并调用函数或方法。如果被调用的方法定义为const，就会出现问题。

示例：

struct Y {}; 
struct X
{
        const Y Go() const { return Y{}; }
        const Y Go2() { return Y{}; }
};

Y f1( std::shared_ptr<X>  ) { return Y{}; }

template< typename FUNC, typename ... ARGS >
auto Do( std::shared_ptr<X>& ptr, FUNC&& f, ARGS&& ... args )
{
    return f( ptr, std::forward<ARGS>(args)... );
}

template < typename CLASS, typename RET, typename ... ARGS>
auto Do( std::shared_ptr<X>& base_ptr, RET (CLASS::*mem_ptr)( ARGS...), ARGS&& ... args )->RET
{
    return (base_ptr.get()->*mem_ptr)( std::forward<ARGS>(args)...);
}

// Any chance to avoid the full duplication of the code here
// to define the member pointer to a const method?

template < typename CLASS, typename RET, typename ... ARGS>
auto Do( std::shared_ptr<X>& base_ptr, RET (CLASS::*mem_ptr)( ARGS...) const, ARGS&& ... args )->RET
{
    return (base_ptr.get()->*mem_ptr)( std::forward<ARGS>(args)...);
}

int main()
{
    auto xptr = std::make_shared<X>();
    Y y1 = Do( xptr, &X::Go );
    Y y2 = Do( xptr, &X::Go2 );
    Y y3 = Do( xptr, &f1 );
}

我的问题是RET (CLASS::*mem_ptr)( ARGS...) const的最后一个专业化。我只是想停止只复制const的整个代码。在现实世界的代码中，该函数再次调用另一个模板化的代码，从而导致在此处重复很多代码。

有没有机会摆脱const成员指针的专业化？

Answer 1

在C ++ 17中，我将使用带有if constexpr的单个模板函数，并检查是否可以使用std::is_invocable作为模板成员函数调用f，然后使用std::invoke来调用它：

template< typename FUNC, typename ... ARGS >
auto Do( std::shared_ptr<X>& ptr, FUNC&& f, ARGS&& ... args ) {
    if constexpr (std::is_invocable_v<FUNC, decltype(ptr), ARGS...>) {
        return std::invoke(f, ptr, std::forward<ARGS>(args)... );
    }
    else {
        return std::invoke(f, ptr.get(), std::forward<ARGS>(args)... );
    }
}

在C ++ 17之前，您可以有两个重载：一个重载非成员函数，另一个重载成员函数。然后，您可以根据可调用对象的类型使用SFINAE禁用一个或另一个（使用类似于std::is_invocable的功能）。

Answer 2

您可以这样做：

template< typename FUNC, typename ... ARGS >
auto Do( std::shared_ptr<X>& ptr, FUNC&& f, ARGS&& ... args )
-> decltype((f(ptr, std::forward<ARGS>(args)... )))
{
    return f( ptr, std::forward<ARGS>(args)... );
}

template<typename MemberF, typename ... ARGS>
auto Do(std::shared_ptr<X>& base_ptr, MemberF mem_ptr, ARGS&& ... args)
-> decltype((base_ptr.get()->*mem_ptr)( std::forward<ARGS>(args)...))
{
    return (base_ptr.get()->*mem_ptr)( std::forward<ARGS>(args)...);
}

Answer 3

这里是C ++ 14版本，不需要SFINAE，并且依赖于以下事实：

const Y (X::*)()与U1 X::*与U1 = const Y()相同；
connt Y (X::*)() const与U2 X::*与U2 = const Y() const相同。

template< typename FUNC, typename ... ARGS >
auto Do( std::shared_ptr<X>& ptr, FUNC&& f, ARGS&& ... args )
{
    return f( ptr, std::forward<ARGS>(args)... );
}

template < typename CLASS, typename U, typename ... ARGS>
auto Do( std::shared_ptr<X>& base_ptr, U CLASS::*mem_ptr, ARGS&& ... args )
{
    return (base_ptr.get()->*mem_ptr)( std::forward<ARGS>(args)...);
}

_{发布一个不同的答案，因为这与第一个答案完全不同，而且两者都很有趣（在我看来）。}

在使用指向const和非const方法的成员指针时减少模板专业化的数量

3 个答案: