Question

我有以下内容：

template <typename T>
struct Base {
    auto func() {
        // do stuff
        auto x = static_cast<T&>(*this).func_impl();
        // do stuff
        return x;
    }
};

struct A : Base<A> {
    int func_impl() {
        return 0;
    }
};

struct B : Base<B> {
    void func_impl() {
    }
};

int main() {
    A a;
    int i = a.func();
    B b;
    b.func();
    return 0;
}

问题在于我无法将派生类中func_impl的返回类型声明为void，如B所示。我尝试使用SFINAE解决这个问题：

template <typename T>
struct Base {
    template <typename = enable_if_t<!is_void<decltype(declval<T>().func_impl())>::value>>
    auto func() {
        // do stuff
        auto x = static_cast<T&>(*this).func_impl();
        // do stuff
        return x;
    }

    template <typename = enable_if_t<is_void<decltype(declval<T>().func_impl())>::value>>
    void func() {
        // do stuff
        static_cast<T&>(*this).func_impl();
        // do stuff
    }
};

但是编译器会给出错误：invalid use of incomplete type 'struct A'和invalid use of incomplete type 'struct B'。有没有办法完成我想要的东西？

Answer 1

尝试

template <typename T>
struct Base {
    template <typename U = T, typename = enable_if_t<!is_void<decltype(declval<U>().func_impl())>::value>>
    auto func() {
        // do stuff
        return static_cast<T&>(*this).func_impl();
    }

    template <typename U = T, typename = enable_if_t<is_void<decltype(declval<U>().func_impl())>::value>>
    void func() {
        // do stuff
        static_cast<T&>(*this).func_impl();
    }
};

我的意思是...... SFINAE适用于模板;如果你想在类中启用/禁用方法，它们必须是模板方法（类/结构是模板类/结构不计算的事实：是方法必须是模板。

SFINAE部分（在这种情况下为std::enable_if_t）必须依赖于方法的模板（在我的示例中为U）。

P.s：无论如何，我没有看到问题返回void

Answer 2

这样的情况：

auto x = static_cast<T&>(*this).func_impl();
// do stuff
return x;

调用Regular Void类型。换句话说，既然你在这里不需要 x，你只需要返回它，你真的需要 func()来返回void？我发现通常情况并非如此。人们不应该使用的任何旧空类型都足够好。因此，让我们轻松编写此案例而不重复：

namespace details {
    struct Void { }; // not intended to be used anywhere
}

template <typename F, typename... Args,
    typename R = std::invoke_result_t<F, Args...>,
    std::enable_if_t<!std::is_void<R>::value, int> = 0>
R invoke_void(F&& f, Args&&... args) {
    return std::invoke(std::forward<F>(f), std::forward<Args>(args)...);
}

template <typename F, typename... Args,
    typename R = std::invoke_result_t<F, Args...>,
    std::enable_if_t<std::is_void<R>::value, int> = 0>
details::Void invoke_void(F&& f, Args&&... args) {
    std::invoke(std::forward<F>(f), std::forward<Args>(args)...);
    return details::Void{};
}

此实现使用C ++ 17库特性，但可以在C ++ 14中实现。这为我们提供了一个invoke()，可以为void交换Void，这样您就可以写下：

auto func() {
    // do stuff
    auto x = invoke_void([](auto& x){ return x.func_impl(); },
        static_cast<T&>(*this));
    // do stuff
    return x;
}

这有点罗嗦，但至少我们不必复制func() - 只需要一个函数处理两种情况就好了。

根据您的解释，更简单或更复杂的另一种选择是重新排序func()的正文：

auto func() {
    // do stuff
    scope_exit{
        // do stuff after func_impl is invoked
    };
    return static_cast<T&>(*this).func_impl();
}

这可以让您获得正确的操作顺序，甚至不需要常规的空白。但是，后func_impl逻辑放在它之前 - 这可能会令人困惑。但好处是这个函数仍然可以返回void。

在SO上有许多类似scope_exit的实现。

SFINAE在无效和非空方法之间发送

2 个答案: