]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | // Copyright (C) 2013 Vicente Botet |
2 | // | |
3 | // Distributed under the Boost Software License, Version 1.0. (See accompanying | |
4 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) | |
5 | ||
6 | #include <boost/assert.hpp> | |
7 | #include <boost/static_assert.hpp> | |
8 | #include <vector> | |
9 | #include <utility> | |
10 | #include <type_traits> | |
11 | #if 1 | |
12 | ||
13 | struct B { | |
14 | int v; | |
15 | B(int i) : v(i) {} | |
16 | }; | |
17 | ||
18 | struct D: B { | |
19 | D(int i) : B(i) {} | |
20 | }; | |
21 | ||
22 | void fb(B const&) {} | |
23 | void fd(D const&) {} | |
24 | ||
25 | BOOST_STATIC_ASSERT(sizeof(B)==sizeof(D)); | |
26 | ||
27 | template <class T, class Allocator=std::allocator<T> > | |
28 | class new_vector; | |
29 | template <class T, class Allocator> | |
30 | class new_vector : public std::vector<T,Allocator> | |
31 | { | |
32 | typedef std::vector<T,Allocator> base_type; | |
33 | public: | |
34 | new_vector() : base_type() {} | |
35 | new_vector(unsigned s) : base_type(s) {} | |
36 | }; | |
37 | ||
38 | template <class Allocator > | |
39 | class new_vector<bool, Allocator> | |
40 | { | |
41 | //std::vector<char,typename Allocator::template rebind<char>::other > v; | |
42 | int i; | |
43 | public: | |
44 | }; | |
45 | ||
46 | template <class T, class A> | |
47 | typename std::enable_if<!std::is_same<T, bool>::value, | |
48 | new_vector<T,A>& | |
49 | >::type | |
50 | new_vector_cast(std::vector<T,A> & v) { | |
51 | return reinterpret_cast<new_vector<T,A>&>(v); | |
52 | } | |
53 | ||
54 | BOOST_STATIC_ASSERT(sizeof(std::vector<int>)==sizeof(new_vector<int>)); | |
55 | BOOST_STATIC_ASSERT(sizeof(std::vector<bool>)!=sizeof(new_vector<bool>)); | |
56 | ||
57 | void fb(std::vector<int> const&) {} | |
58 | void fd(new_vector<int> const&) {} | |
59 | ||
60 | int main() { | |
61 | { | |
62 | std::vector<int> b(1); | |
63 | b[0] = 1; | |
64 | new_vector<int> d = new_vector_cast(b); | |
65 | BOOST_ASSERT(b[0] == d[0]); | |
66 | } | |
67 | { | |
68 | //std::vector<bool> b; | |
69 | //new_vector<bool> d = new_vector_cast(b); // compile fail | |
70 | } | |
71 | { | |
72 | std::vector<int> b(1); | |
73 | b[0] = 1; | |
74 | fd(new_vector_cast(b)); | |
75 | } | |
76 | { | |
77 | new_vector<int> d(1); | |
78 | d[0] = 1; | |
79 | std::vector<int> b = d; | |
80 | BOOST_ASSERT(b[0] == d[0]); | |
81 | } | |
82 | { | |
83 | //new_vector<bool> d; | |
84 | //std::vector<bool> b = d; // compile fail | |
85 | } | |
86 | { | |
87 | new_vector<int> d(1); | |
88 | d[0] = 1; | |
89 | fd(d); | |
90 | } | |
91 | return 0; | |
92 | } | |
93 | ||
94 | ||
95 | #else | |
96 | int main() { | |
97 | { | |
98 | B b(1); | |
99 | D d = reinterpret_cast<D&>(b); | |
100 | BOOST_ASSERT(b.v == d.v); | |
101 | } | |
102 | { | |
103 | B b(1); | |
104 | fd(reinterpret_cast<D&>(b)); | |
105 | } | |
106 | { | |
107 | D d(2); | |
108 | B b = d; | |
109 | BOOST_ASSERT(b.v == d.v); | |
110 | } | |
111 | { | |
112 | D d(2); | |
113 | fd(d); | |
114 | } | |
115 | return 0; | |
116 | } | |
117 | ||
118 | #define BOOST_THREAD_VERSION 4 | |
119 | ||
120 | #include <iostream> | |
121 | #include <boost/thread.hpp> | |
122 | ||
123 | int calculate_the_answer_to_life_the_universe_and_everything() | |
124 | { | |
125 | return 42; | |
126 | } | |
127 | ||
128 | int main() | |
129 | { | |
130 | boost::packaged_task<int()> pt(calculate_the_answer_to_life_the_universe_and_everything); | |
131 | boost::shared_future<int> fi1 = boost::shared_future<int>(pt.get_future()); | |
132 | boost::shared_future<int> fi2 = fi1; | |
133 | ||
134 | boost::thread task(boost::move(pt)); // launch task on a thread | |
135 | ||
136 | boost::wait_for_any(fi1, fi2); | |
137 | std::cout << "Wait for any returned\n"; | |
138 | return (0); | |
139 | } | |
140 | #endif |