////
Copyright 2017 Peter Dimov

Distributed under the Boost Software License, Version 1.0.

See accompanying file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt
////

[[shared_array]]
[appendix]
# shared_array (deprecated)
:toc:
:toc-title:
:idprefix: shared_array_

NOTE: This facility is deprecated because a `shared_ptr` to `T[]` or `T[N]`
is now available, and is superior in every regard.

## Description

The `shared_array` class template stores a pointer to a dynamically allocated
array. (Dynamically allocated array are allocated with the C++ `new[]`
expression.) The object pointed to is guaranteed to be deleted when the last
`shared_array` pointing to it is destroyed or reset.

Every `shared_array` meets the _CopyConstructible_ and _Assignable_
requirements of the {cpp} Standard Library, and so can be used in standard
library containers. Comparison operators are supplied so that shared_array
works with the standard library's associative containers.

Normally, a `shared_array` cannot correctly hold a pointer to an object that
has been allocated with the non-array form of `new`. See `shared_ptr` for that
usage.

Because the implementation uses reference counting, cycles of `shared_array`
instances will not be reclaimed. For example, if `main` holds a shared_array
to `A`, which directly or indirectly holds a shared_array back to `A`, the use
count of `A` will be 2. Destruction of the original `shared_array` will leave
`A` dangling with a use count of 1.

A `shared_ptr` to a `std::vector` is an alternative to a `shared_array` that
is a bit heavier duty but far more flexible.

The class template is parameterized on `T`, the type of the object pointed to.
`shared_array` and most of its member functions place no requirements on `T`;
it is allowed to be an incomplete type, or `void`. Member functions that do
place additional requirements (constructors, reset) are explicitly documented
below.

## Synopsis

```
namespace boost {

  template<class T> class shared_array {
  public:
    typedef T element_type;

    explicit shared_array(T* p = 0);
    template<class D> shared_array(T* p, D d);
    shared_array(const shared_array& v) noexcept;

    ~shared_array() noexcept;

    shared_array& operator=(const shared_array& v) noexcept;

    void reset(T* p = 0);
    template<class D> void reset(T* p, D d);

    T& operator[](std::ptrdiff_t n) const noexcept;
    T* get() const noexcept;

    bool unique() const noexcept;
    long use_count() const noexcept;

    explicit operator bool() const noexcept;

    void swap(shared_array<T>& v) noexcept;
  };

  template<class T> bool
    operator==(const shared_array<T>& a, const shared_array<T>& b) noexcept;
  template<class T> bool
    operator!=(const shared_array<T>& a, const shared_array<T>& b) noexcept;
  template<class T> bool
    operator<(const shared_array<T>& a, const shared_array<T>& b) noexcept;

  template<class T>
    void swap(shared_array<T>& a, shared_array<T>& b) noexcept;
}
```

## Members

### element_type

```
typedef T element_type;
```
Type:: Provides the type of the stored pointer.

### Constructors

```
explicit shared_array(T* p = 0);
```
[none]
* {blank}
+
Effects:: Constructs a `shared_array`, storing a copy of `p`, which must be a
pointer to an array that was allocated via a C++ `new[]` expression or be 0.
Afterwards, the use count is 1 (even if `p == 0`; see `~shared_array`).
Requires:: `T` is a complete type.
Throws:: `std::bad_alloc`. If an exception is thrown, `delete[] p` is called.

```
template<class D> shared_array(T* p, D d);
```
[none]
* {blank}
+
Effects:: Constructs a `shared_array`, storing a copy of `p` and of `d`.
Afterwards, the use count is 1. When the the time comes to delete the array
pointed to by `p`, the object `d` is used in the statement `d(p)`.
Requires::
* `T` is a complete type.
* The copy constructor and destructor of `D` must not throw.
* Invoking the object `d` with parameter `p` must not throw.
Throws:: `std::bad_alloc`. If an exception is thrown, `d(p)` is called.

```
shared_array(const shared_array& v) noexcept;
```
[none]
* {blank}
+
Effects:: Constructs a `shared_array`, as if by storing a copy of the pointer
stored in `v`. Afterwards, the use count for all copies is 1 more than the
initial use count.
Requires:: `T` is a complete type.

### Destructor

```
~shared_array() noexcept;
```
[none]
* {blank}
+
Effects:: Decrements the use count. Then, if the use count is 0, deletes the
array pointed to by the stored pointer. Note that `delete[]` on a pointer with
a value of 0 is harmless. 

### Assignment

```
shared_array& operator=(const shared_array& v) noexcept;
```
[none]
* {blank}
+
Effects:: Constructs a new `shared_array` as described above, then replaces
this `shared_array` with the new one, destroying the replaced object.
Requires:: `T` is a complete type.
Returns:: `*this`.

### reset

```
void reset(T* p = 0);
```
[none]
* {blank}
+
Effects:: Constructs a new `shared_array` as described above, then replaces
this `shared_array` with the new one, destroying the replaced object.
Requires:: `T` is a complete type.
Throws:: `std::bad_alloc`. If an exception is thrown, `delete[] p` is called.

```
template<class D> void reset(T* p, D d);
```
[none]
* {blank}
+
Effects:: Constructs a new `shared_array` as described above, then replaces
this `shared_array` with the new one, destroying the replaced object.
Requires::
* `T` is a complete type.
* The copy constructor of `D` must not throw.
Throws:: `std::bad_alloc`. If an exception is thrown, `d(p)` is called.

### Indexing

```
T& operator[](std::ptrdiff_t n) const noexcept;
```
Returns:: A reference to element `n` of the array pointed to by the stored
pointer. Behavior is undefined and almost certainly undesirable if the stored
pointer is 0, or if `n` is less than 0 or is greater than or equal to the
number of elements in the array.
Requires:: `T` is a complete type.

### get

```
T* get() const noexcept;
```
[none]
* {blank}
+
Returns:: The stored pointer.

### unique

```
bool unique() const noexcept;
```
[none]
* {blank}
+
Returns:: `true` if no other `shared_array` is sharing ownership of the
stored pointer, `false` otherwise.

### use_count

```
long use_count() const noexcept;
```
[none]
* {blank}
+
Returns:: The number of `shared_array` objects sharing ownership of the
stored pointer.

### Conversions

```
explicit operator bool() const noexcept;
```
[none]
* {blank}
+
Returns:: `get() != 0`.
Requires:: `T` is a complete type.

### swap

```
void swap(shared_array<T>& b) noexcept;
```
[none]
* {blank}
+
Effects:: Exchanges the contents of the two smart pointers.

## Free Functions

### Comparison

```
template<class T> bool
  operator==(const shared_array<T>& a, const shared_array<T>& b) noexcept;
```
```
template<class T> bool
  operator!=(const shared_array<T>& a, const shared_array<T>& b) noexcept;
```
```
template<class T> bool
  operator<(const shared_array<T>& a, const shared_array<T>& b) noexcept;
```
[none]
* {blank}
+
Returns:: The result of comparing the stored pointers of the two smart
pointers.

NOTE: The `operator<` overload is provided to define an ordering so that
`shared_array` objects can be used in associative containers such as
`std::map`. The implementation uses `std::less<T*>` to perform the comparison.
This ensures that the comparison is handled correctly, since the standard
mandates that relational operations on pointers are unspecified (5.9
[expr.rel] paragraph 2) but `std::less` on pointers is well-defined (20.3.3
[lib.comparisons] paragraph 8).

### swap

```
template<class T>
  void swap(shared_array<T>& a, shared_array<T>& b) noexcept;
```
[none]
* {blank}
+
Returns:: `a.swap(b)`.
Requires:: `T` is a complete type.
