3

我使用 C++ 中的模板类实现了 multiton 模式。

#ifndef MULTITON_H
#define MULTITON_H

#include <map>

template <typename Key, typename T> class Multiton
{
public:    
    static void destroy()
    {
        for (typename std::map<Key, T*>::iterator it = instances.begin(); it != instances.end(); ++it) {
            delete (*it).second;
        }
    }

    static T& getRef(const Key& key)
    {
        typename std::map<Key, T*>::iterator it = instances.find(key);

        if (it != instances.end()) {
            return *(T*)(it->second);
        }

        T* instance = new T;
        instances[key] = instance;
        return *instance;
    }

    static T* getPtr(const Key& key)
    {
        typename std::map<Key, T*>::iterator it = instances.find(key);

        if (it != instances.end()) {
            return (T*)(it->second);
        }

        T* instance = new T;
        instances[key] = instance;
        return instance;
    }

protected:
    Multiton() {}
    virtual ~Multiton() {}

private:
    Multiton(const Multiton&) {}
    Multiton& operator= (const Multiton&) { return *this; }

    static std::map<Key, T*> instances;
};

template <typename Key, typename T> std::map<Key, T*> Multiton<Key, T>::instances;

#endif

用法：

class Foo : public Multiton<std::string, Foo> {};
Foo& foo1 = Foo::getRef("foobar");
Foo* foo2 = Foo::getPtr("foobar");
Foo::destroy();

有什么改进建议吗？

4

3 回答 3

3

1）个人喜好，但我会颠倒模板参数的顺序并将密钥默认为 std::string （如果这是你最常用的）

template <typename Key, typename T> class Multiton { ... }

然后你可以这样做：

class Foo : public Multiton<Foo> {};
class Bar : public Multiton<Bar,int> {};

我认为哪个更好。

2）此外，如果您从未将指针/引用传递给 Multitron（这不会违反模式），则您不需要在类中使用虚拟析构函数。

3) 如果你为你的 T*s 使用了一个更智能的容器，你可以避免调用 Foo::destroy()。当静态实例被销毁时，类似的东西std::map<Key,boost::shared_ptr<T> >会销毁所有对象。（虽然如果你关心破坏的顺序，那么你需要一些更聪明的东西——你可以从现有的单例解决方案中调整一些东西，比如凤凰单例等）

4）您可以将迭代器更改为 const_iterators。

5）destroy应该可能会清除map，以防止调用destroy后意外访问无效内存。或者，如果您想防止这种情况发生，您应该抛出异常。

Foo* foo2 = Foo::getPtr("foobar");
Foo::destroy();
Foo::getPtr("foobar")->doSomething(); // BANG

6）如果您不使用多态 T 那么您可以使用 std::map 并且您的代码看起来像这样......

template <typename Key, typename T> class Multiton
{
public:
    //Can probably get rid of this guy as maps destructor will do the right thing 
    static void destroy()
    {
        instances.clear();
    }

    static T& getRef(const Key& key)
    {
        return instances[key];
    }

    static T* getPtr(const Key& key)
    {
        return &instances[key];
    }

protected:
    Multiton() {}
    virtual ~Multiton() {}

private:
    Multiton(const Multiton&) {}
    Multiton& operator= (const Multiton&) { return *this; }

    static std::map<Key, T> instances;
};

这就是我现在能想到的。

于 2010-02-27T05:06:49.343 回答
2

一种改进是重写getRef以使用getPtr（反之亦然，方向与不重复自己无关紧要）：

static T& getRef(const Key& key)
{
    return *getPtr(key);
}
于 2010-02-27T04:41:30.330 回答
0

看来你做了非常令人印象深刻的工作。

顺便说一句，我可以问你为什么在这里铸造实例（以 c 风格）吗？

return (T*)(it->second);

我想如果你只写会更干净

return it->second;

此外，由于这篇文章已有 10 年的历史，我使用智能指针以现代 c++ 方式对版本进行了一点升级。请看一下！

多吨.h

#ifndef MULTITON_H
#define MULTITON_H

#include <map>
#include <string>

template <typename T, typename Key = int> class Multiton {
  public:
    static void DestroyAll();
    static void Destroy(const Key &key);
    static std::shared_ptr<T> GetPtr(const Key &key);
    static T &GetRef(const Key &key) { return *GetPtr(key); }

  protected:
    Multiton();
    ~Multiton();

  private:
    Multiton(const Multiton &) = default;
    Multiton &operator=(const Multiton &) = default;
    static std::map<Key, std::shared_ptr<T>> instances_;
};

#endif // MULTITON_H

多吨.cpp

#include "multiton.h"
template <typename T, typename Key> void Multiton<T, Key>::DestroyAll() {
    for (auto it = instances_.begin(); it != instances_.end(); ++it)
        delete (*it).second;
    instances_.clear();
}

template <typename T, typename Key> void Multiton<T, Key>::Destroy(const Key &key) {
    auto it = instances_.find(key);

    if (it != instances_.end()) {
        delete (*it).second;
        instances_.erase(it);
    }
}

template <typename T, typename Key> std::shared_ptr<T> Multiton<T, Key>::GetPtr(const Key &key) {
    const auto it = instances_.find(key);

    if (it != instances_.end())
        return (it->second);

    std::shared_ptr<T> instance = std::make_shared<T>();
    instances_[key] = instance;
    return instance;
}

template <typename T, typename Key> Multiton<T, Key>::Multiton() {}

template <typename T, typename Key> Multiton<T, Key>::~Multiton() {}

template <typename T, typename Key> std::map<Key, std::shared_ptr<T>> Multiton<T, Key>::instances_;
于 2020-12-07T04:23:59.777 回答