std::experimental::shared_ptr<T>:: shared_ptr
|
constexpr
shared_ptr
(
)
noexcept
;
|
(1) | |
|
constexpr
shared_ptr
(
std::
nullptr_t
)
noexcept
;
|
(2) | |
|
template
<
class
Y
>
explicit shared_ptr ( Y * ptr ) ; |
(3) | |
|
template
<
class
Y,
class
Deleter
>
shared_ptr ( Y * ptr, Deleter d ) ; |
(4) | |
|
template
<
class
Deleter
>
shared_ptr ( std:: nullptr_t ptr, Deleter d ) ; |
(5) | |
|
template
<
class
Y,
class
Deleter,
class
Alloc
>
shared_ptr ( Y * ptr, Deleter d, Alloc alloc ) ; |
(6) | |
|
template
<
class
Deleter,
class
Alloc
>
shared_ptr ( std:: nullptr_t ptr, Deleter d, Alloc alloc ) ; |
(7) | |
|
template
<
class
Y
>
shared_ptr ( const shared_ptr < Y > & r, element_type * ptr ) noexcept ; |
(8) | |
|
shared_ptr
(
const
shared_ptr
&
r
)
noexcept
;
|
(9) | |
|
template
<
class
Y
>
shared_ptr ( const shared_ptr < Y > & r ) noexcept ; |
(9) | |
|
shared_ptr
(
shared_ptr
&&
r
)
noexcept
;
|
(10) | |
|
template
<
class
Y
>
shared_ptr ( shared_ptr < Y > && r ) noexcept ; |
(10) | |
|
template
<
class
Y
>
explicit shared_ptr ( const std:: weak_ptr < Y > & r ) ; |
(11) | |
|
template
<
class
Y
>
shared_ptr ( std:: auto_ptr < Y > && r ) ; |
(12) | |
|
template
<
class
Y,
class
Deleter
>
shared_ptr ( std:: unique_ptr < Y,Deleter > && r ) ; |
(13) | |
Construye un nuevo
shared_ptr
a partir de varios tipos de punteros que referencian un objeto a gestionar.
Para los propósitos de la descripción a continuación, se dice que un tipo de puntero
Y*
es compatible con un tipo de puntero
T*
si
Y*
es convertible a
T*
o
Y
es el tipo de arreglo
U[N]
y
T
es
U cv []
(donde cv es algún conjunto de calificadores cv).
shared_ptr
sin objeto gestionado, es decir, un
shared_ptr
vacío.
shared_ptr
con
ptr
como el puntero al objeto gestionado. Si
T
es un tipo de arreglo
U[N]
,
Y(*)[N]
debe ser convertible a
T*
. Si
T
es un tipo de arreglo
U[]
,
Y(*)[]
debe ser convertible a
T*
. De lo contrario,
Y*
debe ser convertible a
T*
. Adicionalmente:
T
no es un tipo array;
delete
[
]
ptr
si
T
es un tipo array) como el deleter.
Y
debe ser un tipo completo. Esa expresión delete debe estar bien formada, tener un comportamiento bien definido y no lanzar ninguna excepción.
Deleter
debe ser
CopyConstructible
, y su constructor de copia y destructor no deben lanzar excepciones.
Alloc
debe ser un
Allocator
, y su constructor de copia y destructor no deben lanzar excepciones.
shared_ptr
que comparte información de propiedad con
r
, pero contiene un puntero no relacionado y no gestionado
ptr
. Incluso si este
shared_ptr
es el último del grupo en salir del ámbito, llamará al destructor para el objeto originalmente gestionado por
r
. Sin embargo, llamar a
get()
en este siempre devolverá una copia de
ptr
. Es responsabilidad del programador asegurar que este
ptr
permanezca válido mientras este shared_ptr exista, como en los casos de uso típicos donde
ptr
es un miembro del objeto gestionado por
r
o es un alias (por ejemplo, downcast) de
r.
get
(
)
.
shared_ptr
que comparte la propiedad del objeto gestionado por
r
. Si
r
no gestiona ningún objeto,
*
this
tampoco gestiona ningún objeto. La plantilla de sobrecarga no participa en la resolución de sobrecarga si
Y*
no es
compatible con
T*
.
shared_ptr
desde
r
. Después de la construcción,
*
this
contiene una copia del estado previo de
r
,
r
está vacío. La sobrecarga de plantilla no participa en la resolución de sobrecarga si
Y*
no es
compatible con
T*
.
shared_ptr
que comparte la propiedad del objeto gestionado por
r
.
Y*
debe ser
compatible con
T*
. Nótese que
r.
lock
(
)
puede usarse para el mismo propósito: la diferencia es que este constructor lanza una excepción si el argumento está vacío, mientras que
weak_ptr
<
T
>
::
lock
(
)
construye un
shared_ptr
vacío en ese caso.
shared_ptr
que almacena y posee el objeto anteriormente propiedad de
r
.
Y*
debe ser convertible a
T*
. Después de la construcción,
r
está vacío.
shared_ptr
que gestiona el objeto actualmente gestionado por
r
. El deleter asociado con
r
se almacena para la futura eliminación del objeto gestionado.
r
no gestiona ningún objeto después de la llamada. Esta sobrecarga no participa en la resolución de sobrecarga si
Y*
no es
compatible con
T*
.
Si
D
es un tipo de referencia, equivalente a
shared_ptr
(
r.
release
(
)
,
std::
ref
(
r.
get_deleter
(
)
)
. De lo contrario, equivalente a
shared_ptr
(
r.
release
(
)
, r.
get_deleter
(
)
)
.
Contenidos |
Notas
Al construir un
shared_ptr
a partir de un puntero en bruto a un objeto de un tipo derivado de
std::experimental::enable_shared_from_this
, los constructores de
shared_ptr
actualizan el miembro privado
weak_ptr
de la base
std::experimental::enable_shared_from_this
para que las futuras llamadas a
shared_from_this()
compartan la propiedad con el
shared_ptr
creado por este constructor de puntero en bruto.
Las sobrecargas de puntero crudo asumen la propiedad del objeto apuntado, por lo que construir un
shared_ptr
usando las sobrecargas de puntero crudo para un objeto que ya está gestionado por un
shared_ptr
puede llevar a comportamiento indefinido, incluso si el objeto es de un tipo derivado de
std::experimental::enable_shared_from_this
.
Parámetros
| ptr | - | un puntero a un objeto a gestionar |
| d | - | un deleter para usar al destruir el objeto |
| alloc | - | un allocator para usar en asignaciones de datos para uso interno |
| r | - | otro puntero inteligente con el que compartir la propiedad o del que adquirir la propiedad |
Excepciones
T
no es un tipo array,
delete
[
]
ptr
en caso contrario) se llama si ocurre una excepción.
Ejemplo
|
Esta sección está incompleta
Razón: sin ejemplo |
Véase también
|
crea un shared pointer que gestiona un nuevo objeto
(function template) |
|
|
crea un shared pointer que gestiona un nuevo objeto asignado usando un allocator
(function template) |