Ticket #7523: noexcept.patch

File noexcept.patch, 25.2 KB (added by Antony Polukhin, 10 years ago)

Updated noexcept patch for trunk version

  • detail/operator_bool.hpp

     
    88
    99#if ( defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, < 0x570) ) || defined(__CINT__)
    1010
    11     operator bool () const
     11    operator bool () const BOOST_NOEXCEPT
    1212    {
    1313        return px != 0;
    1414    }
    … …  
    2121
    2222    typedef void (*unspecified_bool_type)( this_type*** );
    2323
    24     operator unspecified_bool_type() const // never throws
     24    operator unspecified_bool_type() const BOOST_NOEXCEPT
    2525    {
    2626        return px == 0? 0: unspecified_bool;
    2727    }
    … …  
    3333
    3434    typedef element_type * (this_type::*unspecified_bool_type)() const;
    3535
    36     operator unspecified_bool_type() const // never throws
     36    operator unspecified_bool_type() const BOOST_NOEXCEPT
    3737    {
    3838        return px == 0? 0: &this_type::get;
    3939    }
    … …  
    4242
    4343    typedef element_type * this_type::*unspecified_bool_type;
    4444
    45     operator unspecified_bool_type() const // never throws
     45    operator unspecified_bool_type() const BOOST_NOEXCEPT
    4646    {
    4747        return px == 0? 0: &this_type::px;
    4848    }
    … …  
    5050#endif
    5151
    5252    // operator! is redundant, but some compilers need it
    53     bool operator! () const // never throws
     53    bool operator! () const BOOST_NOEXCEPT
    5454    {
    5555        return px == 0;
    5656    }

  • weak_ptr.hpp

     
    3131
    3232    typedef typename boost::detail::sp_element< T >::type element_type;
    3333
    34     weak_ptr(): px(0), pn() // never throws in 1.30+
     34    weak_ptr() BOOST_NOEXCEPT : px(0), pn() // never throws in 1.30+
    3535    {
    3636    }
    3737
    … …  
    4141
    4242// ... except in C++0x, move disables the implicit copy
    4343
    44     weak_ptr( weak_ptr const & r ): px( r.px ), pn( r.pn ) // never throws
     44    weak_ptr( weak_ptr const & r ) BOOST_NOEXCEPT : px( r.px ), pn( r.pn )
    4545    {
    4646    }
    4747
    48     weak_ptr & operator=( weak_ptr const & r ) // never throws
     48    weak_ptr & operator=( weak_ptr const & r ) BOOST_NOEXCEPT
    4949    {
    5050        px = r.px;
    5151        pn = r.pn;
    … …  
    8181    weak_ptr( weak_ptr<Y> const & r )
    8282
    8383#endif
    84     : px(r.lock().get()), pn(r.pn) // never throws
     84    BOOST_NOEXCEPT : px(r.lock().get()), pn(r.pn)
    8585    {
    8686        boost::detail::sp_assert_convertible< Y, T >();
    8787    }
    … …  
    9898    weak_ptr( weak_ptr<Y> && r )
    9999
    100100#endif
    101     : px( r.lock().get() ), pn( static_cast< boost::detail::weak_count && >( r.pn ) ) // never throws
     101    BOOST_NOEXCEPT : px( r.lock().get() ), pn( static_cast< boost::detail::weak_count && >( r.pn ) )
    102102    {
    103103        boost::detail::sp_assert_convertible< Y, T >();
    104104        r.px = 0;
    105105    }
    106106
    107107    // for better efficiency in the T == Y case
    108     weak_ptr( weak_ptr && r ): px( r.px ), pn( static_cast< boost::detail::weak_count && >( r.pn ) ) // never throws
     108    weak_ptr( weak_ptr && r )
     109    BOOST_NOEXCEPT : px( r.px ), pn( static_cast< boost::detail::weak_count && >( r.pn ) )
    109110    {
    110111        r.px = 0;
    111112    }
    112113
    113114    // for better efficiency in the T == Y case
    114     weak_ptr & operator=( weak_ptr && r ) // never throws
     115    weak_ptr & operator=( weak_ptr && r ) BOOST_NOEXCEPT
    115116    {
    116117        this_type( static_cast< weak_ptr && >( r ) ).swap( *this );
    117118        return *this;
    … …  
    130131    weak_ptr( shared_ptr<Y> const & r )
    131132
    132133#endif
    133     : px( r.px ), pn( r.pn ) // never throws
     134    BOOST_NOEXCEPT : px( r.px ), pn( r.pn )
    134135    {
    135136        boost::detail::sp_assert_convertible< Y, T >();
    136137    }
    … …  
    138139#if !defined(BOOST_MSVC) || (BOOST_MSVC >= 1300)
    139140
    140141    template<class Y>
    141     weak_ptr & operator=( weak_ptr<Y> const & r ) // never throws
     142    weak_ptr & operator=( weak_ptr<Y> const & r ) BOOST_NOEXCEPT
    142143    {
    143144        boost::detail::sp_assert_convertible< Y, T >();
    144145
    … …  
    151152#if defined( BOOST_HAS_RVALUE_REFS )
    152153
    153154    template<class Y>
    154     weak_ptr & operator=( weak_ptr<Y> && r )
     155    weak_ptr & operator=( weak_ptr<Y> && r ) BOOST_NOEXCEPT
    155156    {
    156157        this_type( static_cast< weak_ptr<Y> && >( r ) ).swap( *this );
    157158        return *this;
    … …  
    160161#endif
    161162
    162163    template<class Y>
    163     weak_ptr & operator=( shared_ptr<Y> const & r ) // never throws
     164    weak_ptr & operator=( shared_ptr<Y> const & r ) BOOST_NOEXCEPT
    164165    {
    165166        boost::detail::sp_assert_convertible< Y, T >();
    166167
    … …  
    172173
    173174#endif
    174175
    175     shared_ptr<T> lock() const // never throws
     176    shared_ptr<T> lock() const BOOST_NOEXCEPT
    176177    {
    177178        return shared_ptr<T>( *this, boost::detail::sp_nothrow_tag() );
    178179    }
    179180
    180     long use_count() const // never throws
     181    long use_count() const BOOST_NOEXCEPT
    181182    {
    182183        return pn.use_count();
    183184    }
    184185
    185     bool expired() const // never throws
     186    bool expired() const BOOST_NOEXCEPT
    186187    {
    187188        return pn.use_count() == 0;
    188189    }
    … …  
    192193        return pn.empty();
    193194    }
    194195
    195     void reset() // never throws in 1.30+
     196    void reset() BOOST_NOEXCEPT // never throws in 1.30+
    196197    {
    197198        this_type().swap(*this);
    198199    }
    199200
    200     void swap(this_type & other) // never throws
     201    void swap(this_type & other) BOOST_NOEXCEPT
    201202    {
    202203        std::swap(px, other.px);
    203204        pn.swap(other.pn);
    … …  
    210211        pn = r.pn;
    211212    }
    212213
    213     template<class Y> bool owner_before( weak_ptr<Y> const & rhs ) const
     214    template<class Y> bool owner_before( weak_ptr<Y> const & rhs ) const BOOST_NOEXCEPT
    214215    {
    215216        return pn < rhs.pn;
    216217    }
    217218
    218     template<class Y> bool owner_before( shared_ptr<Y> const & rhs ) const
     219    template<class Y> bool owner_before( shared_ptr<Y> const & rhs ) const BOOST_NOEXCEPT
    219220    {
    220221        return pn < rhs.pn;
    221222    }
    … …  
    237238
    238239};  // weak_ptr
    239240
    240 template<class T, class U> inline bool operator<(weak_ptr<T> const & a, weak_ptr<U> const & b)
     241template<class T, class U> inline bool operator<(weak_ptr<T> const & a, weak_ptr<U> const & b) BOOST_NOEXCEPT
    241242{
    242243    return a.owner_before( b );
    243244}
    244245
    245 template<class T> void swap(weak_ptr<T> & a, weak_ptr<T> & b)
     246template<class T> void swap(weak_ptr<T> & a, weak_ptr<T> & b) BOOST_NOEXCEPT
    246247{
    247248    a.swap(b);
    248249}

  • intrusive_ptr.hpp

     
    5858
    5959    typedef T element_type;
    6060
    61     intrusive_ptr(): px( 0 )
     61    intrusive_ptr() BOOST_NOEXCEPT : px( 0 )
    6262    {
    6363    }
    6464
    … …  
    110110
    111111#if defined( BOOST_HAS_RVALUE_REFS )
    112112
    113     intrusive_ptr(intrusive_ptr && rhs): px( rhs.px )
     113    intrusive_ptr(intrusive_ptr && rhs) BOOST_NOEXCEPT : px( rhs.px )
    114114    {
    115115        rhs.px = 0;
    116116    }
    117117
    118     intrusive_ptr & operator=(intrusive_ptr && rhs)
     118    intrusive_ptr & operator=(intrusive_ptr && rhs) BOOST_NOEXCEPT
    119119    {
    120120        this_type( static_cast< intrusive_ptr && >( rhs ) ).swap(*this);
    121121        return *this;
    … …  
    135135        return *this;
    136136    }
    137137
    138     void reset()
     138    void reset() BOOST_NOEXCEPT
    139139    {
    140140        this_type().swap( *this );
    141141    }
    … …  
    145145        this_type( rhs ).swap( *this );
    146146    }
    147147
    148     T * get() const
     148    T * get() const BOOST_NOEXCEPT
    149149    {
    150150        return px;
    151151    }
    … …  
    165165// implicit conversion to "bool"
    166166#include <boost/smart_ptr/detail/operator_bool.hpp>
    167167
    168     void swap(intrusive_ptr & rhs)
     168    void swap(intrusive_ptr & rhs) BOOST_NOEXCEPT
    169169    {
    170170        T * tmp = px;
    171171        px = rhs.px;

  • enable_shared_from_this.hpp

     
    2525{
    2626protected:
    2727
    28     enable_shared_from_this()
     28    enable_shared_from_this() BOOST_NOEXCEPT
    2929    {
    3030    }
    3131
    32     enable_shared_from_this(enable_shared_from_this const &)
     32    enable_shared_from_this(enable_shared_from_this const &) BOOST_NOEXCEPT
    3333    {
    3434    }
    3535
    36     enable_shared_from_this & operator=(enable_shared_from_this const &)
     36    enable_shared_from_this & operator=(enable_shared_from_this const &) BOOST_NOEXCEPT
    3737    {
    3838        return *this;
    3939    }
    4040
    41     ~enable_shared_from_this()
     41    ~enable_shared_from_this() BOOST_NOEXCEPT // ~weak_ptr<T> newer throws, so this call also must not throw
    4242    {
    4343    }
    4444

  • make_shared_object.hpp

     
    6767
    6868public:
    6969
    70     sp_ms_deleter(): initialized_( false )
     70    sp_ms_deleter() BOOST_NOEXCEPT : initialized_( false )
    7171    {
    7272    }
    7373
    7474    // optimization: do not copy storage_
    75     sp_ms_deleter( sp_ms_deleter const & ): initialized_( false )
     75    sp_ms_deleter( sp_ms_deleter const & ) BOOST_NOEXCEPT : initialized_( false )
    7676    {
    7777    }
    7878
    … …  
    8686        destroy();
    8787    }
    8888
    89     void * address()
     89    void * address() BOOST_NOEXCEPT
    9090    {
    9191        return storage_.data_;
    9292    }
    9393
    94     void set_initialized()
     94    void set_initialized() BOOST_NOEXCEPT
    9595    {
    9696        initialized_ = true;
    9797    }
    … …  
    9999
    100100#if defined( BOOST_HAS_RVALUE_REFS )
    101101
    102 template< class T > T&& sp_forward( T & t )
     102template< class T > T&& sp_forward( T & t ) BOOST_NOEXCEPT
    103103{
    104104    return static_cast< T&& >( t );
    105105}

  • shared_ptr.hpp

     
    324324
    325325    typedef typename boost::detail::sp_element< T >::type element_type;
    326326
    327     shared_ptr(): px( 0 ), pn() // never throws in 1.30+
     327    shared_ptr() BOOST_NOEXCEPT : px( 0 ), pn() // never throws in 1.30+
    328328    {
    329329    }
    330330
    … …  
    358358
    359359// ... except in C++0x, move disables the implicit copy
    360360
    361     shared_ptr( shared_ptr const & r ): px( r.px ), pn( r.pn ) // never throws
     361    shared_ptr( shared_ptr const & r ) BOOST_NOEXCEPT : px( r.px ), pn( r.pn )
    362362    {
    363363    }
    364364
    … …  
    374374    }
    375375
    376376    template<class Y>
    377     shared_ptr( weak_ptr<Y> const & r, boost::detail::sp_nothrow_tag ): px( 0 ), pn( r.pn, boost::detail::sp_nothrow_tag() ) // never throws
     377    shared_ptr( weak_ptr<Y> const & r, boost::detail::sp_nothrow_tag )
     378    BOOST_NOEXCEPT : px( 0 ), pn( r.pn, boost::detail::sp_nothrow_tag() )
    378379    {
    379380        if( !pn.empty() )
    380381        {
    … …  
    392393    shared_ptr( shared_ptr<Y> const & r )
    393394
    394395#endif
    395     : px( r.px ), pn( r.pn ) // never throws
     396    BOOST_NOEXCEPT : px( r.px ), pn( r.pn )
    396397    {
    397398        boost::detail::sp_assert_convertible< Y, T >();
    398399    }
    399400
    400401    // aliasing
    401402    template< class Y >
    402     shared_ptr( shared_ptr<Y> const & r, element_type * p ): px( p ), pn( r.pn ) // never throws
     403    shared_ptr( shared_ptr<Y> const & r, element_type * p ) BOOST_NOEXCEPT : px( p ), pn( r.pn )
    403404    {
    404405    }
    405406
    406407    template<class Y>
    407     shared_ptr(shared_ptr<Y> const & r, boost::detail::static_cast_tag): px(static_cast<element_type *>(r.px)), pn(r.pn)
     408    shared_ptr(shared_ptr<Y> const & r, boost::detail::static_cast_tag)
     409    BOOST_NOEXCEPT : px(static_cast<element_type *>(r.px)), pn(r.pn)
    408410    {
    409411    }
    410412
    411413    template<class Y>
    412     shared_ptr(shared_ptr<Y> const & r, boost::detail::const_cast_tag): px(const_cast<element_type *>(r.px)), pn(r.pn)
     414    shared_ptr(shared_ptr<Y> const & r, boost::detail::const_cast_tag)
     415    BOOST_NOEXCEPT : px(const_cast<element_type *>(r.px)), pn(r.pn)
    413416    {
    414417    }
    415418
    … …  
    480483
    481484    // assignment
    482485
    483     shared_ptr & operator=( shared_ptr const & r ) // never throws
     486    shared_ptr & operator=( shared_ptr const & r ) BOOST_NOEXCEPT
    484487    {
    485488        this_type(r).swap(*this);
    486489        return *this;
    … …  
    489492#if !defined(BOOST_MSVC) || (BOOST_MSVC >= 1400)
    490493
    491494    template<class Y>
    492     shared_ptr & operator=(shared_ptr<Y> const & r) // never throws
     495    shared_ptr & operator=(shared_ptr<Y> const & r) BOOST_NOEXCEPT
    493496    {
    494497        this_type(r).swap(*this);
    495498        return *this;
    … …  
    523526
    524527#if defined( BOOST_HAS_RVALUE_REFS )
    525528
    526     shared_ptr( shared_ptr && r ): px( r.px ), pn() // never throws
     529    shared_ptr( shared_ptr && r ) BOOST_NOEXCEPT : px( r.px ), pn()
    527530    {
    528531        pn.swap( r.pn );
    529532        r.px = 0;
    … …  
    539542    shared_ptr( shared_ptr<Y> && r )
    540543
    541544#endif
    542     : px( r.px ), pn() // never throws
     545    BOOST_NOEXCEPT : px( r.px ), pn()
    543546    {
    544547        boost::detail::sp_assert_convertible< Y, T >();
    545548
    … …  
    547550        r.px = 0;
    548551    }
    549552
    550     shared_ptr & operator=( shared_ptr && r ) // never throws
     553    shared_ptr & operator=( shared_ptr && r ) BOOST_NOEXCEPT
    551554    {
    552555        this_type( static_cast< shared_ptr && >( r ) ).swap( *this );
    553556        return *this;
    554557    }
    555558
    556559    template<class Y>
    557     shared_ptr & operator=( shared_ptr<Y> && r ) // never throws
     560    shared_ptr & operator=( shared_ptr<Y> && r ) BOOST_NOEXCEPT
    558561    {
    559562        this_type( static_cast< shared_ptr<Y> && >( r ) ).swap( *this );
    560563        return *this;
    … …  
    562565
    563566#endif
    564567
    565     void reset() // never throws in 1.30+
     568    void reset() BOOST_NOEXCEPT // never throws in 1.30+
    566569    {
    567570        this_type().swap(*this);
    568571    }
    … …  
    587590    {
    588591        this_type( r, p ).swap( *this );
    589592    }
    590 
    591     typename boost::detail::sp_dereference< T >::type operator* () const // never throws
     593   
     594    // never throws (but has a BOOST_ASSERT in it, so not marked with BOOST_NOEXCEPT)
     595    typename boost::detail::sp_dereference< T >::type operator* () const
    592596    {
    593597        BOOST_ASSERT( px != 0 );
    594598        return *px;
    595599    }
    596 
    597     typename boost::detail::sp_member_access< T >::type operator-> () const // never throws
     600   
     601    // never throws (but has a BOOST_ASSERT in it, so not marked with BOOST_NOEXCEPT)
     602    typename boost::detail::sp_member_access< T >::type operator-> () const
    598603    {
    599604        BOOST_ASSERT( px != 0 );
    600605        return px;
    601606    }
    602 
    603     typename boost::detail::sp_array_access< T >::type operator[] ( std::ptrdiff_t i ) const // never throws
     607   
     608    // never throws (but has a BOOST_ASSERT in it, so not marked with BOOST_NOEXCEPT)
     609    typename boost::detail::sp_array_access< T >::type operator[] ( std::ptrdiff_t i ) const
    604610    {
    605611        BOOST_ASSERT( px != 0 );
    606612        BOOST_ASSERT( i >= 0 && ( i < boost::detail::sp_extent< T >::value || boost::detail::sp_extent< T >::value == 0 ) );
    … …  
    608614        return px[ i ];
    609615    }
    610616
    611     element_type * get() const // never throws
     617    element_type * get() const BOOST_NOEXCEPT
    612618    {
    613619        return px;
    614620    }
    … …  
    616622// implicit conversion to "bool"
    617623#include <boost/smart_ptr/detail/operator_bool.hpp>
    618624
    619     bool unique() const // never throws
     625    bool unique() const BOOST_NOEXCEPT
    620626    {
    621627        return pn.unique();
    622628    }
    623629
    624     long use_count() const // never throws
     630    long use_count() const BOOST_NOEXCEPT
    625631    {
    626632        return pn.use_count();
    627633    }
    628634
    629     void swap( shared_ptr & other ) // never throws
     635    void swap( shared_ptr & other ) BOOST_NOEXCEPT
    630636    {
    631637        std::swap(px, other.px);
    632638        pn.swap(other.pn);
    633639    }
    634640
    635     template<class Y> bool owner_before( shared_ptr<Y> const & rhs ) const
     641    template<class Y> bool owner_before( shared_ptr<Y> const & rhs ) const BOOST_NOEXCEPT
    636642    {
    637643        return pn < rhs.pn;
    638644    }
    639645
    640     template<class Y> bool owner_before( weak_ptr<Y> const & rhs ) const
     646    template<class Y> bool owner_before( weak_ptr<Y> const & rhs ) const BOOST_NOEXCEPT
    641647    {
    642648        return pn < rhs.pn;
    643649    }
    … …  
    647653        return pn.get_deleter( ti );
    648654    }
    649655
    650     bool _internal_equiv( shared_ptr const & r ) const
     656    bool _internal_equiv( shared_ptr const & r ) const BOOST_NOEXCEPT
    651657    {
    652658        return px == r.px && pn == r.pn;
    653659    }
    … …  
    670676
    671677};  // shared_ptr
    672678
    673 template<class T, class U> inline bool operator==(shared_ptr<T> const & a, shared_ptr<U> const & b)
     679template<class T, class U> inline bool operator==(shared_ptr<T> const & a, shared_ptr<U> const & b) BOOST_NOEXCEPT
    674680{
    675681    return a.get() == b.get();
    676682}
    677683
    678 template<class T, class U> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<U> const & b)
     684template<class T, class U> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<U> const & b) BOOST_NOEXCEPT
    679685{
    680686    return a.get() != b.get();
    681687}
    … …  
    684690
    685691// Resolve the ambiguity between our op!= and the one in rel_ops
    686692
    687 template<class T> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<T> const & b)
     693template<class T> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<T> const & b) BOOST_NOEXCEPT
    688694{
    689695    return a.get() != b.get();
    690696}
    691697
    692698#endif
    693699
    694 template<class T, class U> inline bool operator<(shared_ptr<T> const & a, shared_ptr<U> const & b)
     700template<class T, class U> inline bool operator<(shared_ptr<T> const & a, shared_ptr<U> const & b) BOOST_NOEXCEPT
    695701{
    696702    return a.owner_before( b );
    697703}
    698704
    699 template<class T> inline void swap(shared_ptr<T> & a, shared_ptr<T> & b)
     705template<class T> inline void swap(shared_ptr<T> & a, shared_ptr<T> & b) BOOST_NOEXCEPT
    700706{
    701707    a.swap(b);
    702708}
    … …  
    741747
    742748// get_pointer() enables boost::mem_fn to recognize shared_ptr
    743749
    744 template<class T> inline T * get_pointer(shared_ptr<T> const & p)
     750template<class T> inline T * get_pointer(shared_ptr<T> const & p) BOOST_NOEXCEPT
    745751{
    746752    return p.get();
    747753}
    … …  
    854860
    855861#if !defined(BOOST_SP_NO_ATOMIC_ACCESS)
    856862
    857 template<class T> inline bool atomic_is_lock_free( shared_ptr<T> const * /*p*/ )
     863template<class T> inline bool atomic_is_lock_free( shared_ptr<T> const * /*p*/ ) BOOST_NOEXCEPT
    858864{
    859865    return false;
    860866}
    … …  
    933939
    934940template< class T > struct hash;
    935941
    936 template< class T > std::size_t hash_value( boost::shared_ptr<T> const & p )
     942template< class T > std::size_t hash_value( boost::shared_ptr<T> const & p ) BOOST_NOEXCEPT
    937943{
    938944    return boost::hash< T* >()( p.get() );
    939945}

  • scoped_ptr.hpp

     
    6363
    6464#ifndef BOOST_NO_AUTO_PTR
    6565
    66     explicit scoped_ptr( std::auto_ptr<T> p ): px( p.release() ) // never throws
     66    explicit scoped_ptr( std::auto_ptr<T> p ) BOOST_NOEXCEPT : px( p.release() )
    6767    {
    6868#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
    6969        boost::sp_scalar_constructor_hook( px );
    … …  
    9898        return px;
    9999    }
    100100
    101     T * get() const // never throws
     101    T * get() const BOOST_NOEXCEPT
    102102    {
    103103        return px;
    104104    }
    … …  
    106106// implicit conversion to "bool"
    107107#include <boost/smart_ptr/detail/operator_bool.hpp>
    108108
    109     void swap(scoped_ptr & b) // never throws
     109    void swap(scoped_ptr & b) BOOST_NOEXCEPT
    110110    {
    111111        T * tmp = b.px;
    112112        b.px = px;
    … …  
    114114    }
    115115};
    116116
    117 template<class T> inline void swap(scoped_ptr<T> & a, scoped_ptr<T> & b) // never throws
     117template<class T> inline void swap(scoped_ptr<T> & a, scoped_ptr<T> & b) BOOST_NOEXCEPT
    118118{
    119119    a.swap(b);
    120120}
    121121
    122122// get_pointer(p) is a generic way to say p.get()
    123123
    124 template<class T> inline T * get_pointer(scoped_ptr<T> const & p)
     124template<class T> inline T * get_pointer(scoped_ptr<T> const & p) BOOST_NOEXCEPT
    125125{
    126126    return p.get();
    127127}

  • shared_array.hpp

     
    5656
    5757    typedef T element_type;
    5858
    59     shared_array(): px( 0 ), pn() // never throws
     59    shared_array() BOOST_NOEXCEPT : px( 0 ), pn()
    6060    {
    6161    }
    6262
    … …  
    9090
    9191// ... except in C++0x, move disables the implicit copy
    9292
    93     shared_array( shared_array const & r ): px( r.px ), pn( r.pn ) // never throws
     93    shared_array( shared_array const & r ) BOOST_NOEXCEPT : px( r.px ), pn( r.pn )
    9494    {
    9595    }
    9696
    97     shared_array( shared_array && r ): px( r.px ), pn() // never throws
     97    shared_array( shared_array && r ) BOOST_NOEXCEPT : px( r.px ), pn()
    9898    {
    9999        pn.swap( r.pn );
    100100        r.px = 0;
    … …  
    114114    shared_array( shared_array<Y> const & r )
    115115
    116116#endif
    117     : px( r.px ), pn( r.pn ) // never throws
     117    BOOST_NOEXCEPT : px( r.px ), pn( r.pn ) // never throws
    118118    {
    119119        boost::detail::sp_assert_convertible< Y[], T[] >();
    120120    }
    … …  
    122122    // aliasing
    123123
    124124    template< class Y >
    125     shared_array( shared_array<Y> const & r, element_type * p ): px( p ), pn( r.pn ) // never throws
     125    shared_array( shared_array<Y> const & r, element_type * p ) BOOST_NOEXCEPT : px( p ), pn( r.pn )
    126126    {
    127127    }
    128128
    129129    // assignment
    130130
    131     shared_array & operator=( shared_array const & r ) // never throws
     131    shared_array & operator=( shared_array const & r ) BOOST_NOEXCEPT
    132132    {
    133133        this_type( r ).swap( *this );
    134134        return *this;
    … …  
    137137#if !defined(BOOST_MSVC) || (BOOST_MSVC >= 1400)
    138138
    139139    template<class Y>
    140     shared_array & operator=( shared_array<Y> const & r ) // never throws
     140    shared_array & operator=( shared_array<Y> const & r ) BOOST_NOEXCEPT
    141141    {
    142142        this_type( r ).swap( *this );
    143143        return *this;
    … …  
    147147
    148148#if defined( BOOST_HAS_RVALUE_REFS )
    149149
    150     shared_array & operator=( shared_array && r ) // never throws
     150    shared_array & operator=( shared_array && r ) BOOST_NOEXCEPT
    151151    {
    152152        this_type( static_cast< shared_array && >( r ) ).swap( *this );
    153153        return *this;
    154154    }
    155155
    156156    template<class Y>
    157     shared_array & operator=( shared_array<Y> && r ) // never throws
     157    shared_array & operator=( shared_array<Y> && r ) BOOST_NOEXCEPT
    158158    {
    159159        this_type( static_cast< shared_array<Y> && >( r ) ).swap( *this );
    160160        return *this;
    … …  
    162162
    163163#endif
    164164
    165     void reset() // never throws
     165    void reset() BOOST_NOEXCEPT
    166166    {
    167167        this_type().swap( *this );
    168168    }
    … …  
    188188        this_type( r, p ).swap( *this );
    189189    }
    190190
    191     T & operator[] (std::ptrdiff_t i) const // never throws
     191    T & operator[] (std::ptrdiff_t i) const // never throws (but has a BOOST_ASSERT in it, so not marked with BOOST_NOEXCEPT)
    192192    {
    193193        BOOST_ASSERT(px != 0);
    194194        BOOST_ASSERT(i >= 0);
    195195        return px[i];
    196196    }
    197197   
    198     T * get() const // never throws
     198    T * get() const BOOST_NOEXCEPT
    199199    {
    200200        return px;
    201201    }
    … …  
    203203// implicit conversion to "bool"
    204204#include <boost/smart_ptr/detail/operator_bool.hpp>
    205205
    206     bool unique() const // never throws
     206    bool unique() const BOOST_NOEXCEPT
    207207    {
    208208        return pn.unique();
    209209    }
    210210
    211     long use_count() const // never throws
     211    long use_count() const BOOST_NOEXCEPT
    212212    {
    213213        return pn.use_count();
    214214    }
    215215
    216     void swap(shared_array<T> & other) // never throws
     216    void swap(shared_array<T> & other) BOOST_NOEXCEPT
    217217    {
    218218        std::swap(px, other.px);
    219219        pn.swap(other.pn);
    … …  
    233233
    234234};  // shared_array
    235235
    236 template<class T> inline bool operator==(shared_array<T> const & a, shared_array<T> const & b) // never throws
     236template<class T> inline bool operator==(shared_array<T> const & a, shared_array<T> const & b) BOOST_NOEXCEPT
    237237{
    238238    return a.get() == b.get();
    239239}
    240240
    241 template<class T> inline bool operator!=(shared_array<T> const & a, shared_array<T> const & b) // never throws
     241template<class T> inline bool operator!=(shared_array<T> const & a, shared_array<T> const & b) BOOST_NOEXCEPT
    242242{
    243243    return a.get() != b.get();
    244244}
    245245
    246 template<class T> inline bool operator<(shared_array<T> const & a, shared_array<T> const & b) // never throws
     246template<class T> inline bool operator<(shared_array<T> const & a, shared_array<T> const & b) BOOST_NOEXCEPT
    247247{
    248248    return std::less<T*>()(a.get(), b.get());
    249249}
    250250
    251 template<class T> void swap(shared_array<T> & a, shared_array<T> & b) // never throws
     251template<class T> void swap(shared_array<T> & a, shared_array<T> & b) BOOST_NOEXCEPT
    252252{
    253253    a.swap(b);
    254254}

  • scoped_array.hpp

     
    5353
    5454    typedef T element_type;
    5555
    56     explicit scoped_array( T * p = 0 ) : px( p ) // never throws
     56    explicit scoped_array( T * p = 0 ) BOOST_NOEXCEPT : px( p )
    5757    {
    5858#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
    5959        boost::sp_array_constructor_hook( px );
    … …  
    6868        boost::checked_array_delete( px );
    6969    }
    7070
    71     void reset(T * p = 0) // never throws
     71    void reset(T * p = 0) // never throws (but has a BOOST_ASSERT in it, so not marked with BOOST_NOEXCEPT)
    7272    {
    7373        BOOST_ASSERT( p == 0 || p != px ); // catch self-reset errors
    7474        this_type(p).swap(*this);
    7575    }
    7676
    77     T & operator[](std::ptrdiff_t i) const // never throws
     77    T & operator[](std::ptrdiff_t i) const // never throws (but has a BOOST_ASSERT in it, so not marked with BOOST_NOEXCEPT)
    7878    {
    7979        BOOST_ASSERT( px != 0 );
    8080        BOOST_ASSERT( i >= 0 );
    8181        return px[i];
    8282    }
    8383
    84     T * get() const // never throws
     84    T * get() const BOOST_NOEXCEPT
    8585    {
    8686        return px;
    8787    }
    … …  
    8989// implicit conversion to "bool"
    9090#include <boost/smart_ptr/detail/operator_bool.hpp>
    9191
    92     void swap(scoped_array & b) // never throws
     92    void swap(scoped_array & b) BOOST_NOEXCEPT
    9393    {
    9494        T * tmp = b.px;
    9595        b.px = px;
    … …  
    9797    }
    9898};
    9999
    100 template<class T> inline void swap(scoped_array<T> & a, scoped_array<T> & b) // never throws
     100template<class T> inline void swap(scoped_array<T> & a, scoped_array<T> & b) BOOST_NOEXCEPT
    101101{
    102102    a.swap(b);
    103103}