Question

我有一个有趣的问题，在我的一种基于传递的编译器中出现了。每个传递都不知道其他传递，并且在命令模式链之后，一个公共对象沿着链传递。

传递的对象是对文件的引用。

现在，在其中一个阶段中，人们可能希望关联大量数据，例如该文件的SHA512哈希值，这需要合理的时间来计算。但是，由于该块数据仅用于该特定情况，因此我不希望所有文件引用都需要为该SHA512保留空间。但是，我也不希望其他传递必须一遍又一遍地重新计算SHA512哈希。例如，某人可能只接受与给定的SHA512列表匹配的文件，但是当文件引用到达链的末尾时，或者他们想要两者或者...... .etc时，他们不希望打印该值。

我需要的是某种容器，它只包含给定类型中的一种。如果容器不包含该类型，则需要创建该类型的实例并以某种方式存储它。它基本上是一个字典，其类型是用来查找的东西。

这是我到目前为止所获得的，相关位是FileData::Get<t>方法：

class FileData;
// Cache entry interface
struct FileDataCacheEntry
{
    virtual void Initalize(FileData&)
    {
    }
    virtual ~FileDataCacheEntry()
    {
    }
};

// Cache itself
class FileData
{
    struct Entry
    {
        std::size_t identifier;
        FileDataCacheEntry * data;
        Entry(FileDataCacheEntry *dataToStore, std::size_t id)
            : data(dataToStore), identifier(id)
        {
        }
        std::size_t GetIdentifier() const
        {
            return identifier;
        }
        void DeleteData()
        {
            delete data;
        }
    };
    WindowsApi::ReferenceCounter refCount;
    std::wstring fileName_;
    std::vector<Entry> cache;
public:
    FileData(const std::wstring& fileName) : fileName_(fileName)
    {
    }
    ~FileData()
    {
        if (refCount.IsLastObject())
            for_each(cache.begin(), cache.end(), std::mem_fun_ref(&Entry::DeleteData));
    }
    const std::wstring& GetFileName() const
    {
        return fileName_;
    }

    //RELEVANT METHOD HERE
    template<typename T>
    T& Get()
    {
        std::vector<Entry>::iterator foundItem = 
            std::find_if(cache.begin(), cache.end(), boost::bind(
            std::equal_to<std::size_t>(), boost::bind(&Entry::GetIdentifier, _1), T::TypeId));
        if (foundItem == cache.end())
        {
            std::auto_ptr<T> newCacheEntry(new T);
            Entry toInsert(newCacheEntry.get(), T::TypeId);
            cache.push_back(toInsert);
            newCacheEntry.release();
            T& result = *static_cast<T*>(cache.back().data);
            result.Initalize(*this);
            return result;
        }
        else
        {
            return *static_cast<T*>(foundItem->data);
        }
    }
};

// Example item you'd put in cache
class FileBasicData : public FileDataCacheEntry
{
    DWORD    dwFileAttributes;
    FILETIME ftCreationTime;
    FILETIME ftLastAccessTime;
    FILETIME ftLastWriteTime;
    unsigned __int64 size;
public:
    enum
    {
        TypeId = 42
    }
    virtual void Initialize(FileData& input)
    {
        // Get file attributes and friends...
    }
    DWORD GetAttributes() const;
    bool IsArchive() const;
    bool IsCompressed() const;
    bool IsDevice() const;
    // More methods here
};

int main()
{
    // Example use
    FileData fd;
    FileBasicData& data = fd.Get<FileBasicData>();
    // etc
}

出于某种原因，这种设计对我来说是错误的，因为它使用无类型指针做了很多事情。我在这里严重偏离基地吗？是否有预先存在的库（增强或其他）可以使这更清晰/更容易理解？

Answer 1

正如ergosys所说，std :: map是你问题的明显解决方案。但是我可以看到你关注RTTI（以及相关的膨胀）。事实上，“任何”值容器不需要RTTI来工作。提供类型和唯一标识符之间的映射就足够了。这是一个提供此映射的简单类：

