Question

对于从未听说过“Schwarz Counter”的人，请参阅this wikibook页面。

我正在尝试用C ++ 11模板实现这个习惯用法，除非模板参数不是默认可构造的，否则一切正常。这是我的实现:(参见问题的代码注释）

#include <type_traits>

template<typename T>
class Single {
public:
    static T& get() {
        return reinterpret_cast<T&>(instance.storage);
    }

private:
    struct Instance {
        enum { kSize = sizeof(T), kAlign = std::alignment_of<T>::value };

        int counter;
        typename std::aligned_storage<kSize, kAlign>::type storage;

        template<typename... Arg>
        Instance(Arg&&... param) {
            if (counter++ == 0) {
                new (&storage) T(param...);
            }
        }

        ~Instance() {
            if (--counter == 0) {
                reinterpret_cast<T&>(storage).~T();
            }
        }
    };

    static Instance instance;
};

// The following won't compile if T isn't default constructible.
// I want to get rid of the definition in this case, and let the
// users of this template to provide their own definitions.
// I'd like to keep the it when T is default constructible, because
// most of the time T is (according to my experience, most global 
// objects are constructed without arguments, singletons are
// essentially global objects).
//
// So, basically I want something like this:
// #if std::is_default_constructible<T>::value
//     template<typename T>
//     ...;
// #endif
// Could this be done in C++11 ? If not, how about C++14 ?
template<typename T>
typename Single<T>::Instance Single<T>::instance;

BTW，如果该类是默认可构造的，则使用此模板定义单例非常简单，例如：

class Y {
    friend class Single<Y>;
    Y(int, int) { std::cout << "Y()\n"; }
    ~Y() { std::cout << "~Y()\n"; }
};

class X {
    friend class Single<X>;
    X() { std::cout << "X()\n"; }
    ~X() { std::cout << "~X()\n"; }
};

int main() {
    auto& x = Single<X>::get();
    // auto& g = Single<Y>::get(); // oops
    return 0;
}

Answer 1

创建两个类。一个用于默认的可构造T，另一个用于非。

如果默认可构造实例是默认可构造的，则将您的主实现分派为仅使用默认的可构造实例。

template<class T,class=void>
struct WhichSingle {
  using type=Single<T>;
};
template<class T>
struct WhichSingle<T,typename std::enable_if<
  !std::is_default_constructible<T>::value
>::type> {
  using type=SingleNoDefault<T>;
};

template<class X>
using Bob = typename WhichSignle<X>::type;

和Bob<X>可以是Single或SingleNoDefault。

可以做出更好的名字，并努力减少重复，但这只是笨拙的工作。

Schwarz计数器和可变参数模板

1 个答案: