C ++ std bad_weak_ptr
Sintaxe:
Abaixo está a sintaxe para criar a exceção da classe Bad_weak_ptr.
classe Bad_weak_ptr: public std :: Exceptionbad_weak_ptr ();
const char *o que () tiro ();
;
Esta classe define uma exceção que podemos jogar usando o construtor de ponteiros compartilhados que está mantendo o argumento do tipo de ponteiro fraco. Na sintaxe, a exceção acima é o erro que estaremos jogando enquanto o mau ponteiro fraco ocorre. Dentro da função de classe, declaramos duas funções do tipo de dados de caracteres constantes que são o método "o que ()" e o método "throw ()". A função "What ()" é usada para retornar o personagem terminado que identifica a exceção usada e o "tiro ()" é usado para lançar a exceção sempre que o compilador detectar o problema. O valor de retorno para o mau ponteiro fraco é a corda terminada nula com a explicação.
Exemplo # 01:
Vamos agora executar um exemplo de Bad_weak_ptr para verificar como funciona. O primeiro passo para ser executado nisso é incluir os arquivos de cabeçalho "iostrem" e a "memória". O "iostream" fornece a capacidade de executar operações de entrada e saída; Enquanto a "memória" nos permite executar várias operações relacionadas à alocação de memória, etc.
Agora, na função principal, declaramos um ponteiro compartilhado do tipo inteiro com o nome "PTR". Para esse ponteiro, passamos o valor inteiro “42” e, usando a nova palavra -chave, alocamos para a pilha de memória. E então, usando o ponteiro fraco, declaramos um Bad_weak_ptr chamado "bad_weak_pointer" ao qual referenciamos o ponteiro compartilhado "PTR". Agora, usando a palavra -chave RESET (), redefiniremos os bits no índice fornecido de "ptr" para nulo ou "0". Em seguida, chamaremos a instrução Try que é usada para executar algo definido pelo usuário. Dentro disso, declaramos outro ponteiro compartilhado chamado "P2", que estará segurando o mau ponteiro fraco "Bad_weak_pointer". Agora, chamamos a declaração Catch () que nos permitirá definir o bloco de execução sempre que o erro ocorrer. Para a declaração Catch (), passamos pelo Bad_weak_ptr e o "err" como um parâmetro. O "err" é usado para manter o erro que ocorrerá neste programa. Dentro da variável "err" do aparelho encaracolado, exibirá o tipo de erro que ocorre neste código usando o método what (), que é usado para obter a declaração que identifica o erro.
#incluir#incluir
int main ()
std :: shared_ptr ptr (new int (42));
std :: frAcha_ptr bad_weak_pointer (ptr);
ptr.reiniciar();
tentar
std :: shared_ptr p2 (bad_weak_pointer);
catch (const std :: bad_weak_ptr & err)
std :: cout << err.what() << '\n';
Agora, vamos verificar nossa saída na qual foi exibido um erro que ocorreu devido ao mau ponteiro fraco.
Exemplo # 02:
Neste exemplo, tentaremos executar outro programa BAD_WEAK_PTR no qual criaremos um objeto do tipo de ponteiro compartilhado e chamaremos o construtor e o destruidor. Vamos ter uma visão detalhada do código que vamos executar. Depois de incluir os mesmos arquivos de cabeçalho que incluímos no exemplo acima. Criaremos um objeto "BD_PTR" usando a estrutura. E chamado Enabled_Shared_From_This para o objeto BD_PTR que permite o objeto BD_PTR que é gerenciado pelo ponteiro compartilhado chamado "BD_PTR".
Dentro deste objeto, chamaremos o construtor para o "bd_ptr" e o destruidor. Além disso, dentro dessas duas funções, passamos a declaração que será exibida em sua execução bem -sucedida. E também criou uma função para esse objeto "BD-PTR" chamado "getBdptr", que retornará o Shared_PTR que compartilhará a propriedade de "this". O método "shared_from_this ()" é usado para permitir o objeto que o ponteiro compartilhado está gerenciando, permite a criação de uma instância para o objeto do ponteiro compartilhado. Agora, passando para a nossa principal função, onde chamamos a declaração de tentativa na qual declaramos uma variável chamada "f" de objeto "bd_ptr" para o qual atribuímos um heap de memória usando uma palavra -chave "nova".
Também criamos mais um ponteiro compartilhado do tipo "BD_PTR" chamado "SP" ao qual atribuímos um método getBdptr () apontando via variável "f" do objeto Type. Usando o operador "->", acessamos o elemento da estrutura para a variável "f". Para o método de captura, passamos por um tipo constante BAD_Weak_Ptr chamado "Badweakptr", o que significa que, se a exceção Bad_weak_ptr ocorrer, ele exibirá o código interno que escrevemos dentro dos aparelhos encaracolados nos quais exibirá o nome da exceção que ocorre E no final, saímos do código com -1.
#incluir#incluir
struct bd_ptr: public std :: enable_shared_from_this
bd_ptr () std :: cout << "bad pointer constructor\n";
~ bd_ptr () std :: cout << "bad pointer destructor\n";
std :: shared_ptr getBdptr () return shared_from_this ();
;
int main ()
tentar
bd_ptr *f = novo bd_ptr;
std :: shared_ptr sp = f-> getBdptr ();
Catch (const std :: bad_weak_ptr e badweakptr)
std :: cout << badweakptr.what();
saída (-1);
retornar 0;
No trecho abaixo, executamos com sucesso a mensagem de criação do construtor, o que significa que nosso construtor é criado com sucesso. Mas o destruidor não é executado porque jogamos uma exceção para o mau ponteiro fraco. Então, ele exibiu o código interno que escrevemos dentro da função de captura que exibia o tipo de erro que ocorreu.
Conclusão
Neste guia, estudamos a exceção que é BAD_WEAK_PTR, que é usada para lançar a exceção e retorna o tipo de mensagem do erro que ocorre no momento da execução. Realizamos exemplos diferentes para explicar o conceito dessa exceção e como ela é usada no código. Tentamos o nosso melhor para explicar o funcionamento do Bad_weak_ptr.