C ++ std fracar_ptr

O pré -requisito para estudar o ponteiro fraco é que devemos saber sobre os indicadores únicos e os indicadores compartilhados. Um ponteiro único tem propriedade única. Ele mantém os objetos gerenciados e não permite que ninguém lide com esses objetos. Vamos supor que temos um objeto chamado "P" que é gerenciado por um ponteiro único. Então, não podemos copiar este ponteiro. No outro caso, para o ponteiro compartilhado, também temos "P", mas estamos usando um ponteiro compartilhado. Desta vez, você pode copiar este ponteiro compartilhado em várias variáveis ​​diferentes e usaremos uma contagem de referência para contar quantos ponteiros inteligentes estão usando ou apontando para esse objeto gerenciado em particular.

Agora, podemos dizer que o ponteiro único é para propriedade única. O ponteiro compartilhado é para propriedade compartilhada. E o ponteiro fraco é para não proprietária. Um ponteiro fraco também é um ponteiro inteligente; não participará da propriedade. É uma referência a um objeto que é gerenciado por um ponteiro compartilhado. Agora, uma coisa que pode estar presa em nossa mente é que, se o ponteiro fraco não tiver nenhuma propriedade como um ponteiro único ou compartilhado, como esse ponteiro fraco será tratado? O ponteiro não tem nada com ele, ele leva o objeto gerenciado dos ponteiros compartilhados. Eles são usados ​​para quebrar a dependência circular dos compartilhados.

Sintaxe:

A sintaxe para aplicar um ponteiro fraco no programa é o seguinte:

std :: frAcha_ptr p (novo int);

Na sintaxe dada, o tipo é o tipo de dados que o ponteiro fraco controla.

Exemplo 1:

Para entender o ponteiro fraco de uma maneira melhor, vamos primeiro dar um exemplo para que seja mais fácil para nós entender como funciona. Neste exemplo, criamos um ponteiro fraco usando os ponteiros compartilhados e criamos a contagem do número de referências usando o ponteiro fraco. Como discutimos anteriormente, o próprio ponteiro fraco não é propriedade; É preciso a propriedade de outros ponteiros para quebrar uma dependência circular de objetos. Agora, movendo -se em direção ao nosso código em que incluímos dois arquivos de cabeçalho - o primeiro arquivo de cabeçalho é a "memória" e o segundo arquivo de cabeçalho é o "iostream". O "iostream" é usado para permitir que o codificador execute as operações de E/S enquanto a "memória" é a biblioteca usada para gerenciar a memória dinâmica.

Em seguida, nos mudamos para a função principal, onde definimos um ponteiro compartilhado do tipo inteiro e nomeamos o ponteiro "shr_ptr_a". Usando o “novo” operador, alocamos a memória no heap para int “12”. Agora, declaramos um ponteiro fraco do tipo inteiro e nomeá -lo como "wk_ptr" para o qual passamos o ponteiro compartilhado. Isso significa que mantém a referência do número inteiro "12". Depois de declará -lo com sucesso, imprimimos o número de contagens de que o ponteiro fraco é chamado usando o "use_count ()", que é usado para retornar o número de instâncias de ponteiro compartilhado que gerenciam o objeto atual. Neste exemplo, realizamos esta etapa 3 vezes criando os três objetos compartilhados. No final do código, retornamos os valores nulos.

#incluir
#incluir
int main ()

std :: shared_ptr shr_ptr_a (new int (12));
std :: frAcha_ptr WK_PTR (SHR_PTR_A);
std :: cout << "Total Number of weak pointers : "
<< wk_ptr.use_count() << std::endl;
std :: shared_ptr shr_ptr_b (shr_ptr_a);
std :: cout << "Total Number of weak pointers : "
<< wk_ptr.use_count() << std::endl;
std :: shared_ptr SHR_PTR_C (SHR_PTR_A);
std :: cout << "Total Number of weak pointers : "
<< wk_ptr.use_count() << std::endl;
retornar (0);

Agora, vamos verificar a saída do código que é exibido no snippet seguinte, no qual imprimimos o número de referências que são criadas. Após a criação de cada referência, imprimimos a contagem para isso. Para a primeira saída, foi um, para a segunda saída, foi 2 e, para a última saída, foi 3. Isso significa que o total de três referências são criadas usando o ponteiro fraco.

Exemplo 2:

Realizamos outro exemplo no qual criamos duas classes e as destruímos usando o ponteiro fraco. Sempre que acessamos qualquer objeto ou excluímos a qualquer momento por qualquer ponteiro inteligente, um ponteiro fraco é usado para rastrear que. É convertido em um ponteiro compartilhado como propriedade temporária. Se queremos destruir o ponteiro compartilhado original, a vida inteira para o objeto é estendida até destruirmos o ponteiro compartilhado temporário.

Agora, vamos prosseguir para o código onde incluímos os arquivos de cabeçalho primeiro. Antes de mergulhar na função principal, declaramos duas classes - a primeira é a “classe_a” e a segunda é a “classe_b”. Dentro da "classe_a", primeiro definimos um ponteiro fraco chamado "BPTR", passando o "Class_B" como um parâmetro. Então, chamamos um construtor e um destruidor para "Class_a". Repetimos as mesmas etapas para o "Class_B", no qual definimos um ponteiro fraco e passamos um "Class_a" como um parâmetro. O construtor exibe uma mensagem de criação da classe. Quando a função de destruição é chamada, ela exibe a mensagem da classe destruída.

Depois disso, entramos na função principal, onde declaramos os ponteiros compartilhados nomeando "a" e "b" ao qual atribuímos uma função "make_shared", onde passamos as duas classes como um parâmetro. A função "make_shared" é usada para alocar e criar qualquer tipo de objeto, passando o tipo de dados como um argumento. Ele retorna o objeto do ponteiro compartilhado, que é o proprietário do objeto e o armazena. Por fim, usando os ponteiros compartilhados "A" e "B", indexamos -os para acessar o índice de memória por trás dos locais indicados pelo "BPTR" e "Aptr". Isso significa que atribuímos os objetos de ponteiros compartilhados ao ponteiro fraco.

#incluir
#incluir
classe classe_b;
classe classe_a

público:
std :: frAcha_ptrbptr;
classe A()
std :: cout << "class_a created sucessfully" << std::endl;

~ class_a ()
std :: cout << "class_a destroyed sucessfully" << std::endl;

;
classe classe_b

público:
std :: frAcha_ptraptr;
class_b ()
std :: cout << "class_b created sucessfull" << std::endl;

~ class_b ()
std :: cout << "class_b destroyed sucessfully" b-> aptr = a;

No snippet seguinte, a saída do nosso código é exibida onde podemos verificar se as duas class_and class_b são criadas e destruídas com sucesso.

Conclusão

Neste artigo, estudamos o uso de indicadores fracos, como eles funcionam e o objetivo de usar os indicadores fracos usando vários exemplos, incluindo o código e a saída. Ponteiros fracos desempenham um papel vital em C++. Em coordenação com os ponteiros compartilhados, dicas fracas ajudam ao declarar ou inicializar um ciclo otimizado para obter os elementos. Eles também ajudam na aquisição de recursos.