C ++ std unique_ptr
Siempre que se cree el puntero inteligente, llamará automáticamente a nuevo y asignará el montón de memoria. Luego, en base a qué puntero inteligente usa, esa memoria se volverá automáticamente gratuita. Ahora vamos a nuestro tema principal, el puntero único. Se eliminará un puntero único cuando salga del alcance. Los punteros únicos no se pueden copiar en el otro puntero, ya sea del mismo tipo de datos porque un puntero único apunta a una memoria. Si se ha copiado el puntero único, eso significa que a la vez dos punteros apuntan al mismo montón de memoria. Entonces, por eso no podemos copiar consejos únicos. Consejos únicos Asegúrese de que eliminen sus objetos con ellos.
Sintaxis
La sintaxis para crear un puntero único es el siguiente:
std :: unique_ptrAquí, el objeto creado dinámicamente también se destruye cuando el puntero único se destruye.
Ejemplo # 01:
Para comprender los consejos únicos con más profundidad, daremos un ejemplo. En este ejemplo, hemos definido una estructura llamada persona. "Person" tiene un constructor que toma una cadena como parámetro e imprime el valor. También tiene un destructor que al destruir se imprimirá "eliminado" para que podamos entender que la persona está destruida. Dentro del método principal, hemos declarado un puntero único y lo hemos pasado un valor "Jack.".
Ahora, este puntero tomará "Jack" y lo pasará a la memoria a la que señala que es la estructura "persona". El valor "Jack" irá al constructor y se imprimirá. Después de eso, el puntero único eliminará automáticamente el objeto y "eliminó!"Se imprimirá en la pantalla. Ahora, ejecutemos y ejecutemos nuestro código para ver la salida.
#incluir#incluir
usando el espacio de nombres STD;
estructura
Persona (cadena n): nombre (n)
cout<
~ Persona ()
cout<< "Deleted!";
nombre de cadena;
;
En t
principal ()
auto p = make_unique ("jack");
regresar 0;
Nuestro código se ha ejecutado con éxito y nos da el resultado esperado. El puntero único ha tomado el valor "Jack" y lo ha pasado al constructor porque estaba apuntando hacia el objeto de la estructura "persona". El constructor ha impreso el valor. Después de eso, se imprime "eliminado". Ahora, aquí, solo hemos impreso el valor. Pero en escenarios en tiempo real, podemos realizar todas las operaciones y después de realizar la operación, el objeto de estructura o clase se destruirá en sí misma.
Ejemplo # 02:
En este ejemplo, hemos tratado de explicar el constructor único en detalles. También hemos tratado de crear un puntero único de manera diferente para que pueda comprender las diferentes sintaxis y enfoques para crear punteros únicos. Para realizar este ejemplo, hemos creado una clase llamada "Uniqueptr". En esta clase, tenemos un constructor de esta clase y un destructor. En el ejemplo anterior, explicamos que podemos hacer cualquier operación que deseemos en el constructor. En este ejemplo, hemos tratado de hacerlo para darle una experiencia práctica.
Entonces, primero en el constructor, hemos impreso "en constructor" para hacerle saber al usuario que estamos en nuestro constructor en este momento. Después de eso, hemos declarado dos enteros "X" y "Y" que contienen los valores de "2" y "3" respectivamente. Después de eso, declaramos otra variable que también es un entero: "Z". Hemos resumido o agregado los valores de "x" y "y" y almacenamos la salida en el entero "z". En la línea número 13, hemos impreso "Operación realizada" y también hemos imprimido el valor de "Z" en su contra para que podamos informar al usuario que la operación se realiza y el valor después de la operación es el siguiente.
En nuestro destructor, simplemente hemos impreso "en destructor". En el método principal, simplemente hemos creado el puntero único y lo ha pasado el nombre de la clase para que pueda entender qué memoria tiene que apuntar hacia. Ahora, ejecutaremos nuestro código para verificar la salida.
#incluir#incluir
usando el espacio de nombres STD;
clase uniqueptr
público:
Uniqueptr ()
cout<<”In constructor”<
int y = 3;
int z = x + y;
cout<<”Operation Performed = “<
~ Uniqueptr ()
cout<<”In Destructor”<
;
int main ()
std :: unique_ptr x = std :: unique_ptr (nuevo uniqueptr);
regresar 0;
Después de ejecutar nuestro código, el siguiente es la salida que obtendremos del sistema. Una cosa que debe explicar aquí es que, en nuestro método principal, no creamos ningún objeto de la clase para acceder a él. En cambio, solo creamos un puntero único y lo señalamos hacia nuestra clase. El sistema ha impreso "en constructor", lo que significa que ha ido en el constructor y la otra línea impresa también explica que el sistema ha realizado la operación de adición en los enteros e imprimido el valor contra el mensaje impreso. Por último, el compilador se movió dentro del destructor, imprimió el mensaje y destruyó el objeto de la clase. Una cosa a tener en cuenta aquí es que no creamos ni eliminamos el montón de memoria aquí. Todo esto fue hecho por nuestro puntero único.
Conclusión
En esta guía, discutimos un tipo de puntero inteligente que es un puntero único. Los consejos únicos son consejos inteligentes que nos ayudan con la asignación de memoria y la gestión de la memoria. Entonces, para comprender los consejos únicos, primero explicamos los consejos inteligentes y los consejos únicos. Después de eso, explicamos la sintaxis de punteros únicos. Se realizaron múltiples ejemplos en diferentes escenarios para que el lector entienda prácticamente los consejos únicos.