基于模板的条件类成员

Question

我希望有一个接收互斥锁类型作为模板参数的类，以便（有条件地）线程安全。如果互斥锁类型等于 NoMutex（我的互斥锁空实现），我不想将此互斥锁成员添加到我的类中，以便节省空间。 我想做这样的事情：

class NoMutex{
// Same interface as std::mutex but empty implementation
// so optimization can remove unnecessary function calls
};

template <class Mutex>
class MyClass {
    public:
    // Actually I want to hide it somehow. I dont want it to occupy any space if Mutex == NoMutex
    some_template_trick<std::is_same_v<Mutex, NoMutex, void, Mutex> mutex;

    void someFunction(){
        std::unique_lock<Mutex> l(getMutex()); // I want to use std::unique_lock here
        // do some concurrent stuff

    }


    Mutex& getMutex(){
        if constexpr(std::is_same_v<Mutex, NoMutex>){
            //ok... return reference to temporary is wrong, but i'm hopping
            //that gcc will realize there is nothing to be done once all implementations
            //are empty.
            return NoMutex();
        }
        return mutex;
    }
};

我不想专门化该类，也不想创建 lock() unlock() 方法，我希望它们由 std::unique_lock(); 管理 有可能吗？

提前致谢！

Answer 1

可以使用空基类优化 (EBO) 优化空数据成员。也就是说，尽管无状态类的大小不为零（至少 1 个字节），但如果用作基类，它不会消耗额外的内存：

template <typename Mutex>
struct CompressedMutex
{
    Mutex mutex;
    Mutex& getMutex() { return mutex; }
};

template <>
struct CompressedMutex<NoMutex> : NoMutex
{
    NoMutex& getMutex() { return *this; }
};

template <typename Mutex>
class MyClass : CompressedMutex<Mutex>
{
public: 
    void someFunction()
    {
        std::unique_lock<Mutex> l(this->getMutex());
    }
};

DEMO

请注意，getMutex() 是从属名称，访问时需要 this-> 或 CompressedMutex<Mutex>::。

---

然而，通常人们也希望在const-qualified 成员函数中锁定一个互斥锁。为此，mutable 关键字可用于互斥数据成员的定义。在NoMutex 的情况下，需要使用const_cast<CompressedMutex&>(*this)，或者声明一个返回的static 对象：

template <typename Mutex>
struct CompressedMutex
{
    mutable Mutex mutex;
    Mutex& getMutex() const { return mutex; }
};

template <>
struct CompressedMutex<NoMutex>
{
    static NoMutex mutex;
    NoMutex& getMutex() const { return mutex; }
};

---

此技术已在标准库中广泛使用，因此无状态分配器（包括std::allocator<T>）不会占容器的总大小。此类对象通常存储在所谓的压缩对（例如boost::compressed_pair）或其变体中，有时与非空数据成员一起存储，因此封闭类的接口不会改变：

#include <boost/compressed_pair.hpp>

template <typename Mutex>
class MyClass
{
public: 
    void someFunction()
    {
        std::unique_lock<Mutex> l(data.second());
    }
private:
    boost::compressed_pair<SomeDataMemberType, Mutex> data;
};

Answer 2

您可以使用包含一或两件事的结构包装器来做到这一点（未经测试的代码）：

template <class T1, class T2> class Pair {
   Pair (const T1 &t1, const T2 &t2) : t1_(t1), t2_(t2) {}
   T1 & first () { return t1_; }
   T2 & second () { return t2_; }

   T1 t1_;
   T2 t2_;
};

template <class T1> class Pair<T1, NoMutex> {
   Pair (const T1 &t1) : t1_(t1) {}
   T1 & first () { return t1_; }
   NoMutex second () { return NoMutex(); }

   T1 t1_;
};