C ++ dono de DST menos

Neste artigo, discutiremos um objeto de função na linguagem C ++, o std :: dono_less. Sua forma completa é baseada em proprietário menor que a operação. Para explicar isso em detalhes, você precisa entender primeiro quais objetos de função são. Os objetos de função também são conhecidos como funções em C++. FUNCTORES são como blocos de construção para compor programas maiores. A principal coisa que fazemos nos funções é que estamos construindo objetos a partir de funções. Então, o que fazemos neste caso é empregar um objeto como uma função.

Um functor é uma função com um estado e a chave para manter este estado é o operador (). Um functor é uma função que é alcançada sobrecarregando o operador de palavras -chave () em algumas classes. Então, os funções são objetos que agem como funções. A mesma função antiga de sintaxe é usada para invocar functores. Um functor é construído criando um objeto que sobrecarrega o operador. Agora, vamos discutir dono_less Functor. Este functor ou objeto de função, em vez de pedidos de tipo baseado em valor, nos fornece pedidos de tipo misto baseados no proprietário de ambos STD :: frAct_ptr e std :: shared_ptr.

Foi ordenado de tal maneira que esses dois ponteiros inteligentes correspondam equivalentemente apenas quando os dois compartilham a propriedade. Ou se os dois estiverem vazios, mesmo quando os valores obtemos dos métodos getter de ponteiros crus não são os mesmos. Eles executam comparações baseadas em proprietários entre ponteiros fracos e ponteiros compartilhados. "Propriedade_less" é usado para solicitar o endereço do bloco de controle. Portanto, considera dois indicadores fracos ou indicadores compartilhados equivalentes se eles compartilharem a mesma propriedade.

Sintaxe:

A sintaxe para o proprietário menos operador é:

modelo struct proprietário_less;
sem dono>

A biblioteca padrão de C ++ nos dá uma especialização de std :: proprietário_less quando "t" não é inicializado. No caso disso, os parâmetros são deduzidos da lista de parâmetros.

Observe que este é um modelo para proprietário_less. Não possui uma sintaxe específica, pois é uma abordagem para resolver um problema usando ponteiros e funções inteligentes.

Os membros do proprietário_less

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

Exemplo # 01:

Para isso, não escrevemos nenhum código complexo que use qualquer estrutura, classe, função ou qualquer objeto de programação como estes. Em vez disso, tentamos escrever um código que possa ser o mais simples possível diretamente em nosso método principal. Inicializamos um ponteiro de um número inteiro de dados com um comprimento de 10.

Depois disso, declaramos um ponteiro compartilhado "x" com um comprimento de 20. Declaramos outro ponteiro compartilhado com o comprimento como o ponteiro compartilhado "x". Na próxima linha, definimos o ponteiro para baseado em valor. Na linha número 12, colocamos nossos ponteiros para indicadores sem proprietários. Agora, realizaremos inserções baseadas em valor para nossos ponteiros x e y.

Depois disso, faremos o mesmo, mas o proprietário baseado em nossos ponteiros x e y usando nosso functor std :: proprietário_less. Observe que escrevemos o mesmo código para ponteiros baseados em valor e com base no proprietário. A única diferença é que estamos usando a palavra -chave STD :: PROUTS_LESS para ponteiros baseados no proprietário.

Agora, para mostrar a diferença de valor e a diferença de tamanho entre as duas abordagens, imprimimos o tamanho dos valores baseados e ponteiros baseados em proprietários. Depois disso, na linha número 20, excluímos o ponteiro que criamos inicialmente no início de nossa função principal. Na última linha, retornamos 0 porque o tipo de retorno do nosso método principal é um número inteiro. Então, voltamos 0. Agora, vamos executar nosso código e verificar nosso resultado.

#incluir
#incluir
#incluir
int main ()

int * ponteiro = new int (10);
std :: shared_ptr x (novo int (20));
std :: shared_ptr y (x, ponteiro);
std :: set < std::shared_ptr > value_based;
std :: set < std::shared_ptr, std :: proprietário_less>> proprietário_based;
value_based.inserir (x);
value_based.inserir (y);
proprietário_based.inserir (x);
proprietário_based.inserir (y);
std :: cout << "value_based.size() is " << value_based.size() << '\n';
std :: cout << "owner_based.size() is " << owner_based.size() << '\n';
excluir ponteiro;
retornar 0;

A saída que obtemos do código realizado acima é o seguinte. Se dermos uma olhada na saída, podemos ver que o tamanho do ponteiro baseado em valor é 2 e o tamanho do ponteiro baseado no proprietário é 1. A questão surge aqui é que, se executamos as mesmas etapas para os dois, como é que seus tamanhos são diferentes? A resposta é que, como discutimos anteriormente em nossa introdução, este functor fornece pedidos de tipo baseado no proprietário e os dois ponteiros se comparam equivalentemente se eles compartilharem a mesma propriedade. Mas se os valores são diferentes para ambos os ponteiros, então por que eles compartilham a mesma propriedade?

Portanto, essa é a principal vantagem do objeto de função sem proprietário, mesmo que os valores sejam diferentes e ainda não sejam iguais, eles compartilham a mesma propriedade. É por isso que o tamanho da base de valor é dois porque está tendo dois ponteiros e os dois têm propriedade diferente. Mas, no proprietário, estamos usando funções sem proprietários, devido ao compartilhamento da mesma propriedade, o tamanho é um. No nosso caso, como os dois ponteiros compartilhados compartilham a mesma propriedade, é por isso que eles são considerados equivalentes e o tamanho da base do proprietário se torna 1.

Conclusão

Neste guia, discutimos um tipo de objeto de função em C ++ que é std :: proprietário_less. Explicamos sobre objetos de função, como esses objetos são usados ​​e como estes são declarados e chamados. Depois disso, discutimos os objetos de função STD ::less_less e explicamos seus aplicativos e definição em termos de programação. Mais tarde, explicamos a sintaxe deles e demos uma olhada em seus membros. Também realizamos um exemplo prático sobre o tópico para fazer você entender o conceito com muito mais detalhes. Para concluir este tópico, podemos dizer que o std :: dono_less define functores ou objetos de função que executam comparações baseadas no proprietário entre ponteiros fracos e ponteiros compartilhados.