Сравнить надстройку:: любое содержимое
Я использую контейнер для хранения списка указателей на что-либо:
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;
}
5 ответов
Единственный простой способ сделать это, который я могу придумать, заключается в поддержке жесткого кодирования для типов, которые вы храните в 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");
}
С С ++11 type_index Вы могли бы использовать std::map или же std::unordered_map включен std::type_index(some_boost_any_object.type()) - похоже на то, что Александр предлагает в своем комментарии ниже.
Вы не можете предоставить это напрямую, но вы можете использовать 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);
}
Примечание: инкапсуляция и т. Д. Оставлены читателю в качестве упражнения
Если вы можете изменить тип в контейнере, есть 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,
Нет необходимости создавать новый класс. Попробуйте использовать xany https://sourceforge.net/projects/extendableany/?source=directory xany class позволяет добавлять новые методы к любой существующей функциональности. Кстати, в документации есть пример, который делает именно то, что вы хотите (создает сопоставимый_все).
Может быть, этот алгоритм пригодится> http://signmotion.blogspot.com/2011/12/boostany.html
Сравните два любых значения по типу и содержанию. Попытайтесь преобразовать строку в число для равных.