std::compartido_ptr es uno de los punteros inteligentes introducidos en C++11. A diferencia de un puntero simple, tiene un bloque de control asociado que realiza un seguimiento del recuento de referencias del objeto gestionado. Este recuento de referencias se comparte entre todas las copias de las instancias compartidas_ptr que apuntan al mismo objeto, lo que garantiza una gestión y eliminación adecuadas de la memoria.
Requisitos previos: Punteros en C++ , Punteros inteligentes en C++ .
Puntero compartido en C++
Sintaxis de std::shared_ptr
El share_ptr de tipo T se puede declarar como:
std::shared_ptr ptr_name;>
Inicialización de objetos Shared_ptr
Podemos inicializar el share_ptr usando los siguientes métodos:
1. Inicialización usando un nuevo puntero
shared_ptr ptr (new T()); shared_ptr ptr = make_shared (new T());>
2. Inicialización utilizando un puntero existente
shared_ptr ptr(already_existing_pointer); shared_ptr ptr = make_shared(already_existing_pointer);>
Métodos de miembros de share_ptr
A continuación se muestran algunos miembros asociados conshared_ptr:
| Método | Descripción |
|---|---|
| reiniciar() | Restablece std::shared_ptr a vacío, liberando la propiedad del objeto administrado. |
| usar_count() | Devuelve el recuento de referencias actual, indicando cuántas instancias std::shared_ptr comparten la propiedad. |
| único() | Compruebe si solo hay un std::shared_ptr propietario del objeto (el recuento de referencias es 1). |
| conseguir() | Devuelve un puntero sin formato al objeto administrado. Tenga cuidado al utilizar este método. |
| intercambiar(shr_ptr2) | intercambia el contenido (propiedad) de dos instancias std::shared_ptr. |
Ejemplos de std::shared_ptr
Ejemplo 1:
C++
>
>Producción
0x1365c20 A::show() A::show() 0x1365c20 0x1365c20 2 2 0 1 0x1365c20>
Ejemplo 2:
C++
// C++ program to illustrate the use of make_shared> #include> #include> using> namespace> std;> int> main()> {> >// Creating shared pointers using std::make_shared> >shared_ptr<>int>>shr_ptr1 = hacer_compartido<>int>>(42);> >shared_ptr<>int>>shr_ptr2 = hacer_compartido<>int>>(24);> >// Accessing the values using the dereference operator> >// (*)> >cout << 'Value 1: ' << *shr_ptr1 << endl;> >cout << 'Value 2: ' << *shr_ptr2 << endl;> >// Using the assignment operator (=) to share ownership> >shared_ptr<>int>>shr_ptr3 = shr_ptr1;> >// Checking if shared pointer 1 and shared pointer 3> >// point to the same object> >if> (shr_ptr1 == shr_ptr3) {> >cout << 'shared pointer 1 and shared pointer 3 '> >'point to the same object.'> ><< endl;> >}> >// Swapping the contents of shared pointer 2 and shared> >// pointer 3> >shr_ptr2.swap(shr_ptr3);> >// Checking the values after the swap> >cout << 'Value 2 (after swap): ' << *shr_ptr2 << endl;> >cout << 'Value 3 (after swap): ' << *shr_ptr3 << endl;> >// Using logical operators to check if shared pointers> >// are valid> >if> (shr_ptr1 && shr_ptr2) {> >cout << 'Both shared pointer 1 and shared pointer '> >'2 are valid.'> ><< endl;> >}> >// Resetting a shared pointer> >shr_ptr1.reset();> }> |
>
>Producción
Value 1: 42 Value 2: 24 shared pointer 1 and shared pointer 3 point to the same object. Value 2 (after swap): 42 Value 3 (after swap): 24 Both shared pointer 1 and shared pointer 2 are valid.>
Ejemplo 3: Implementación de una lista enlazada usando std::shared_ptr
C++
#include> #include> using> namespace> std;> // Define a singly linked list node> struct> Node {> >int> data;> >shared_ptr next;> >Node(>int> val)> >: data(val)> >, next(NULL)> >{> >}> };> class> LinkedList {> public>:> >LinkedList()> >: head(NULL)> >{> >}> >// Insert a new node at the end of the linked list> >void> insert(>int> val)> >{> >shared_ptr newNode = make_shared(val);> >if> (!head) {> >head = newNode;> >}> >else> {> >shared_ptr current = head;> >while> (current->siguiente) {> >current = current->siguiente;> >}> >current->siguiente = nuevoNodo;> >}> >}> >// Delete a node with a given value from the linked list> >void> del(>int> val)> >{> >if> (!head) {> >return>;> >}> >if> (head->datos == valor) {> >head = head->siguiente;> >return>;> >}> >shared_ptr current = head;> >while> (current->siguiente> >&& current->siguiente->datos!= val) {> >current = current->siguiente;> >}> >if> (current->siguiente && actual->siguiente->datos == val) {> >current->siguiente = actual->siguiente->siguiente;> >}> >}> >// Traverse and print the linked list> >void> Print()> >{> >shared_ptr current = head;> >while> (current) {> >cout current = current->próximo; } escucha<< 'NULL' << endl; } private: shared_ptr head; }; int main() { LinkedList linkedList; // Insert nodes into the linked list linkedList.insert(1); linkedList.insert(2); linkedList.insert(3); // Print the linked list cout << 'Linked List: '; linkedList.Print(); // Delete a node and print the updated linked list linkedList.del(2); cout << 'Linked List after deleting 2: '; linkedList.Print(); return 0; }> |
>
algoritmo para rsa
>Producción
Linked List: 1 ->2 -> 3 -> NULL Lista enlazada después de eliminar 2: 1 -> 3 -> NULL>