#include <stdexcept>
#include <boost/shared_ptr.hpp>
class typeinfo
{
    private:
        typeinfo(const typeinfo&); 
        void operator = (const typeinfo&);
    protected:
        typeinfo(){}
    public:
        bool operator != (const typeinfo &o) const { return this != &o; }
        bool operator == (const typeinfo &o) const { return this == &o; }
        template<class T>
        static const typeinfo & get()
        {
            static struct _ti : public typeinfo {} _inst;
            return _inst;
        }
};

typeinfo::get<T>()返回对简单无状态单例的引用，该单例允许进行比较。

此单例仅为类型T创建，其中typeinfo :: get＆lt; T＆gt;（）在程序中的任何地方发布。

现在我们使用它来实现我们称为value的顶级类型。 value是实际包含数据的value_box的持有者：

class value_box
{
    public:
        // returns the typeinfo of the most derived object
        virtual const typeinfo& type() const =0;
        virtual ~value_box(){}
};

template<class T>
class value_box_impl : public value_box
{
    private:
        friend class value;
        T m_val; 
        value_box_impl(const T &t) : m_val(t) {}
        virtual const typeinfo& type() const
        {
            return typeinfo::get< T >();
        }
};
// specialization for void.
template<>
class value_box_impl<void> : public value_box
{
    private:
        friend class value_box;
        virtual const typeinfo& type() const
        {
            return typeinfo::get< void >();
        }
    // This is an optimization to avoid heap pressure for the 
    // allocation of stateless value_box_impl<void> instances:
    void* operator new(size_t) 
    {
        static value_box_impl<void> inst;
        return &inst;
    }
    void operator delete(void* d) 
    {
    }

};

这是bad_value_cast异常：

class bad_value_cast : public std::runtime_error
{
    public:
        bad_value_cast(const char *w="") : std::runtime_error(w) {}
};

这里有价值：

class value
{
    private:
        boost::shared_ptr<value_box> m_value_box;       
    public:
        // a default value contains 'void'
        value() : m_value_box( new value_box_impl<void>() ) {}          
            // embedd an object of type T.
        template<class T> 
        value(const T &t) : m_value_box( new value_box_impl<T>(t) ) {}
        // get the typeinfo of the embedded object
        const typeinfo & type() const {  return m_value_box->type(); }
        // convenience type to simplify overloading on return values
        template<class T> struct arg{};
        template<class T>
        T convert(arg<T>) const
        {
            if (type() != typeinfo::get<T>())
                throw bad_value_cast(); 
            // this is safe now
            value_box_impl<T> *impl=
                      static_cast<value_box_impl<T>*>(m_value_box.get());
            return impl->m_val;
        }
        void convert(arg<void>) const
        {
            if (type() != typeinfo::get<void>())
                throw bad_value_cast(); 
        }
};

方便的转换语法：

template<class T>
T value_cast(const value &v) 
{
    return v.convert(value::arg<T>());
}

就是这样。这是它的样子：

#include <string>
#include <map>
#include <iostream>
int main()
{
    std::map<std::string,value> v;
    v["zero"]=0;
    v["pi"]=3.14159;
    v["password"]=std::string("swordfish");
    std::cout << value_cast<int>(v["zero"]) << std::endl;
    std::cout << value_cast<double>(v["pi"]) << std::endl;
    std::cout << value_cast<std::string>(v["password"]) << std::endl;   
}

拥有any实现的好处是，您可以非常轻松地根据实际需要进行定制，这对于boost :: any来说非常繁琐。例如，对值可以存储的类型的要求很少：它们需要是可复制构造的并且具有公共析构函数。如果您使用的所有类型都有一个运算符＆lt;（ostream＆amp;，T）并且您想要一种打印字典的方法，该怎么办？只需将to_stream方法添加到box并重载运算符＆lt;＆lt;为了价值，你可以写：

std::cout << v["zero"] << std::endl;
std::cout << v["pi"] << std::endl;
std::cout << v["password"] << std::endl;

这是上面的一个pastebin，应该用g ++ / boost编译开箱即用：http://pastebin.com/v0nJwVLW

编辑：添加了优化以避免分配box_impl＆lt;无效＆gt;从堆： http://pastebin.com/pqA5JXhA

Answer 2

您可以创建字符串的哈希或映射来boost :: any。字符串键可以从任何:: type（）中提取。

OneOfAType容器 - 在容器中存储每个给定类型 - 我是不是在这里？

2 个答案: