2012-11-06 14:17:32 +00:00
|
|
|
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
|
|
|
|
|
<html>
|
|
|
|
|
<head>
|
|
|
|
|
<title>make_shared and allocate_shared</title>
|
|
|
|
|
<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"
|
|
|
|
|
width="277" align="middle" border="0">make_shared and allocate_shared
|
|
|
|
|
for arrays</h1>
|
|
|
|
|
<p><A href="#Introduction">Introduction</A><br>
|
|
|
|
|
<A href="#Synopsis">Synopsis</A><br>
|
|
|
|
|
<A href="#functions">Free Functions</A><br>
|
|
|
|
|
<A href="#example">Example</A><br>
|
|
|
|
|
<h2><a name="Introduction">Introduction</a></h2>
|
|
|
|
|
<p>One criticism of Boost <a href="shared_array.htm">shared_array</a> is
|
|
|
|
|
the lack of utility similar to <a href="make_shared.htm">make_shared</a>
|
|
|
|
|
which ensures only a single allocation for an array. A second criticism
|
|
|
|
|
is Boost <code>shared_array</code> does not support custom allocators
|
|
|
|
|
and so also lacks an <code>allocate_shared</code> utility.</p>
|
|
|
|
|
<p>The header files <boost/smart_ptr/make_shared_array.hpp> and
|
|
|
|
|
<boost/smart_ptr/allocate_shared_array.hpp> provide new function
|
|
|
|
|
templates, <code>make_shared</code> and <code>allocate_shared</code>,
|
|
|
|
|
to address this need. <code>make_shared</code> uses the global
|
|
|
|
|
operator <code>new</code> to allocate memory, whereas
|
|
|
|
|
<code>allocate_shared</code> uses an user-supplied allocator,
|
|
|
|
|
allowing finer control.</p>
|
|
|
|
|
<h2><a name="Synopsis">Synopsis</a></h2>
|
|
|
|
|
<pre>namespace boost {
|
|
|
|
|
template<typename T>
|
2012-11-09 17:12:56 +00:00
|
|
|
shared_ptr<T[]> <a href="#functions">make_shared</a>(size_t size);
|
2012-11-06 14:17:32 +00:00
|
|
|
|
|
|
|
|
template<typename T, typename A>
|
2012-11-09 17:12:56 +00:00
|
|
|
shared_ptr<T[]> <a href="#functions">allocate_shared</a>(const A& allocator, size_t size);
|
2012-11-06 14:17:32 +00:00
|
|
|
|
|
|
|
|
#if defined(BOOST_HAS_VARIADIC_TMPL) && defined(BOOST_HAS_RVALUE_REFS)
|
|
|
|
|
template<typename T, typename... Args>
|
2012-11-09 17:12:56 +00:00
|
|
|
shared_ptr<T[]> <a href="#functions">make_shared</a>(size_t size, Args&&... args);
|
|
|
|
|
|
|
|
|
|
template<typename T, typename... Args>
|
|
|
|
|
shared_ptr<T[N]> <a href="#functions">make_shared</a>(Args&&... args);
|
2012-11-06 14:17:32 +00:00
|
|
|
|
|
|
|
|
template<typename T, typename A, typename... Args>
|
|
|
|
|
shared_ptr<T> <a href="#functions">allocate_shared</a>(const A& allocator, size_t size, Args&&... args);
|
2012-11-09 17:12:56 +00:00
|
|
|
|
|
|
|
|
template<typename T, typename A, typename... Args>
|
|
|
|
|
shared_ptr<T[N]> <a href="#functions">allocate_shared</a>(const A& allocator, Args&&... args);
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
|
|
|
|
|
template<typename T, typename... Args>
|
2012-11-10 01:33:29 +00:00
|
|
|
shared_ptr<T[]> <a href="#functions">make_shared</a>(initializer_list<T> list);
|
2012-11-09 17:30:07 +00:00
|
|
|
|
|
|
|
|
template<typename T, typename... Args>
|
2012-11-10 01:33:29 +00:00
|
|
|
shared_ptr<T[N]> <a href="#functions">make_shared</a>(initializer_list<T> list);
|
|
|
|
|
|
|
|
|
|
template<typename T, typename... Args>
|
|
|
|
|
shared_ptr<T[][N]> <a href="#functions">make_shared</a>(size_t size, initializer_list<T> list);
|
2012-11-09 17:12:56 +00:00
|
|
|
|
|
|
|
|
template<typename T, typename A, typename... Args>
|
2012-11-10 01:33:29 +00:00
|
|
|
shared_ptr<T[]> <a href="#functions">allocate_shared</a>(const A& allocator, initializer_list<T> list);
|
|
|
|
|
|
|
|
|
|
template<typename T, typename A, typename... Args>
|
|
|
|
|
shared_ptr<T[N]> <a href="#functions">allocate_shared</a>(const A& allocator, initializer_list<T> list);
|
2012-11-09 17:30:07 +00:00
|
|
|
|
|
|
|
|
template<typename T, typename A, typename... Args>
|
2012-11-10 01:33:29 +00:00
|
|
|
shared_ptr<T[][N]> <a href="#functions">allocate_shared</a>(const A& allocator, size_t size, initializer_list<T> list);
|
2012-11-06 14:17:32 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
template<typename T>
|
|
|
|
|
shared_ptr<T> <a href="#functions">make_shared_noinit</a>(size_t size);
|
2012-11-09 17:12:56 +00:00
|
|
|
|
|
|
|
|
template<typename T>
|
|
|
|
|
shared_ptr<T[N]> <a href="#functions">make_shared_noinit</a>();
|
2012-11-06 14:17:32 +00:00
|
|
|
}</pre>
|
|
|
|
|
<h2><a name="functions">Free Functions</a></h2>
|
|
|
|
|
<pre>template<typename T, typename... Args>
|
|
|
|
|
shared_ptr<T> make_shared(size_t size, Args&&... args);
|
|
|
|
|
template<typename T, typename A, typename... Args>
|
|
|
|
|
shared_ptr<T> allocate_shared(const A& allocator, size_t size, Args&&... args);</pre>
|
|
|
|
|
<blockquote>
|
|
|
|
|
<p><b>Requires:</b> The expression
|
2012-11-10 01:33:29 +00:00
|
|
|
<code>new(pointer) T(forward<Args>(args)...)</code>, where
|
2012-11-06 14:17:32 +00:00
|
|
|
<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
|
2012-11-10 01:33:29 +00:00
|
|
|
<code>new(pointer) T(forward<Args>(args)...)</code>.
|
2012-11-06 14:17:32 +00:00
|
|
|
<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>
|
|
|
|
|
<p><b>Postconditions:</b>
|
|
|
|
|
<code>get() != 0 && use_count() == 1</code>.</p>
|
|
|
|
|
<p><b>Throws:</b> <code>bad_alloc</code>, or an exception thrown from
|
|
|
|
|
<code>A::allocate</code> or the constructor of <code>T</code>.</p>
|
|
|
|
|
<p><b>Notes:</b> This implementation allocates the memory required for
|
|
|
|
|
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>
|
|
|
|
|
</blockquote>
|
|
|
|
|
<h2><a name="example">Example</a></h2>
|
|
|
|
|
<pre>boost::shared_ptr<int[]> array = boost::make_shared<int[]>(size);</pre>
|
|
|
|
|
<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>
|
|
|
|
|
</body>
|
|
|
|
|
</html>
|
