Question

我正在使用容器来保存指向任何内容的指针列表：

struct Example {
    std::vector<boost::any> elements;
}

要在此容器中插入元素，我编写了几个辅助函数（struct Example的成员）：

void add_any(boost::any& a) {
    elements.push_back(a);
}

template<typename T>
void add_to_list(T& a) {
    boost::any bany = &a;
    add_any(bany);
}

现在，我想仅在元素不存在时才插入元素。为此，我认为我只需要使用适当的比较器函数调用search而不是elements。但是，我不知道如何比较boost::any个实例。

我的问题： 知道我的boost::any个实例总是包含指向某个东西的指针;是否可以比较两个boost::any值？

更新

我感谢你的回答。我还设法以可能不安全的方式执行此操作：使用boost::unsafe_any_cast获取void**并比较基础指针。

目前，这工作正常。但是，我会感谢您的评论：也许这是一个很大的错误！

#include <boost/any.hpp>
#include <iostream>
#include <vector>
#include <string>
using namespace std;

bool any_compare(const boost::any& a1, const boost::any& a2) {
    cout << "compare " << *boost::unsafe_any_cast<void*>(&a1)
         << " with:  " << *boost::unsafe_any_cast<void*>(&a2);
    return (*boost::unsafe_any_cast<void*>(&a1)) ==
        (*boost::unsafe_any_cast<void*>(&a2));
}

struct A {};

class Example {
public:
    Example() : elements(0),
                m_1(3.14),
                m_2(42),
                m_3("hello"),
                m_4() {};
    virtual ~Example() {};

    void test_insert() {
        add_to_list(m_1);
        add_to_list(m_2);
        add_to_list(m_3);
        add_to_list(m_4);
        add_to_list(m_1); // should not insert
        add_to_list(m_2); // should not insert
        add_to_list(m_3); // should not insert 
        add_to_list(m_4); // should not insert
    };

    template <typename T>
    void add_to_list(T& a) { 
        boost::any bany = &a;
        add_any(bany);
    }

private:
    vector<boost::any> elements;
    double m_1;
    int    m_2;
    string m_3;
    A      m_4;


    void add_any(const boost::any& a) {
        cout << "Trying to insert " << (*boost::unsafe_any_cast<void*>(&a)) << endl;
        vector<boost::any>::const_iterator it;
        for (it =  elements.begin();
             it != elements.end();
             ++it) {
            if ( any_compare(a,*it) ) {
                cout << " : not inserting, already in list" << endl;
                return;
            }
            cout << endl;
        }
        cout << "Inserting " << (*boost::unsafe_any_cast<void*>(&a)) << endl;
        elements.push_back(a);
    };


};



int main(int argc, char *argv[]) {

    Example ex;
    ex.test_insert();
    unsigned char c;
    ex.add_to_list(c);
    ex.add_to_list(c); // should not insert

    return 0;
}

Answer 1

你不能直接提供它，但你实际上可以使用any作为基础类型......虽然对于指针它没有意义（啊！）

struct any {
  std::type_info const& _info;
  void* _address;
};

一个模板化的构造函数：

template <typename T>
any::any(T* t):
   _info(typeid(*t)),
   _address(dynamic_cast<void*>(t))
{
}

这基本上是boost::any。

现在我们需要用比较机制来“扩充”它。

为了做到这一点，我们将“捕获”std::less的实现。

typedef bool (*Comparer)(void*,void*);

template <typename T>
bool compare(void* lhs, void* rhs) const {
  return std::less<T>()(*reinterpret_cast<T*>(lhs), *reinterpret_cast<T*>(rhs));
}

template <typename T>
Comparer make_comparer(T*) { return compare<T>; }

并扩充any的构造函数。

struct any {
  std::type_info const& _info;
  void* _address;
  Comparer _comparer;
};

template <typename T>
any::any(T* t):
  _info(typeid(*t)),
  _address(dynamic_cast<void*>(t)),
  _comparer(make_comparer(t))
{
}

然后，我们提供了less（或operator<）

的专业化

bool operator<(any const& lhs, any const& rhs) {
  if (lhs._info.before(rhs._info)) { return true; }
  if (rhs._info.before(lhs._info)) { return false; }
  return (*lhs._comparer)(lhs._address, rhs._address);
}

注意：封装等等......留给读者练习

Answer 2

执行此操作的唯一简单方法我可以想到涉及对any实例中存储的类型的硬编码支持，从而破坏了any的大部分用处...

bool equal(const boost::any& lhs, const boost::any& rhs)
{
    if (lhs.type() != rhs.type())
        return false;

    if (lhs.type() == typeid(std::string))
        return any_cast<std::string>(lhs) == any_cast<std::string>(rhs);

    if (lhs.type() == typeid(int))
        return any_cast<int>(lhs) == any_cast<int>(rhs);

    // ...

    throw std::runtime_error("comparison of any unimplemented for type");
}

使用C ++ 11的type_index，您可以使用std::map或std::unordered_map键入std::type_index(some_boost_any_object.type()) - 类似于Alexandre在下面的评论中所建议的。

Answer 3

也许这个算法派上用场＆gt; http://signmotion.blogspot.com/2011/12/boostany.html

按类型和内容比较两个任意值。尝试将字符串转换为等于的数字。

Answer 4

无需创建新课程。尝试使用xany https://sourceforge.net/projects/extendableany/?source=directory xany类允许向任何现有功能添加新方法。顺便提一下，文档中有一个例子可以完全符合您的要求（创建Matched_any）。

Answer 5

如果您可以更改容器中的类型，则会Boost.TypeErasure。它提供了自定义any的简便方法。例如，我使用这种typedef用于类似的目的：

#include <boost/type_erasure/any.hpp>
#include <boost/type_erasure/operators.hpp>

using Foo = boost::type_erasure::any<
    boost::mpl::vector<
        boost::type_erasure::copy_constructible<>,
        boost::type_erasure::equality_comparable<>,
        boost::type_erasure::typeid_<>,
        boost::type_erasure::relaxed
    >
>;

Foo与boost::any的行为完全相同，只是可以对其进行比较，并使用boost::type_erasure::any_cast代替boost::any_cast。

比较boost :: any内容

5 个答案: