141 lines
2.7 KiB
C++
141 lines
2.7 KiB
C++
// Copyright (C) 2013 Vicente Botet
|
|
//
|
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
|
|
|
#include <boost/assert.hpp>
|
|
#include <boost/static_assert.hpp>
|
|
#include <vector>
|
|
#include <utility>
|
|
#include <type_traits>
|
|
#if 1
|
|
|
|
struct B {
|
|
int v;
|
|
B(int i) : v(i) {}
|
|
};
|
|
|
|
struct D: B {
|
|
D(int i) : B(i) {}
|
|
};
|
|
|
|
void fb(B const&) {}
|
|
void fd(D const&) {}
|
|
|
|
BOOST_STATIC_ASSERT(sizeof(B)==sizeof(D));
|
|
|
|
template <class T, class Allocator=std::allocator<T> >
|
|
class new_vector;
|
|
template <class T, class Allocator>
|
|
class new_vector : public std::vector<T,Allocator>
|
|
{
|
|
typedef std::vector<T,Allocator> base_type;
|
|
public:
|
|
new_vector() : base_type() {}
|
|
new_vector(unsigned s) : base_type(s) {}
|
|
};
|
|
|
|
template <class Allocator >
|
|
class new_vector<bool, Allocator>
|
|
{
|
|
//std::vector<char,typename Allocator::template rebind<char>::other > v;
|
|
int i;
|
|
public:
|
|
};
|
|
|
|
template <class T, class A>
|
|
typename std::enable_if<!std::is_same<T, bool>::value,
|
|
new_vector<T,A>&
|
|
>::type
|
|
new_vector_cast(std::vector<T,A> & v) {
|
|
return reinterpret_cast<new_vector<T,A>&>(v);
|
|
}
|
|
|
|
BOOST_STATIC_ASSERT(sizeof(std::vector<int>)==sizeof(new_vector<int>));
|
|
BOOST_STATIC_ASSERT(sizeof(std::vector<bool>)!=sizeof(new_vector<bool>));
|
|
|
|
void fb(std::vector<int> const&) {}
|
|
void fd(new_vector<int> const&) {}
|
|
|
|
int main() {
|
|
{
|
|
std::vector<int> b(1);
|
|
b[0] = 1;
|
|
new_vector<int> d = new_vector_cast(b);
|
|
BOOST_ASSERT(b[0] == d[0]);
|
|
}
|
|
{
|
|
//std::vector<bool> b;
|
|
//new_vector<bool> d = new_vector_cast(b); // compile fail
|
|
}
|
|
{
|
|
std::vector<int> b(1);
|
|
b[0] = 1;
|
|
fd(new_vector_cast(b));
|
|
}
|
|
{
|
|
new_vector<int> d(1);
|
|
d[0] = 1;
|
|
std::vector<int> b = d;
|
|
BOOST_ASSERT(b[0] == d[0]);
|
|
}
|
|
{
|
|
//new_vector<bool> d;
|
|
//std::vector<bool> b = d; // compile fail
|
|
}
|
|
{
|
|
new_vector<int> d(1);
|
|
d[0] = 1;
|
|
fd(d);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
#else
|
|
int main() {
|
|
{
|
|
B b(1);
|
|
D d = reinterpret_cast<D&>(b);
|
|
BOOST_ASSERT(b.v == d.v);
|
|
}
|
|
{
|
|
B b(1);
|
|
fd(reinterpret_cast<D&>(b));
|
|
}
|
|
{
|
|
D d(2);
|
|
B b = d;
|
|
BOOST_ASSERT(b.v == d.v);
|
|
}
|
|
{
|
|
D d(2);
|
|
fd(d);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
#define BOOST_THREAD_VERSION 4
|
|
|
|
#include <iostream>
|
|
#include <boost/thread.hpp>
|
|
|
|
int calculate_the_answer_to_life_the_universe_and_everything()
|
|
{
|
|
return 42;
|
|
}
|
|
|
|
int main()
|
|
{
|
|
boost::packaged_task<int()> pt(calculate_the_answer_to_life_the_universe_and_everything);
|
|
boost::shared_future<int> fi1 = boost::shared_future<int>(pt.get_future());
|
|
boost::shared_future<int> fi2 = fi1;
|
|
|
|
boost::thread task(boost::move(pt)); // launch task on a thread
|
|
|
|
boost::wait_for_any(fi1, fi2);
|
|
std::cout << "Wait for any returned\n";
|
|
return (0);
|
|
}
|
|
#endif
|