1 /* { dg-do compile } */ 2 3 #include<cassert> 4 #include<new> 5 #include<utility> 6 7 namespace boost { 8 9 template<class T> 10 class optional; 11 12 class aligned_storage 13 { 14 char data[ 1000 ]; 15 public: address()16 void const* address() const { return &data[0]; } address()17 void * address() { return &data[0]; } 18 } ; 19 20 21 template<class T> 22 class optional_base 23 { 24 protected : optional_base()25 optional_base(){} optional_base(T const & val)26 optional_base ( T const& val ) 27 { 28 construct(val); 29 } 30 31 template<class U> assign(optional<U> const & rhs)32 void assign ( optional<U> const& rhs ) 33 { 34 if (!is_initialized()) 35 if ( rhs.is_initialized() ) 36 construct(T()); 37 } 38 39 public : 40 is_initialized()41 bool is_initialized() const { return m_initialized ; } 42 43 protected : 44 construct(T const & val)45 void construct ( T const& val ) 46 { 47 new (m_storage.address()) T(val) ; 48 } 49 get_ptr_impl()50 T const* get_ptr_impl() const 51 { return static_cast<T const*>(m_storage.address()); } 52 53 private : 54 55 bool m_initialized ; 56 aligned_storage m_storage ; 57 } ; 58 59 60 template<class T> 61 class optional : public optional_base<T> 62 { 63 typedef optional_base<T> base ; 64 65 public : 66 optional()67 optional() : base() {} optional(T const & val)68 optional ( T const& val ) : base(val) {} 69 optional& operator= ( optional const& rhs ) 70 { 71 this->assign( rhs ) ; 72 return *this ; 73 } 74 75 T const& get() const ; 76 77 T const* operator->() const { assert(this->is_initialized()) ; return this->get_ptr_impl() ; } 78 79 } ; 80 81 82 } // namespace boost 83 84 85 namespace std 86 { 87 88 template<typename _Tp, std::size_t _Nm> 89 struct array 90 { 91 typedef _Tp value_type; 92 typedef const value_type* const_iterator; 93 94 value_type _M_instance[_Nm]; 95 96 }; 97 } 98 99 100 class NT 101 { 102 double _inf, _sup; 103 }; 104 105 106 template < typename T > inline 107 std::array<T, 1> make_array(const T & b1)108make_array(const T& b1) 109 { 110 std::array<T, 1> a = { { b1 } }; 111 return a; 112 } 113 114 class V 115 { 116 typedef std::array<NT, 1> Base; 117 Base base; 118 119 public: V()120 V() {} V(const NT & x)121 V(const NT &x) 122 : base(make_array(x)) {} 123 124 }; 125 126 using boost::optional ; 127 128 optional< std::pair< NT, NT > > 129 linsolve_pointC2() ; 130 construct_normal_offset_lines_isecC2()131optional< V > construct_normal_offset_lines_isecC2 ( ) 132 { 133 optional< std::pair<NT,NT> > ip; 134 135 ip = linsolve_pointC2(); 136 137 V a(ip->first) ; 138 return a; 139 } 140 141 142 143