相关疑难解决方法(0)

我正在看Don Clugston的FastDelegate迷你库,并注意到一个奇怪的语法技巧,具有以下结构:

TemplateClass< void( int, int ) > Object;

几乎看起来好像函数签名被用作模板实例声明的参数.

这种技术(其在FastDelegate中的存在显然是由于一个Jody Hagins)被用于简化模板实例的声明,其具有半任意数量的模板参数.

也就是说,它允许这样的事情如下:

// A template with one parameter
template<typename _T1>
struct Object1
{
    _T1 m_member1;
};

// A template with two parameters
template<typename _T1, typename _T2>
struct Object2
{
    _T1 m_member1;
    _T2 m_member2;
};

// A forward declaration
template<typename _Signature>
struct Object;

// Some derived types using "function signature"-style template parameters
template<typename _Dummy, typename _T1>
struct Object<_Dummy(_T1)> : public Object1<_T1> {};

template<typename _Dummy, typename _T1, typename _T2> …

我理解正常的运算符重载.编译器可以直接将它们转换为方法调用.我不太清楚 - >运算符.我正在编写我的第一个自定义迭代器,我觉得需要 - >运算符.我看了一下stl源代码并实现了我自己的代码:

MyClass* MyClassIterator::operator->() const
{
    //m_iterator is a map<int, MyClass>::iterator in my code.
    return &(m_iterator->second);
}

然后我可以使用MyClassIterator的实例,如:

myClassIterator->APublicMethodInMyClass().

看起来编译器在这里做了两个步骤.1.调用 - >()方法获取一个临时的MyClass*变量.2.在temp变量上调用APublicMethodInMyClass使用其 - >运算符.

我的理解是否正确？

我试图了解 Herb Sutter 在 C++ 和 Beyond 2012 上展示的监视器类：

template<typename T>
class monitor {
private:
    mutable T t;
    mutable std::mutex m;

public:
    monitor(T t_ = T{}) : t{ t_ } {} 
    template<typename F>
    auto operator()(F f) const -> decltype(f(t))
    {
        std::lock_guard<std::mutex> _{ m }; return f(t);
    }
}; 

我设法创建了一个以更老式和更简单（至少对我而言）的方式做同样事情的类：

template<typename T>
class MyMonitor {
public:
    MyMonitor() { t = T(); }

    template<typename F>
    auto callFunc(F f) {
        std::lock_guard<std::mutex> lock(m);
        return f(t);
    }

private:
    T          t;
    std::mutex m;
};  

Herb Sutters …