всем бодрого!
http://www.chaoticmind.net/~hcb/projects/boost.atomic/doc/index.html.
использовал с версией gcc-4.6.1 - никаких проблем не было. (либо в самой либе что-то изменили, либо фазы луны сказываются)
сейчас же, при использовании с версиями gcc-4.6.1/gcc-4.6.3/gcc-4.7.0 при компиляции такого мегапростого кода:
| Код |
#include <iostream>
#include <boost/atomic.hpp>
int main() {
//std::pair<int, boost::atomic<double>> pair = std::make_pair<int, boost::atomic<double>>(1, 5.5);
//std::pair<int, double> pair = std::make_pair<int, double>(1, 5.5);
}
|
http://liveworkspace.org/code/703f4e17de6140bd62341de99dadddf9
получаю такую ошибку:
| Цитата |
In file included from boost/atomic.hpp:15:0,
from source.cpp:2:
boost/atomic/detail/integral-casts.hpp:155:7: error: partial specialization of 'boost::detail::atomic::platform_atomic<T, 4u>' after instantiation of 'boost::detail::atomic::platform_atomic<int>' [-fpermissive]
|
т.к. файл boost/atomic/detail/integral-casts.hpp на офф. репозитории почему-то невиден(хотя 'git clone' стягивает и его в том числе), приведу фрагмент этого файла:
| Код |
template<typename T>
class platform_atomic<T, 4> : private platform_atomic_integral<uint32_t> { // 155ая строка
public:
typedef platform_atomic_integral<uint32_t> super;
typedef union { T e; uint32_t i;} conv;
platform_atomic() {}
explicit platform_atomic(T t) : super(to_integral(t))
{
}
void store(T t, memory_order order=memory_order_seq_cst) volatile
{
super::store(to_integral(t), order);
}
T load(memory_order order=memory_order_seq_cst) volatile const
{
return from_integral(super::load(order));
}
bool compare_exchange_strong(
T &expected,
T desired,
memory_order success_order,
memory_order failure_order) volatile
{
uint32_t _expected, _desired;
_expected=to_integral(expected);
_desired=to_integral(desired);
bool success=super::compare_exchange_strong(_expected, _desired, success_order, failure_order);
expected=from_integral(_expected);
return success;
}
bool compare_exchange_weak(
T &expected,
T desired,
memory_order success_order,
memory_order failure_order) volatile
{
uint32_t _expected, _desired;
_expected=to_integral(expected);
_desired=to_integral(desired);
bool success=super::compare_exchange_weak(_expected, _desired, success_order, failure_order);
expected=from_integral(_expected);
return success;
}
T exchange(T replacement, memory_order order=memory_order_seq_cst) volatile
{
return from_integral(super::exchange(to_integral(replacement), order));
}
operator T(void) const volatile {return load();}
T operator=(T v) volatile {store(v); return v;}
using super::is_lock_free;
protected:
static inline uint32_t to_integral(T &t)
{
uint32_t tmp;
memcpy(&tmp, &t, sizeof(t));
return tmp;
}
static inline T from_integral(uint32_t t)
{
T tmp;
memcpy(&tmp, &t, sizeof(t));
return tmp;
}
};
|
в общем, не понятна причина ошибки.
в этом же файле, и до и после, идут такие же специализации для интегральных типов.
благодарен. |
