Erro duplo livre ou corrupção

O erro de dupla livre ou corrupção em C ++ significa que nosso programa de alguma forma invoca o objeto Free () C ++ com uma variável de ponteiro ilegal. Quando usamos ponteiros inteligentes como Shared_Ptr, devemos verificar porque se chamarmos a função get (), estamos usando diretamente o ponteiro bruto. Planejamos atribuir isso a um ponteiro inteligente para referência contínua. Esta corrupção é a causa raiz do travamento do código. Usamos a função gratuita () para deslocar a memória da heap normalmente. A memória da heap usou principalmente a função do nosso sistema operacional para gerenciar os locais da memória. Então, aqui está o erro quando nosso código não possui este ponteiro até copiarmos o código.

Quando o ponteiro é nulo:

Aqui apenas mostramos nossa função gratuita () como ele funciona no início; Incluímos bibliotecas e padrões de namespace e iniciamos o corpo principal do código inicializou a variável inteira e também inicializamos um ponteiro com o nulo para evitar o erro de dupla livre ou corrupção e outros ponteiros têm o valor de nosso número inteiro. Então usamos a instrução if-else para verificar o ponteiro nulo e o ponteiro que tem nosso valor inteiro. Após a condição, chamamos nossa função para realocar nosso ponteiro.

#incluir
usando namespace std;
int main ()

int x = 5;
int *ptr1 = null;
int *ptr2 = & x;
if (ptr1)

cout << "Pointer is not Null" << endl;

outro

cout << "Pointer is Null" << endl;

grátis (ptr1);
cout << *ptr2;

Após a execução, a saída será assim:

Como está acumulado:

Isso é acumulado se o ponteiro estiver usando a alocação de memória ou chamando a função gratuita () em C ++ diretamente às vezes. Também pode ser acumulado quando o livre () é chamado como um argumento para o mesmo local de memória um ou mais de uma vez. A estrutura de dados de gerenciamento de memória do código ficou corrompida ou não pode permitir que um usuário final suspeito insira os valores em um local de memória aleatória. Se um código chamar a função gratuita () com o mesmo local de memória mais de uma vez.

Além disso, se excluirmos a mesma entrada duas vezes e excluir algo que não foi alocado na pilha de memória. Assim, os ponteiros são a causa direta deste erro.

#incluir
#incluir
#incluir
int main ()
std :: vetor vec 0, 1, 2;
std :: vetor:: iterator it = std :: max_element (VEC.BEGIN (), VEC.fim());
std :: vetor vec2 3, 4, 5;
VEC.inserir (vec.end (), vec2.BEGIN (), VEC2.fim());
VEC.apague isso);
para (Auto & n: VEC)
std :: cout << n << std::endl;

Primeiro, integramos três bibliotecas de cabeçalho; Um é #include, na biblioteca de modelos padrão, é uma classe de modelo na linguagem de programação. É um recipiente de sequência que salva elementos. Usado principalmente para suportar os dados dinâmicos na linguagem de programação C ++. Podemos expandir os vetores, mas depende dos elementos que esses vetores contêm junto com eles.
O segundo arquivo de cabeçalho é #include que nos fornece muitas funcionalidades que podem ser para muitos propósitos, como classificar o elemento, suportar o algoritmo de pesquisa, multiplicar os valores, contar variáveis ​​e assim por diante. Por último, mas não menos importante, isso é #include esse objetivo é apoiar nosso fluxo de entrada e saída. Após as bibliotecas, iniciamos nosso corpo principal, onde usamos padrões com os vetores e atribuímos variáveis ​​com o tipo de dados inteiro e atribuímos valores a essa variável.

Aqui está a nossa declaração em que atribuímos nossa variável junto com seu início e endpoint através da função maz_element. Repita novamente a afirmação, mas mudamos nossos valores para outra variável desta vez. Em seguida, usamos a função de inserção e passamos os parâmetros que são o ponto final de nossa variável anterior, o ponto de partida da 2ª variável e o ponto final da variável. A função EASE () é usada para apagar um único elemento do vetor e também é usado para modificar o tamanho do vetor. Por fim, usamos o loop com o limite de nossa primeira variável e, no loop, exibimos a variável que inicializamos em nosso loop.

Como evitar:

Podemos evitar esse tipo de vulnerabilidade; Devemos sempre atribuir nulo ao nosso ponteiro quando estiver livre. Principalmente os gerentes de heap ignoraram os indicadores nulos livres posteriormente. Esta é a melhor prática que anulamos todos os ponteiros excluídos, bem como devemos também verificar se o ponteiro é nulo ou não antes de libertar o ponteiro. Devemos inicializar o ponteiro nulo no início do nosso código. Como quando tentamos usar a declaração cout (std :: cout).

#incluir
usando namespace std;
int main ()

int * i = new int ();
excluir i;
cout<cout<<"\npointer delete successfully";
excluir i;
cout<retornar 0;

O arquivo de cabeçalho está incluído. Em seguida, escrevemos usando o namespace padrão e iniciamos o corpo do programa principal. Inicializamos o ponteiro com o tipo de dados inteiro. Aqui atribuímos nulo ao ponteiro e imprimimos o ponteiro. Depois de atribuir o nulo, excluímos o ponteiro e imprimimos a mensagem do sucesso. Por fim, verificamos novamente nosso ponteiro e você pode ver que não existe um ponteiro existente em nossa heap de memória.

Conclusão:

Neste artigo, descrevemos brevemente o erro duplo livre ou corrupção. Em seguida, realocamos nossa memória usando nossa função () e discutimos as causas do erro e usamos o exemplo de apagar () função. No final, fornecemos uma solução uma solução simples e lógica para esse erro de uma maneira muito fácil.