Question

我正在尝试实现一个包装任意类型和互斥量的类。要访问包装的数据，需要传递函子作为locked方法的参数。然后，包装器类将包装的数据作为参数传递给函子。

我希望包装器类可与const和非const一起使用，因此我尝试了以下方法

#include <mutex>
#include <string>

template<typename T, typename Mutex = std::mutex>
class   Mutexed
{
private:
    T m_data;
    mutable Mutex m_mutex;

public:
    using type = T;
    using mutex_type = Mutex;

public:
    explicit Mutexed() = default;

    template<typename... Args>
    explicit Mutexed(Args&&... args)
        : m_data{std::forward<Args>(args)...}
    {}

    template<typename F>
    auto locked(F&& f) -> decltype(std::forward<F>(f)(m_data)) {
        std::lock_guard<Mutex> lock(m_mutex);
        return std::forward<F>(f)(m_data);
    }

    template<typename F>
    auto locked(F&& f) const -> decltype(std::forward<F>(f)(m_data)) {
        std::lock_guard<Mutex> lock(m_mutex);
        return std::forward<F>(f)(m_data);
    }
};

int main()
{
    Mutexed<std::string> str{"Foo"};

    str.locked([](auto &s) { /* this doesn't compile */
        s = "Bar";
    });

    str.locked([](std::string& s) { /* this compiles fine */
        s = "Baz";
    });
    return 0;
}

使用通用lambda的第一个locked调用无法编译，并出现以下错误

/home/foo/tests/lamdba_auto_const/lambda_auto_const/main.cpp: In instantiation of ‘main()::<lambda(auto:1&)> [with auto:1 = const std::__cxx11::basic_string<char>]’:
/home/foo/tests/lamdba_auto_const/lambda_auto_const/main.cpp:30:60:   required by substitution of ‘template<class F> decltype (forward<F>(f)(((const Mutexed<T, Mutex>*)this)->Mutexed<T, Mutex>::m_data)) Mutexed<T, Mutex>::locked(F&&) const [with F = main()::<lambda(auto:1&)>]’
/home/foo/tests/lamdba_auto_const/lambda_auto_const/main.cpp:42:6:   required from here
/home/foo/tests/lamdba_auto_const/lambda_auto_const/main.cpp:41:11: error: passing ‘const std::__cxx11::basic_string<char>’ as ‘this’ argument discards qualifiers [-fpermissive]
         s = "Bar";
           ^
In file included from /usr/include/c++/5/string:52:0,
                 from /usr/include/c++/5/stdexcept:39,
                 from /usr/include/c++/5/array:38,
                 from /usr/include/c++/5/tuple:39,
                 from /usr/include/c++/5/mutex:38,
                 from /home/foo/tests/lamdba_auto_const/lambda_auto_const/main.cpp:1:
/usr/include/c++/5/bits/basic_string.h:558:7: note:   in call to ‘std::__cxx11::basic_string<_CharT, _Traits, _Alloc>& std::__cxx11::basic_string<_CharT, _Traits, _Alloc>::operator=(const _CharT*) [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>]’
       operator=(const _CharT* __s)
       ^

但是第二个带有std::string&参数的调用就可以了。

那是为什么？有没有一种方法可以使它在使用通用lambda时按预期工作？

Answer 1

从根本上来说，这是SFINAE不友好的可调用对象所发生的问题。有关更多参考，请查看P0826。

问题是，当您调用此命令时：

 str.locked([](auto &s) { s = "Bar"; });

我们有locked的两个重载，我们必须尝试两者。非const重载可以正常工作。但是const －即使无论如何也不会由重载解析选择－仍然必须实例化（这是一个通用的lambda，因此要弄清楚decltype(std::forward<F>(f)(m_data))可能是什么，您必须实例化它），并且实例化在lambda主体内失败。该主体不在即时上下文之外，因此这不是替代失败，而是一个硬错误。

致电时

str.locked([](std::string& s) { s = "Bar"; });

在重载解决的整个过程中，我们根本不需要查看主体–我们可以在调用站点处简单拒绝（因为您不能将const string传递到{{1} }。

当今的语言中并没有真正解决此问题的方法-您基本上必须在lambda上添加约束，以确保实例化失败发生在替换的直接上下文中，而不是在主体中。像这样：

string&

请注意，我们不需要使这种对SFINAE友好的方法-我们只需要确保无需实例化主体就可以确定返回类型。

更彻底的语言解决方案是允许“推论str.locked([](auto &s) -> void { s = "Bar"; });”（有关此特定问题，请参见论文中的the section）。但这不会在C ++ 20中出现。

为什么lambda auto＆参数选择const重载？

1 个答案: