C ++ STD propriétaire moins

Dans cet article, nous discuterons d'un objet de fonction dans la langue C ++, le std :: propriétaire_less. Sa forme complète est basée sur le propriétaire moins que l'opération. Pour expliquer cela en détail, vous devez d'abord comprendre quels objets de fonction sont. Les objets de fonction sont également connus sous le nom de fonds en C++. Les foncteurs sont comme des éléments constitutifs pour composer des programmes plus importants. La principale chose que nous faisons dans les fonds est que nous construisons des objets hors des fonctions. Donc, ce que nous faisons dans ce cas, c'est employer un objet comme une fonction.

Un Functor est une fonction avec un état et la clé pour maintenir cet état est l'opérateur (). Un Functor est une fonction qui est obtenue en surchargeant l'opérateur de mots clés () dans certaines classes. Ainsi, les fonds sont des objets qui agissent comme des fonctions. La même vieille fonction de syntaxe est utilisée pour invoquer des fonds. Un Functor est construit en créant un objet qui surcharge l'opérateur. Maintenant, discutons du propriétaire. Cet objet Functor ou Function, au lieu d'une commande de type basée sur la valeur, nous fournit une commande de type mixte basé sur le propriétaire de STD :: faible_ptr et std :: shared_ptr.

Il a été ordonné de telle manière que ces deux pointeurs intelligents ne correspondent de manière équivalente que lorsque les deux partagent la propriété. Ou si les deux sont vides même lorsque les valeurs que nous avons obtenues à partir des méthodes Getter des pointeurs brutes ne sont pas les mêmes. Ceux-ci effectuent des comparaisons basées sur le propriétaire entre des pointeurs faibles et des pointeurs partagés. "Propriétaire_less" est utilisé pour commander l'adresse du bloc de commande. Ainsi, il considère deux pointeurs faibles ou des pointeurs partagés équivalents s'ils partagent la même propriété.

Syntaxe:

La syntaxe du propriétaire moins opérateur est:

modèle struct propriétaire_less;
sans propriétaire>

La bibliothèque standard de C ++ nous donne une spécialisation de std :: propriétaire_less lorsque «t» n'est pas initialisé. Dans le cas de cela, les paramètres sont déduits de la liste des paramètres.

Notez qu'il s'agit d'un modèle pour propriétaire_less. Il n'a pas de syntaxe spécifique car il s'agit d'une approche pour résoudre un problème à l'aide de pointeurs et de fonds.

Les membres de propriétaire_less

Bool Operator () (const std :: shared_ptr& LHS,
const std :: shared_ptr& rhs) Const noexcept

Exemple # 01:

Pour ce faire, nous n'avons écrit aucun code complexe qui utilise une structure, une classe, une fonction ou un objet de programmation comme ceux-ci. Au lieu de cela, nous avons essayé d'écrire un code qui peut être aussi simple que possible directement dans notre méthode principale. Nous avons initialisé un pointeur d'un entier de type de données avec une longueur de 10.

Après cela, nous avons déclaré un pointeur partagé «x» avec une longueur de 20. Nous avons déclaré un autre pointeur partagé avec la longueur comme le pointeur partagé «x». Dans la ligne suivante, nous avons réglé le pointeur sur une valeur basée sur la valeur. En ligne numéro 12, nous avons réglé nos pointeurs sur des pointeurs sans propriétaire. Maintenant, nous allons effectuer des insertions basées sur la valeur pour nos pointeurs x et y.

Après cela, nous ferons la même chose, mais le propriétaire basé pour nos pointeurs X et Y en utilisant notre Functor Std :: propriétaire_less. Veuillez noter que nous avons écrit le même code pour les pointeurs basés sur la valeur et les propriétaires. La seule différence est que nous utilisons le mot-clé std :: propriétaire pour les pointeurs basés sur le propriétaire.

Maintenant, pour vous montrer la différence de valeur et la différence de taille entre les deux approches, nous avons imprimé la taille des deux valeurs basées sur les valeurs et les pointeurs du propriétaire. Après cela, dans la ligne numéro 20, nous avons supprimé le pointeur que nous avons créé initialement au début de notre fonction principale. Dans la dernière ligne, nous avons retourné 0 parce que le type de retour de notre méthode principale est un entier. Donc, nous sommes revenus 0. Maintenant, nous allons exécuter notre code et vérifier notre résultat.

#inclure
#inclure
#inclure
int main ()

int * pointer = new int (10);
std :: shared_ptr x (nouveau int (20));
std :: shared_ptr y (x, pointeur);
STD :: Set < std::shared_ptr > value_based;
STD :: Set < std::shared_ptr, std :: propriétaire_less>> propriétaire_ basé;
Value_basé.insérer (x);
Value_basé.insérer (y);
propriétaire de base.insérer (x);
propriétaire de base.insérer (y);
std :: cout << "value_based.size() is " << value_based.size() << '\n';
std :: cout << "owner_based.size() is " << owner_based.size() << '\n';
supprimer le pointeur;
retour 0;

La sortie que nous obtenons du code exécuté ci-dessus est la suivante. Si nous jetons un coup d'œil à la sortie, nous pouvons voir que la taille du pointeur basé sur la valeur est de 2 et que la taille du pointeur basé sur le propriétaire est 1. La question se pose ici que si nous avons effectué les mêmes étapes pour les deux, alors comment se fait-il que leurs tailles soient différentes? La réponse est que, comme nous l'avons discuté plus tôt dans notre introduction, ce fonctor fournit une commande de type propriétaire et les deux pointeurs se comparent de manière équivalente s'il partage la même propriété. Mais si les valeurs sont différentes pour les deux pointeurs, alors pourquoi partagent-ils la même propriété?

Donc, c'est le principal avantage de l'objet de fonction sans propriétaire même si les valeurs sont différentes et pas encore égales, ils partagent la même propriété. C'est pourquoi la taille de la valeur basée est deux car elle a deux pointeurs et les deux ont une propriété différente. Mais chez le propriétaire, nous utilisons des fonds sans propriétaire qui sont dus au partage de la même propriété, la taille est une. Dans notre cas, puisque les deux pointeurs partagés partagent la même propriété, c'est pourquoi ils sont considérés comme équivalents et que la taille de la base du propriétaire devient 1.

Conclusion

Dans ce guide, nous avons discuté d'un type d'objet de fonction dans C ++ qui est std :: propriétaire_less. Nous avons expliqué les objets de fonction, comment ces objets sont utilisés et comment ceux-ci sont déclarés et appelés. Après cela, nous avons discuté d'objets de fonction std :: propriétaire sans rapport et avons expliqué leurs applications et leur définition en termes de programmation. Plus tard, nous avons expliqué leur syntaxe et jeté un coup d'œil à leurs membres. Nous avons également effectué un exemple pratique concernant le sujet pour vous faire comprendre le concept plus en détail. Pour conclure ce sujet, nous pouvons dire que Std :: propriétaire_less définit des fonds ou des objets de fonction qui effectuent des comparaisons basées sur le propriétaire entre des pointeurs faibles et des pointeurs partagés.