我一直在考虑创建一个同步器助手模板类，它基于 Herb Sutter 在这个 talk 中的包装器类的想法。这在 msvc 中不起作用(除非我们删除大括号初始化)但是当大括号初始化被删除时就没问题了。

在 clang/gcc (ubuntu 12.10, gcc4.7.2, clang (3.2) self built with libc++) 中，private 访问修饰符似乎必须出现在 public 之前:这看起来有点奇怪。

gcc 的错误是 错误:“t_”未在此范围内声明

clang 是

error: use of undeclared identifier 't_'
  auto operator()(F f) const ->decltype(f(t_))

这可能是一个我不知道的模板/declytpe 问题，想知道是否有人可以帮助解决这个问题。 (全部使用相关的 c++11 标志编译)

template <class T>
class Synchronised {
    public:
        Synchronised(T t = T{}) : t_{t} {}
        template <typename F>
        auto operator()(F f) const -> decltype(f(t_)) {
            std::lock_guard<std::mutex> lock{mutex_};
            return f(t_);
        }
        private: // place this before public: and this object compiles
            mutable T t_;
            mutable std::mutex mutex_;
};

编辑:添加 Johannes 的想法和全类，以防有人需要剪切和粘贴。

#include <future>
#include <iostream>
#include <thread>
#include <vector>

template <class T> T &self(T &t) { return t;  }
template<typename T> struct Dependent {  };

template<typename T>
class Synchronised : Dependent<T>{
 public:
  explicit Synchronised(T t = T()) : t_(t) {}
  template<typename Functor>
  auto operator()(Functor functor) const ->decltype(functor(self(*this).t_)) {
  //auto operator()(Functor functor) const ->decltype(functor(this->t_)) {
    std::lock_guard<std::mutex> lock(mutex_);
    return functor(t_);
  }
 private:
  mutable T t_;
  mutable std::mutex mutex_;
};


int main() {

    Synchronised<std::string> sync_string("Start\n");
    std::vector<std::future<void>> futures;
}

最佳答案

以下仅足以使类模板定义本身有效。然而，同样的规则使得查找在类模板中找不到数据成员(这需要引入空的依赖基类或依赖函数调用)也会使类模板的实例化找不到数据成员，并且因此将触发编译器错误。

我们告诉编译器“等一下，也许你会在实例化时找到数据成员”，但我没有考虑实际实例化时会发生什么。我们现在要做到这一点，即使在类实例化发生后，名称仍然是依赖的。解析必须等到调用 operator()。

// keep this little util somewhere :)
template<typename T>
struct self { 
  template<typename U> U &operator()(U &t) { return t; } 
};

template <class T>
class Synchronised {
    public:
// ...
        auto operator()(F f) const -> decltype(f(self<F>()(*this).t_)) {
// ...
};

self 使用类模板而不是函数模板也将防止参数依赖查找的发生，防止 F 的作者也编写了一个名为self 与参数 *this 匹配(这也可能是下面部分解决方案的潜在问题)。

除了重新排序，你还有其他几个选择

1. 使 . 左侧的表达式依赖，但不仅仅是封闭类(因为它将是特殊情况)

   // keep this little util somewhere :)
   template <class T> T &self(T &t) { return t; }
   
   template <class T>
   class Synchronised {
       public:
   // ...
           auto operator()(F f) const -> decltype(f(self(*this).t_)) {
   // ...
   };
   

2. 引入一个依赖基类来解决封闭类的特殊情况

   // Keep this little util somewhere
   template<typename T> struct Dependent { };
   
   template <class T>
   class Synchronised : Dependent<T> {
       public:
   // ...
           auto operator()(F f) const -> decltype(f(this->t_)) {
   // ...
   };
   

第一个是基于使 self(*this).t_ 成为未知特化成员的标准

• the type of the object expression is dependent and is not the current instantiation.

第二个基于使 this->t_ 成为未知特化成员的标准

• the type of the object expression is the current instantiation, the current instantiation has at least one dependent base class, and name lookup of the id-expression does not find a member of the current instantiation or a non-dependent base class thereof;

这反过来使 x->t_ 对于这两种情况都是依赖表达式，因此将在实例化时查找名称。标准说

A class member access expression (5.2.5) is type-dependent if the expression refers to a member of the current instantiation and the type of the referenced member is dependent, or the class member access expression refers to a member of an unknown specialization.

关于c++ - Clang 访问修饰符顺序和 decltype，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/14188535/