forked from boostorg/smart_ptr
Update make_shared for arrays documentation
This commit is contained in:
Glen Fernandes
@ -5,7 +5,7 @@
|
||||
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
|
||||
</head>
|
||||
<body text="#000000" bgColor="#ffffff" link="#0000ff" vlink="#0000ff">
|
||||
<h1><IMG height="86" alt="boost.png (6897 bytes)" src="../../boost.png"
|
||||
<h1><img height="86" alt="boost.png (6897 bytes)" src="../../boost.png"
|
||||
width="277" align="middle" border="0">make_shared and allocate_shared
|
||||
for arrays</h1>
|
||||
<p><A href="#Introduction">Introduction</A><br>
|
||||
@ -29,103 +29,69 @@
|
||||
allowing finer control.</p>
|
||||
<h2><a name="Synopsis">Synopsis</a></h2>
|
||||
<pre>namespace boost {
|
||||
template<typename U> // U = T[]
|
||||
template<typename U> // U is T[]
|
||||
shared_ptr<U> <a href="#functions">make_shared</a>(size_t size);
|
||||
|
||||
template<typename U, typename A> // U = T[]
|
||||
template<typename U, typename A> // U is T[]
|
||||
shared_ptr<U> <a href="#functions">allocate_shared</a>(const A& allocator, size_t size);
|
||||
|
||||
template<typename U> // U is T[N]
|
||||
shared_ptr<U> <a href="#functions">make_shared</a>();
|
||||
|
||||
#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
|
||||
template<typename U, typename... Args> // U = T[]
|
||||
shared_ptr<U> <a href="#functions">make_shared</a>(size_t size, Args&&... args);
|
||||
template<typename U, typename A> // U is T[N]
|
||||
shared_ptr<U> <a href="#functions">allocate_shared</a>(const A& allocator);
|
||||
|
||||
template<typename U> // U is T[]
|
||||
shared_ptr<U> <a href="#functions">make_shared</a>(size_t size, const T& value);
|
||||
|
||||
template<typename U, typename... Args> // U = T[N]
|
||||
shared_ptr<U> <a href="#functions">make_shared</a>(Args&&... args);
|
||||
template<typename U, typename A> // U is T[]
|
||||
shared_ptr<U> <a href="#functions">allocate_shared</a>(const A& allocator, size_t size, const T& value);
|
||||
|
||||
template<typename U, typename A, typename... Args> // U = T[]
|
||||
shared_ptr<U> <a href="#functions">allocate_shared</a>(const A& allocator, size_t size, Args&&... args);
|
||||
template<typename U> // U is T[N]
|
||||
shared_ptr<U> <a href="#functions">make_shared</a>(const T& value);
|
||||
|
||||
template<typename U, typename A, typename... Args> // U = T[N]
|
||||
shared_ptr<U> <a href="#functions">allocate_shared</a>(const A& allocator, Args&&... args);
|
||||
#endif
|
||||
template<typename U, typename A> // U is T[N]
|
||||
shared_ptr<U> <a href="#functions">allocate_shared</a>(const A& allocator, const T& value);
|
||||
|
||||
#if !defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX)
|
||||
template<typename U, typename... Args> // U = T[N]
|
||||
shared_ptr<U> <a href="#functions">make_shared</a>(const T (&list)[N]);
|
||||
|
||||
template<typename U, typename... Args> // U = T[][N]
|
||||
shared_ptr<U> <a href="#functions">make_shared</a>(size_t size, const T (&list)[N]);
|
||||
|
||||
template<typename U, typename... Args> // U = T[M][N]
|
||||
shared_ptr<U> <a href="#functions">make_shared</a>(const T (&list)[N]);
|
||||
|
||||
template<typename U, typename A, typename... Args> // U = T[N]
|
||||
shared_ptr<T[> <a href="#functions">allocate_shared</a>(const A& allocator, const T (&list)[N]);
|
||||
|
||||
template<typename U, typename A, typename... Args> // U = T[][N]
|
||||
shared_ptr<U> <a href="#functions">allocate_shared</a>(const A& allocator, size_t size, const T (&list)[N]);
|
||||
|
||||
template<typename U, typename A, typename... Args> // U = T[M][N]
|
||||
shared_ptr<U> <a href="#functions">allocate_shared</a>(const A& allocator, const T (&list)[N]);
|
||||
|
||||
#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
|
||||
template<typename U, typename... Args> // U = T[]
|
||||
shared_ptr<U> <a href="#functions">make_shared</a>(initializer_list<T> list);
|
||||
|
||||
template<typename U, typename A, typename... Args> // U = T[]
|
||||
shared_ptr<U> <a href="#functions">allocate_shared</a>(const A& allocator, initializer_list<T> list);
|
||||
#endif
|
||||
|
||||
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
|
||||
template<typename U> // U = T[]
|
||||
shared_ptr<U> <a href="#functions">make_shared</a>(size_t size, T&& value);
|
||||
|
||||
template<typename U> // U = T[N]
|
||||
shared_ptr<U> <a href="#functions">make_shared</a>(T&& value);
|
||||
|
||||
template<typename U, typename A> // U = T[]
|
||||
shared_ptr<U> <a href="#functions">allocate_shared</a>(const A& allocator, size_t size, T&& value);
|
||||
|
||||
template<typename U, typename A> // U = T[N]
|
||||
shared_ptr<U> <a href="#functions">allocate_shared</a>(const A& allocator, T&& value);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
template<typename U> // U = T[]
|
||||
template<typename U> // U is T[]
|
||||
shared_ptr<U> <a href="#functions">make_shared_noinit</a>(size_t size);
|
||||
|
||||
template<typename U> // U = T[N]
|
||||
shared_ptr<U> <a href="#functions">make_shared_noinit</a>();
|
||||
|
||||
template<typename U, typename A> // U = T[]
|
||||
template<typename U, typename A> // U is T[]
|
||||
shared_ptr<U> <a href="#functions">allocate_shared_noinit</a>(const A& allocator, size_t size);
|
||||
|
||||
template<typename U, typename A> // U = T[N]
|
||||
template<typename U> // U is T[N]
|
||||
shared_ptr<U> <a href="#functions">make_shared_noinit</a>();
|
||||
|
||||
template<typename U, typename A> // U is T[N]
|
||||
shared_ptr<U> <a href="#functions">allocate_shared_noinit</a>(const A& allocator);
|
||||
}</pre>
|
||||
<h2><a name="functions">Free Functions</a></h2>
|
||||
<pre>template<typename U, typename... Args> // U = T[]
|
||||
shared_ptr<U> make_shared(size_t size, Args&&... args);
|
||||
<pre>template<typename U> // U is T[]
|
||||
shared_ptr<U> make_shared(size_t size);
|
||||
|
||||
template<typename U, typename A, typename... Args> // U = T[]
|
||||
shared_ptr<U> allocate_shared(const A& allocator, size_t size, Args&&... args);</pre>
|
||||
template<typename U, typename A> // U is T[]
|
||||
shared_ptr<U> allocate_shared(const A& allocator, size_t size);
|
||||
|
||||
template<typename U> // U is T[N]
|
||||
shared_ptr<U> make_shared();
|
||||
|
||||
template<typename U, typename A> // U is T[N]
|
||||
shared_ptr<U> allocate_shared(const A& allocator);</pre>
|
||||
<blockquote>
|
||||
<p><b>Requires:</b> The expression
|
||||
<code>new(pointer) T(forward<Args>(args)...)</code>, where
|
||||
<code>pointer</code> is a <code>void*</code> pointing to storage
|
||||
suitable to hold an object of type <code>T</code>, shall be
|
||||
well-formed. <code>A</code> shall be an <em>Allocator</em>, as
|
||||
described in section 20.1.5 (<strong>Allocator requirements</strong>)
|
||||
of the C++ Standard. The copy constructor and destructor of
|
||||
<code>A</code> shall not throw.</p>
|
||||
<code>new(pointer) T()</code>, where <code>pointer</code> is a
|
||||
<code>void*</code> pointing to storage suitable to hold an object
|
||||
of type <code>T</code>, shall be well-formed. <code>A</code>
|
||||
shall be an <em>Allocator</em>, as described in section 20.1.5
|
||||
(<strong>Allocator requirements</strong>) of the C++ Standard.
|
||||
The copy constructor and destructor of <code>A</code> shall not
|
||||
throw.</p>
|
||||
<p><b>Effects:</b> Allocates memory suitable for an array of type
|
||||
<code>T</code> and size <code>size</code> and constructs an array
|
||||
of objects in it via the placement new expression
|
||||
<code>new(pointer) T()</code> or
|
||||
<code>new(pointer) T(args...)</code>.
|
||||
<code>allocate_shared</code> uses a copy of
|
||||
<code>allocator</code> to allocate memory. If an exception is thrown,
|
||||
has no effect.</p>
|
||||
<code>new(pointer) T()</code>. <code>allocate_shared</code> uses
|
||||
a copy of <code>allocator</code> to allocate memory. If an
|
||||
exception is thrown, has no effect.</p>
|
||||
<p><b>Returns:</b> A <code>shared_ptr</code> instance that stores and
|
||||
owns the address of the newly constructed array of type <code>T</code>
|
||||
and size <code>size</code>.</p>
|
||||
@ -137,121 +103,63 @@ shared_ptr<U> allocate_shared(const A& allocator, size_t size, Args&am
|
||||
the returned <code>shared_ptr</code> and an array of type
|
||||
<code>T</code> of size <code>size</code> in a single allocation. This
|
||||
provides efficiency to equivalent to an intrusive smart array
|
||||
pointer.</p>
|
||||
<p>The prototypes shown above are used if your compiler supports r-value
|
||||
references and variadic templates. They perfectly forward the
|
||||
<code>args</code> parameters to the constructors of
|
||||
<code>T</code> for each array element.</p>
|
||||
<p>Otherwise, you can use the overloads which take only the array size
|
||||
(and the allocator in case of <code>allocate_shared</code>) and do not
|
||||
take any constructor arguments. These overloads invoke the default
|
||||
constructor of <code>T</code> for each array element.</p>
|
||||
pointer.</p>
|
||||
</blockquote>
|
||||
<pre>template<typename U, typename... Args> // U = T[N]
|
||||
shared_ptr<U> make_shared(Args&&... args);
|
||||
<pre>template<typename U> // U is T[]
|
||||
shared_ptr<U> make_shared(size_t size, const T& value);
|
||||
|
||||
template<typename U, typename A, typename... Args> // U = T[N]
|
||||
shared_ptr<U> allocate_shared(const A& allocator, Args&&... args);</pre>
|
||||
<blockquote>
|
||||
<p><b>Description:</b> These overloads of the utilities above are for a
|
||||
fixed size array.</p>
|
||||
</blockquote>
|
||||
<pre>template<typename U, typename... Args> // U = T[]
|
||||
shared_ptr<U> make_shared(initializer_list<T> list);
|
||||
template<typename U, typename A> // U is T[]
|
||||
shared_ptr<U> allocate_shared(const A& allocator, size_t size, const T& value);
|
||||
|
||||
template<typename U, typename A, typename... Args> // U = T[]
|
||||
shared_ptr<U> allocate_shared(const A& allocator, initializer_list<T> list);</pre>
|
||||
<blockquote>
|
||||
<p><b>Description:</b> These overloads initialize the array elements
|
||||
from the initializer list.</p>
|
||||
</blockquote>
|
||||
<pre>template<typename U, typename... Args> // U = T[N]
|
||||
shared_ptr<U> make_shared(const T (&list)[N]);
|
||||
template<typename U> // U is T[N]
|
||||
shared_ptr<U> make_shared(const T& value);
|
||||
|
||||
template<typename U, typename A, typename... Args> // U = T[N]
|
||||
shared_ptr<U> allocate_shared(const A& allocator, const T (&list)[N]);</pre>
|
||||
<blockquote>
|
||||
<p><b>Description:</b> These overloads of the utilities above are for a
|
||||
fixed size array.</p>
|
||||
</blockquote>
|
||||
<pre>template<typename U, typename... Args> // U = T[][N]
|
||||
shared_ptr<U> make_shared(size_t size, const T (&list)[N]);
|
||||
|
||||
template<typename U, typename A, typename... Args> // U = T[][N]
|
||||
shared_ptr<U> allocate_shared(const A& allocator, size_t size, const T (&list)[N]);</pre>
|
||||
<blockquote>
|
||||
<p><b>Description:</b> These overloads initialize inner array elements
|
||||
from the initializer list.</p>
|
||||
</blockquote>
|
||||
<pre>template<typename U, typename... Args> // U = T[M][N]
|
||||
shared_ptr<U> make_shared(const T (&list)[N]);
|
||||
|
||||
template<typename U, typename A, typename... Args> // U = T[M][N]
|
||||
shared_ptr<U> allocate_shared(const A& allocator, const T (&list)[N]);</pre>
|
||||
<blockquote>
|
||||
<p><b>Description:</b> These overloads of the utilities above are for a
|
||||
fixed size array.</p>
|
||||
</blockquote>
|
||||
<pre>template<typename U> // U = T[]
|
||||
shared_ptr<U> make_shared(size_t size, T&& value);
|
||||
|
||||
template<typename U, typename A> // U = T[]
|
||||
shared_ptr<U> allocate_shared(const A& allocator, size_t size, T&& value);</pre>
|
||||
template<typename U, typename A> // U is T[N]
|
||||
shared_ptr<U> allocate_shared(const A& allocator, const T& value);</pre>
|
||||
<blockquote>
|
||||
<p><b>Description:</b> These overloads initialize array elements with
|
||||
the given value.</p>
|
||||
</blockquote>
|
||||
<pre>template<typename U> // U = T[N]
|
||||
shared_ptr<U> make_shared(T&& value);
|
||||
|
||||
template<typename U, typename A> // U = T[N]
|
||||
shared_ptr<U> allocate_shared(const A& allocator, T&& value);</pre>
|
||||
<blockquote>
|
||||
<p><b>Description:</b> These overloads of the utilities above are for a
|
||||
fixed size array.</p>
|
||||
</blockquote>
|
||||
<pre>template<typename U> // U = T[]
|
||||
<pre>template<typename U> // U is T[]
|
||||
shared_ptr<U> make_shared_noinit(size_t size);
|
||||
|
||||
template<typename U, typename A> // U = T[]
|
||||
shared_ptr<U> allocate_shared_noinit(const A& allocator, size_t size);</pre>
|
||||
template<typename U, typename A> // U is T[]
|
||||
shared_ptr<U> allocate_shared_noinit(const A& allocator, size_t size);
|
||||
|
||||
template<typename U> // U is T[N]
|
||||
shared_ptr<U> make_shared_noinit();
|
||||
|
||||
template<typename U, typename A> // U is T[N]
|
||||
shared_ptr<U> allocate_shared_noinit(const A& allocator);</pre>
|
||||
<blockquote>
|
||||
<p><b>Description:</b> These overloads do not perform any value
|
||||
initialization of elements.</p>
|
||||
</blockquote>
|
||||
<pre>template<typename U> // U = T[N]
|
||||
shared_ptr<U> make_shared_noinit();
|
||||
|
||||
template<typename U, typename A> // U = T[N]
|
||||
shared_ptr<U> allocate_shared_noinit(const A& allocator);</pre>
|
||||
<blockquote>
|
||||
<p><b>Description:</b> These overloads of the utilities above are for a
|
||||
fixed size array.</p>
|
||||
</blockquote>
|
||||
<h2><a name="example">Example</a></h2>
|
||||
<p>An example of each overload of make_shared for arrays:</p>
|
||||
</blockquote>
|
||||
<h2><a name="example">Examples</a></h2>
|
||||
<p>Some examples of each overload of make_shared for arrays:</p>
|
||||
<blockquote>
|
||||
<pre>boost::shared_ptr<int[]> a1 = boost::make_shared<int[]>(size);
|
||||
boost::shared_ptr<point[]> a2 = boost::make_shared<point[]>(size, x, y);
|
||||
boost::shared_ptr<point[5]> a3 = boost::make_shared<point[5]>(x, y);
|
||||
boost::shared_ptr<int[]> a4 = boost::make_shared<int[]>({1, 2, 3});
|
||||
boost::shared_ptr<int[3]> a5 = boost::make_shared<int[3]>({1, 2, 3});
|
||||
boost::shared_ptr<int[][3]> a6 = boost::make_shared<int[][3]>(size, {1, 2, 3});
|
||||
boost::shared_ptr<int[5][3]> a7 = boost::make_shared<int[5][3]>({1, 2, 3});
|
||||
boost::shared_ptr<point[]> a8 = boost::make_shared<point[]>(size, {x, y});
|
||||
boost::shared_ptr<point[5]> a9 = boost::make_shared<point[5]>({x, y});
|
||||
boost::shared_ptr<int[]> a10 = boost::make_shared_noinit<int[]>(size);
|
||||
boost::shared_ptr<int[5]> a11 = boost::make_shared_noinit<int[5]>();</pre>
|
||||
boost::shared_ptr<int[8]> a2 = boost::make_shared<int[8]>();
|
||||
boost::shared_ptr<int[][2]> a3 = boost::make_shared<int[][2]>(size);
|
||||
boost::shared_ptr<int[4][2]> a4 = boost::make_shared<int[4][2]>();
|
||||
boost::shared_ptr<int[]> a5 = boost::make_shared<int[]>(size, 1);
|
||||
boost::shared_ptr<int[8]> a6 = boost::make_shared<int[8]>(1);
|
||||
boost::shared_ptr<int[][2]> a7 = boost::make_shared<int[][2]>(size, {1, 2});
|
||||
boost::shared_ptr<int[4][2]> a8 = boost::make_shared<int[4][2]>({1, 2});
|
||||
boost::shared_ptr<int[]> a9 = boost::make_shared_noinit<int[]>(size);
|
||||
boost::shared_ptr<int[8]> a10 = boost::make_shared_noinit<int[8]>();
|
||||
boost::shared_ptr<int[][2]> a11 = boost::make_shared_noinit<int[][2]>(size);
|
||||
boost::shared_ptr<int[4][2]> a12 = boost::make_shared_noinit<int[4][2]>();</pre>
|
||||
</blockquote>
|
||||
<h2><a name="history">History</a></h2>
|
||||
<p>November 2012. Glen Fernandes contributed implementations of
|
||||
make_shared and allocate_shared for arrays.</p>
|
||||
<hr>
|
||||
<p>$Date: 2012-10-30 10:12:25 -0800 (Tue, 30 Oct 2012) $</p>
|
||||
<p><small>Copyright 2012 Glen Fernandes. Distributed under the Boost
|
||||
Software License, Version 1.0. See accompanying file
|
||||
<A href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</A> or copy at
|
||||
<A href="http://www.boost.org/LICENSE_1_0.txt">
|
||||
http://www.boost.org/LICENSE_1_0.txt</A>.</small></p>
|
||||
<p>$Date: 2014-01-20 11:10:00 -0800 (Mon, 20 Jan 2014) $</p>
|
||||
<p><small>Copyright 2012-2014 Glen Fernandes. Distributed under the
|
||||
Boost Software License, Version 1.0. See accompanying file
|
||||
<a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or copy at
|
||||
<a href="http://www.boost.org/LICENSE_1_0.txt">
|
||||
http://www.boost.org/LICENSE_1_0.txt</a>.</small></p>
|
||||
</body>
|
||||
</html>
|
||||
|
||||
Reference in New Issue
Block a user