ptr_array();

• Effects: constructs array where each element is null

explicit ptr_array( const ptr_array& r );

template< class U > explicit ptr_array( const ptr_array<U,N>& r );

• Effects: Constructs array by cloning r

ptr_array( compatible-smart-ptr<ptr_array>& r );

• Effects: take ownership of the supplied pointers

ptr_array& operator=( const ptr_array& r );

template< class U > ptr_array& operator=( const ptr_array<U,N>& r );

• Effects: Assigns a clone of r
• Exception safety: Strong guarantee

ptr_array& operator=( compatible-smart-ptr<this_type> r );

• Effects: take ownership of the supplied pointers
• Throws: Nothing

T&       front();

const T& front() const;

• Requirements: not empty();
• Effects: return *begin();
• Throws: bad_ptr_container_operation if empty() == true

T&       back();

const T& back() const;

• Requirements: not empty();
• Effects: return *--end();
• Throws: bad_ptr_container_operation if empty() == true

template< size_t idx > T&       at( size_type n );

template< size_t idx > const T& at( size_type n ) const;

• Requirements: idx < size() (compile-time enforced)
• Effects: Returns a reference to the n'th element
• Throws: nothing

T&       at( size_type n );

const T& at( size_type n ) const;

• Requirements: n < size()
• Effects: Returns a reference to the n'th element
• Throws: bad_index if n >=size()

T&       operator[]( size_type n );

const T& operator[]( size_type n ) const;

• Requirements: n < size()
• Effects: Returns a reference to the n'th element
• Throws: Nothing

void swap( ptr_array& r );

• Effects: swaps the two arrays
• Complexity: Linear
• Throws: nothing

template< size_t idx > auto_type replace( T* r );

• Requirements:

  • idx < size() (compile-time enforced)
  • r != 0

• Effects: returns the object indexed by idx and replaces it with r.

• Throws: bad_pointer if x == 0.

• Exception safety: Strong guarantee

template< size_t idx, class U > auto_type replace( compatible-smart-ptr<U> r );

• Effects: return replace<idx>( r.release() );

auto_type replace( size_t idx, T* r );

• Requirements: `` x != 0 and idx < size()``
• Effects: returns the object indexed by idx and replaces it with x.
• Throws: bad_index if idx >= size() and bad_pointer if x == 0.
• Exception safety: Strong guarantee

template< class U > auto_type replace( size_t idx, compatible-smart-ptr<U> r );

• Effects: return replace( idx, r.release() );

compatible-smart-ptr<ptr_array>  clone() const;

• Effects: Returns a deep copy of the container
• Throws: std::bad_alloc if there is not enough memory to make a clone of the container
• Complexity: Linear

compatible-smart-ptr<ptr_array>  release();

• Effects: Releases ownership of the container. This is a useful way of returning a container from a function.
• Postconditions: empty() == true and all pointers are null
• Throws: std::bad_alloc if the return value cannot be allocated
• Exception safety: Strong guarantee

template< size_t idx > bool is_null() const;

• Requirements: idx < size() (compile-time enforced)
• Effects: returns whether the pointer at index idx is null
• Exception safety: Nothrow guarantee

bool is_null( size_type idx ) const;

• Requirements: idx < size()
• Effects: returns whether the pointer at index idx is null
• Exception safety: Nothrow guarantee