boost/smart_ptr/make_shared.hpp

   1 #ifndef BOOST_SMART_PTR_MAKE_SHARED_HPP_INCLUDED
   2 #define BOOST_SMART_PTR_MAKE_SHARED_HPP_INCLUDED
   3
   4 //  make_shared.hpp
   5 //
   6 //  Copyright (c) 2007, 2008 Peter Dimov
   7 //
   8 //  Distributed under the Boost Software License, Version 1.0.
   9 //  See accompanying file LICENSE_1_0.txt or copy at
  10 //  http://www.boost.org/LICENSE_1_0.txt
  11 //
  12 //  See http://www.boost.org/libs/smart_ptr/make_shared.html
  13 //  for documentation.
  14
  15 #include <boost/config.hpp>
  16 #include <boost/smart_ptr/shared_ptr.hpp>
  17 #include <boost/type_traits/type_with_alignment.hpp>
  18 #include <boost/type_traits/alignment_of.hpp>
  19 #include <cstddef>
  20 #include <new>
  21
  22 namespace boost
  23 {
  24
  25 namespace detail
  26 {
  27
  28 template< std::size_t N, std::size_t A > struct sp_aligned_storage
  29 {
  30     union type
  31     {
  32         char data_[ N ];
  33         typename boost::type_with_alignment< A >::type align_;
  34     };
  35 };
  36
  37 template< class T > class sp_ms_deleter
  38 {
  39 private:
  40
  41     typedef typename sp_aligned_storage< sizeof( T ), ::boost::alignment_of< T >::value >::type storage_type;
  42
  43     bool initialized_;
  44     storage_type storage_;
  45
  46 private:
  47
  48     void destroy()
  49     {
  50         if( initialized_ )
  51         {
  52             reinterpret_cast< T* >( storage_.data_ )->~T();
  53             initialized_ = false;
  54         }
  55     }
  56
  57 public:
  58
  59     sp_ms_deleter(): initialized_( false )
  60     {
  61     }
  62
  63     // optimization: do not copy storage_
  64     sp_ms_deleter( sp_ms_deleter const & ): initialized_( false )
  65     {
  66     }
  67
  68     ~sp_ms_deleter()
  69     {
  70         destroy();
  71     }
  72
  73     void operator()( T * )
  74     {
  75         destroy();
  76     }
  77
  78     void * address()
  79     {
  80         return storage_.data_;
  81     }
  82
  83     void set_initialized()
  84     {
  85         initialized_ = true;
  86     }
  87 };
  88
  89 template< class T > T forward( T t )
  90 {
  91     return t;
  92 }
  93
  94 } // namespace detail
  95
  96 // Zero-argument versions
  97 //
  98 // Used even when variadic templates are available because of the new T() vs new T issue
  99
 100 template< class T > boost::shared_ptr< T > make_shared()
 101 {
 102     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >() );
 103
 104     detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
 105
 106     void * pv = pd->address();
 107
 108     ::new( pv ) T();
 109     pd->set_initialized();
 110
 111     T * pt2 = static_cast< T* >( pv );
 112
 113     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
 114     return boost::shared_ptr< T >( pt, pt2 );
 115 }
 116
 117 template< class T, class A > boost::shared_ptr< T > allocate_shared( A const & a )
 118 {
 119     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >(), a );
 120
 121     detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
 122
 123     void * pv = pd->address();
 124
 125     ::new( pv ) T();
 126     pd->set_initialized();
 127
 128     T * pt2 = static_cast< T* >( pv );
 129
 130     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
 131     return boost::shared_ptr< T >( pt, pt2 );
 132 }
 133
 134 #if defined( BOOST_HAS_VARIADIC_TMPL ) && defined( BOOST_HAS_RVALUE_REFS )
 135
 136 // Variadic templates, rvalue reference
 137
 138 template< class T, class... Args > boost::shared_ptr< T > make_shared( Args && ... args )
 139 {
 140     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >() );
 141
 142     detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
 143
 144     void * pv = pd->address();
 145
 146     ::new( pv ) T( detail::forward<Args>( args )... );
 147     pd->set_initialized();
 148
 149     T * pt2 = static_cast< T* >( pv );
 150
 151     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
 152     return boost::shared_ptr< T >( pt, pt2 );
 153 }
 154
 155 template< class T, class A, class... Args > boost::shared_ptr< T > allocate_shared( A const & a, Args && ... args )
 156 {
 157     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >(), a );
 158
 159     detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
 160
 161     void * pv = pd->address();
 162
 163     ::new( pv ) T( detail::forward<Args>( args )... );
 164     pd->set_initialized();
 165
 166     T * pt2 = static_cast< T* >( pv );
 167
 168     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
 169     return boost::shared_ptr< T >( pt, pt2 );
 170 }
 171
 172 #else
 173
 174 // C++03 version
 175
 176 template< class T, class A1 >
 177 boost::shared_ptr< T > make_shared( A1 const & a1 )
 178 {
 179     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >() );
 180
 181     detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
 182
 183     void * pv = pd->address();
 184
 185     ::new( pv ) T( a1 );
 186     pd->set_initialized();
 187
 188     T * pt2 = static_cast< T* >( pv );
 189
 190     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
 191     return boost::shared_ptr< T >( pt, pt2 );
 192 }
 193
 194 template< class T, class A, class A1 >
 195 boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1 )
 196 {
 197     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >(), a );
 198
 199     detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
 200
 201     void * pv = pd->address();
 202
 203     ::new( pv ) T( a1 );
 204     pd->set_initialized();
 205
 206     T * pt2 = static_cast< T* >( pv );
 207
 208     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
 209     return boost::shared_ptr< T >( pt, pt2 );
 210 }
 211
 212 template< class T, class A1, class A2 >
 213 boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2 )
 214 {
 215     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >() );
 216
 217     detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
 218
 219     void * pv = pd->address();
 220
 221     ::new( pv ) T( a1, a2 );
 222     pd->set_initialized();
 223
 224     T * pt2 = static_cast< T* >( pv );
 225
 226     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
 227     return boost::shared_ptr< T >( pt, pt2 );
 228 }
 229
 230 template< class T, class A, class A1, class A2 >
 231 boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2 )
 232 {
 233     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >(), a );
 234
 235     detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
 236
 237     void * pv = pd->address();
 238
 239     ::new( pv ) T( a1, a2 );
 240     pd->set_initialized();
 241
 242     T * pt2 = static_cast< T* >( pv );
 243
 244     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
 245     return boost::shared_ptr< T >( pt, pt2 );
 246 }
 247
 248 template< class T, class A1, class A2, class A3 >
 249 boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3 )
 250 {
 251     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >() );
 252
 253     detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
 254
 255     void * pv = pd->address();
 256
 257     ::new( pv ) T( a1, a2, a3 );
 258     pd->set_initialized();
 259
 260     T * pt2 = static_cast< T* >( pv );
 261
 262     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
 263     return boost::shared_ptr< T >( pt, pt2 );
 264 }
 265
 266 template< class T, class A, class A1, class A2, class A3 >
 267 boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3 )
 268 {
 269     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >(), a );
 270
 271     detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
 272
 273     void * pv = pd->address();
 274
 275     ::new( pv ) T( a1, a2, a3 );
 276     pd->set_initialized();
 277
 278     T * pt2 = static_cast< T* >( pv );
 279
 280     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
 281     return boost::shared_ptr< T >( pt, pt2 );
 282 }
 283
 284 template< class T, class A1, class A2, class A3, class A4 >
 285 boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4 )
 286 {
 287     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >() );
 288
 289     detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
 290
 291     void * pv = pd->address();
 292
 293     ::new( pv ) T( a1, a2, a3, a4 );
 294     pd->set_initialized();
 295
 296     T * pt2 = static_cast< T* >( pv );
 297
 298     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
 299     return boost::shared_ptr< T >( pt, pt2 );
 300 }
 301
 302 template< class T, class A, class A1, class A2, class A3, class A4 >
 303 boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4 )
 304 {
 305     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >(), a );
 306
 307     detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
 308
 309     void * pv = pd->address();
 310
 311     ::new( pv ) T( a1, a2, a3, a4 );
 312     pd->set_initialized();
 313
 314     T * pt2 = static_cast< T* >( pv );
 315
 316     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
 317     return boost::shared_ptr< T >( pt, pt2 );
 318 }
 319
 320 template< class T, class A1, class A2, class A3, class A4, class A5 >
 321 boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5 )
 322 {
 323     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >() );
 324
 325     detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
 326
 327     void * pv = pd->address();
 328
 329     ::new( pv ) T( a1, a2, a3, a4, a5 );
 330     pd->set_initialized();
 331
 332     T * pt2 = static_cast< T* >( pv );
 333
 334     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
 335     return boost::shared_ptr< T >( pt, pt2 );
 336 }
 337
 338 template< class T, class A, class A1, class A2, class A3, class A4, class A5 >
 339 boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5 )
 340 {
 341     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >(), a );
 342
 343     detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
 344
 345     void * pv = pd->address();
 346
 347     ::new( pv ) T( a1, a2, a3, a4, a5 );
 348     pd->set_initialized();
 349
 350     T * pt2 = static_cast< T* >( pv );
 351
 352     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
 353     return boost::shared_ptr< T >( pt, pt2 );
 354 }
 355
 356 template< class T, class A1, class A2, class A3, class A4, class A5, class A6 >
 357 boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6 )
 358 {
 359     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >() );
 360
 361     detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
 362
 363     void * pv = pd->address();
 364
 365     ::new( pv ) T( a1, a2, a3, a4, a5, a6 );
 366     pd->set_initialized();
 367
 368     T * pt2 = static_cast< T* >( pv );
 369
 370     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
 371     return boost::shared_ptr< T >( pt, pt2 );
 372 }
 373
 374 template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6 >
 375 boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6 )
 376 {
 377     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >(), a );
 378
 379     detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
 380
 381     void * pv = pd->address();
 382
 383     ::new( pv ) T( a1, a2, a3, a4, a5, a6 );
 384     pd->set_initialized();
 385
 386     T * pt2 = static_cast< T* >( pv );
 387
 388     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
 389     return boost::shared_ptr< T >( pt, pt2 );
 390 }
 391
 392 template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7 >
 393 boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7 )
 394 {
 395     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >() );
 396
 397     detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
 398
 399     void * pv = pd->address();
 400
 401     ::new( pv ) T( a1, a2, a3, a4, a5, a6, a7 );
 402     pd->set_initialized();
 403
 404     T * pt2 = static_cast< T* >( pv );
 405
 406     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
 407     return boost::shared_ptr< T >( pt, pt2 );
 408 }
 409
 410 template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7 >
 411 boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7 )
 412 {
 413     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >(), a );
 414
 415     detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
 416
 417     void * pv = pd->address();
 418
 419     ::new( pv ) T( a1, a2, a3, a4, a5, a6, a7 );
 420     pd->set_initialized();
 421
 422     T * pt2 = static_cast< T* >( pv );
 423
 424     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
 425     return boost::shared_ptr< T >( pt, pt2 );
 426 }
 427
 428 template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 >
 429 boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8 )
 430 {
 431     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >() );
 432
 433     detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
 434
 435     void * pv = pd->address();
 436
 437     ::new( pv ) T( a1, a2, a3, a4, a5, a6, a7, a8 );
 438     pd->set_initialized();
 439
 440     T * pt2 = static_cast< T* >( pv );
 441
 442     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
 443     return boost::shared_ptr< T >( pt, pt2 );
 444 }
 445
 446 template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 >
 447 boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8 )
 448 {
 449     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >(), a );
 450
 451     detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
 452
 453     void * pv = pd->address();
 454
 455     ::new( pv ) T( a1, a2, a3, a4, a5, a6, a7, a8 );
 456     pd->set_initialized();
 457
 458     T * pt2 = static_cast< T* >( pv );
 459
 460     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
 461     return boost::shared_ptr< T >( pt, pt2 );
 462 }
 463
 464 template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9 >
 465 boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9 )
 466 {
 467     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >() );
 468
 469     detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
 470
 471     void * pv = pd->address();
 472
 473     ::new( pv ) T( a1, a2, a3, a4, a5, a6, a7, a8, a9 );
 474     pd->set_initialized();
 475
 476     T * pt2 = static_cast< T* >( pv );
 477
 478     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
 479     return boost::shared_ptr< T >( pt, pt2 );
 480 }
 481
 482 template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9 >
 483 boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9 )
 484 {
 485     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >(), a );
 486
 487     detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
 488
 489     void * pv = pd->address();
 490
 491     ::new( pv ) T( a1, a2, a3, a4, a5, a6, a7, a8, a9 );
 492     pd->set_initialized();
 493
 494     T * pt2 = static_cast< T* >( pv );
 495
 496     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
 497     return boost::shared_ptr< T >( pt, pt2 );
 498 }
 499
 500 #endif
 501
 502 } // namespace boost
 503
 504 #endif // #ifndef BOOST_SMART_PTR_MAKE_SHARED_HPP_INCLUDED