Propietario de C ++ STD menos

En este artículo, discutiremos un objeto de función en el lenguaje C ++, el std :: propietario_less. Su forma completa se basa en el propietario menos que la operación. Para explicar esto en detalle, debe comprender primero qué objetos de función son. Los objetos de función también se conocen como functores en c++. Los functores son como bloques de construcción para componer programas más grandes. Lo principal que hacemos en los functores es que estamos construyendo objetos con funciones. Entonces, lo que hacemos en este caso es emplear un objeto como una función.

Un functor es una función con un estado y la clave para mantener este estado es el operador (). Un functor es una función que se logra sobrecargando el operador de palabras clave () en algunas clases. Entonces, los functores son objetos que actúan como funciones. La misma función de sintaxis antigua se usa para invocar functores. Se construye un functor creando un objeto que sobrecarga al operador. Ahora, discutamos el functor de propietario_less. Este functor o objeto de función, en lugar del orden de tipo basado en el valor, nos proporciona un pedido de tipo mixto basado en el propietario de ambos std :: weak_ptr y std :: shared_ptr.

Se ha ordenado de tal manera que estos dos consejos inteligentes coincidan de manera equivalente solo cuando ambos comparten la propiedad. O si ambos están vacíos incluso cuando los valores que obtuvimos de los métodos de getter de punteros sin procesar no son los mismos. Estos realizan comparaciones basadas en propietarios entre consejos débiles y consejos compartidos. "Propietario_less" se utiliza para ordenar la dirección del bloque de control. Entonces, considera dos punteros débiles o consejos compartidos equivalentes si comparten la misma propiedad.

Sintaxis:

La sintaxis para el propietario menos operador es:

plantilla struct propietario_less;
sin dueño>

La biblioteca estándar de C ++ nos da una especialización de std :: propietario_less cuando "t" no se inicializa. En el caso de eso, los parámetros se deducen de la lista de parámetros.

Tenga en cuenta que esta es una plantilla para propietario_less. No tiene una sintaxis específica, ya que es un enfoque para resolver un problema utilizando consejos y functores inteligentes.

Los miembros del propietario_less

operador bool () (const std :: shared_ptr& lhs,
const std :: shared_ptr& rhs) const noexcept

Ejemplo # 01:

Para hacerlo, no hemos escrito ningún código complejo que use ninguna estructura, clase, función o cualquier objeto de programación como este. En cambio, intentamos escribir un código que pueda ser lo más simple posible directamente en nuestro método principal. Inicializamos un puntero de un entero de tipo de datos con una longitud de 10.

Después de eso, declaramos un puntero compartido "X" con una longitud de 20. Hemos declarado otro puntero compartido con la longitud como el puntero compartido "X". En la siguiente línea, hemos establecido el puntero en valor basado en el valor. En la línea número 12, hemos establecido nuestros consejos en consejos sin propietario. Ahora, realizaremos inserciones basadas en el valor para nuestros Pointers X e Y.

Después de eso, haremos lo mismo pero el propietario basado en nuestros consejos X e Y usando nuestro functor std :: propietario_less. Tenga en cuenta que hemos escrito el mismo código para punteros basados ​​en valor y propietario. La única diferencia es que estamos usando la palabra clave std :: propietario_less para punteros basados ​​en el propietario.

Ahora, para mostrarle la diferencia de valor y la diferencia de tamaño entre los dos enfoques, hemos impreso el tamaño de los punteros basados ​​en valores y propietarios. Después de eso, en la línea número 20, eliminamos el puntero que creamos inicialmente al comienzo de nuestra función principal. En la última línea, hemos devuelto 0 porque el tipo de retorno de nuestro método principal es un entero. Entonces, hemos regresado 0. Ahora, ejecutaremos nuestro código y verificaremos nuestro resultado.

#incluir
#incluir
#incluir
int main ()

int * pointer = new int (10);
std :: shared_ptr x (nuevo int (20));
std :: shared_ptr y (x, puntero);
std :: set < std::shared_ptr > value_based;
std :: set < std::shared_ptr, std :: propietario_less>> propietario_based;
Valor_Based.insertar (x);
Valor_Based.insertar (y);
propietario.insertar (x);
propietario.insertar (y);
std :: cout << "value_based.size() is " << value_based.size() << '\n';
std :: cout << "owner_based.size() is " << owner_based.size() << '\n';
Eliminar puntero;
regresar 0;

La salida que obtenemos del código realizado anteriormente es el siguiente. Si echamos un vistazo a la salida, podemos ver que el tamaño del puntero basado en el valor es 2 y el tamaño del puntero basado en el propietario es 1. La pregunta surge aquí es que si realizamos los mismos pasos para ambos, ¿cómo es que sus tamaños son diferentes?? La respuesta es que, como discutimos anteriormente en nuestra introducción, este functor proporciona el pedido de tipo basado en el propietario y los dos punteros se comparan de manera equivalente si comparten la misma propiedad. Pero si los valores son diferentes para ambos consejos, ¿por qué comparten la misma propiedad??

Entonces, esta es la principal ventaja del objeto de función sin propietario, incluso si los valores son diferentes y no iguales aún, comparten la misma propiedad. Es por eso que el tamaño del valor basado es dos porque tiene dos punteros y ambos tienen una propiedad diferente. Pero en el propietario, estamos utilizando funciones sin propietario que se deben al intercambio de la misma propiedad, el tamaño es uno. En nuestro caso, dado que los dos punteros compartidos comparten la misma propiedad, por eso se consideran equivalentes y el tamaño de la base de propietarios se convierte en 1.

Conclusión

En esta guía, discutimos un tipo de objeto de función en C ++ que es std :: propietario_less. Explicamos sobre los objetos de la función, cómo se usan estos objetos y cómo se declaran y llaman a estos. Después de eso, discutimos los objetos de función std :: propietario_less y explicamos sus aplicaciones y definición en términos de programación. Más tarde, explicamos su sintaxis y echamos un vistazo a sus miembros. También realizamos un ejemplo práctico con respecto al tema para hacerle comprender el concepto con mucho más detalle. Para concluir este tema, podemos decir que std :: propietario_less define functores o objetos de función que realizan comparaciones basadas en propietarios entre punteros débiles y punteros compartidos.