mano, nunk o youtube acertou tão bem ao recomendar seu canal, olha q procurei e não tinha mais encontrado, bem qndo estava com esse problema de gerenciamento dinâmico de memória voalá, vc aparece, muito obrigado...Estoui desenvolvendo para o mengadrive de 16bits e 2,5 mb de ram kkkk a briga por kbites está insana, mas alocando as memórias manualmente em blocos separados, vai evitart muitos bugs, vanos ver até onde vai esse motorola 68000
No CodeBlocks, quando desaloquei, o ponteiro perdeu toda a referência que tinha sido alocada na chamada do malloc, ficando com lixo de memória na saída de dados. Da mesma forma que aconteceu com o calloc, não fica com valor 0 depois de ter desalocado.
É pq quando vc desaloca com free vc está falando pro SO que não precisa mais daqueles endereços, portanto o SO pode colocar outros valores la dentro. Por isso é sempre bom colocar o ponteiro apontando pra null tbm.
No Windows isso não acontece, ele desaloca a memória, e acho que ele perde a referência do p, mas mesmo assim ainda existe, quando esse código é executado: int *p = (int *) malloc(sizeof(int)); *p = 125; free(p); printf("%d", *p); Ele mostra o lixo que está no pedaço da memória p
Pessoal, esse lixo não é nada mais nada menos que o próprio endereço de memória antigo, pode ser qualquer outro tipo de valor atribuído ao ponteiro. É aleatório, só devem entender que o ponteiro não retorna ao NULL ele mantém a memória original anteriormente alocada para uso posterior. No entanto, ao chamar o malloc() novamente para o ponteiro não é garantido que ele voltará ao antigo local de memória, principalmente se ele já estiver alocado em outro ponteiro. É assim mesmo, não existe exatidão nessas paradas.
E quando declaramos o malloc assim? int *p; p = (int*)malloc(sizeof(int)); //Resevei o espaço para alocação --> (Conversão para tipo *)malloc(sizeof(TIPO)) p = 24; //Atribui o valor a ser alocado no espaço ????????????
[RESOLVIDO] [Pelo menos no linux]: dá certo colocando a declaração toda do malloc junto a variável dentro do free(). Ou seja, ao invés de "free(p);" seria "free(p = (int*)malloc(sizeof(int)));"
7 anos depois eu tô vendo aqui os vídeos pra tentar resolver as questões e você tá abrindo minha mente
Eu to amando sua didática :) é de outro nível!
mano, nunk o youtube acertou tão bem ao recomendar seu canal, olha q procurei e não tinha mais encontrado, bem qndo estava com esse problema de gerenciamento dinâmico de memória voalá, vc aparece, muito obrigado...Estoui desenvolvendo para o mengadrive de 16bits e 2,5 mb de ram kkkk a briga por kbites está insana, mas alocando as memórias manualmente em blocos separados, vai evitart muitos bugs, vanos ver até onde vai esse motorola 68000
Rapaz!!! Melhor didática para o assunto que eu encontrei.
Excelentes aulas. Simplicidade e clareza de ideias. Vida longa ao canal.
Muito obrigado professor pela ajuda, com certeza os videos me ajudaram bastante a fechar provas de programação na faculdade!!!
Continue com as video aulas ! voce explica muito bem ! nao pare de fazer videos de C por favor, gracas a vc tudo fica mais facil mt obrigado !
Esse canal foi a minha salvação pra aprender linguagem C; Muito obrigado!
Cara, muito obrigado. Aula 96 e 97 me salvaram demais!
Muito bom professor, pra ficar excelente o video seria bom alguns exercícios. Obrigado pela ajuda!
Que cara bom!
Muito boas suas aulas, espero que continue.
inscrito número 43.100
*MUITO BOM*
assistir 10 videos todos muito bom baixei todosobrigado pela ajuda
Ótima aula!
Aula perfeita!
Realmente Rafael...
Nos meus código em Dev, se eu posicionar a função free() antes da impressão, o valor se perde e imprime uns valores que parecem a posição da memoria.
aconteceu o msm comigo, conseguiu descobrir o pq?
Obrigado! Ótima explicação!
Muito obg !
No CodeBlocks, quando desaloquei, o ponteiro perdeu toda a referência que tinha sido alocada na chamada do malloc, ficando com lixo de memória na saída de dados. Da mesma forma que aconteceu com o calloc, não fica com valor 0 depois de ter desalocado.
É pq quando vc desaloca com free vc está falando pro SO que não precisa mais daqueles endereços, portanto o SO pode colocar outros valores la dentro. Por isso é sempre bom colocar o ponteiro apontando pra null tbm.
No Windows isso não acontece, ele desaloca a memória, e acho que ele perde a referência do p, mas mesmo assim ainda existe, quando esse código é executado:
int *p = (int *) malloc(sizeof(int));
*p = 125;
free(p);
printf("%d", *p);
Ele mostra o lixo que está no pedaço da memória p
Me ajudou demais em Analise e Estrutura de Dados na USP :D
Imaginei que alunos da USP nem assistissem videoaulas de tão fodas que são haha
Professor, me confirma uma coisa: ao fim da execução da main, se nao usarmos o free(), a memória permanece alocada no computador?
Aqui a função free antes do printf não só desaloca a memória, como faz o printf retornar um valor totalmente aleatório.
Ótimo
No meu, terminal do visual studio no windows, ele dezaloca a memória e seta o ponteiro pra NULL.
estou usando o sistema linux ubuntu, por que sera que as variaveis contem o valor 0, e o ponteiro depois de desalocado possui o valor 0
show
no arduino, qnd você chama free() ele seta para NULL.
pois invés de aparecer 1000 no meu log, apareceu "" (NADA-NULL)
CONTINUA AS AULAS :(
No Ubuntu 14.04, a função "free(void*)" enche a posição desalocada com zeros.
Compilador: gcc (Ubuntu 4.8.4-2ubuntu1~14.04) 4.8.4.
Opções passadas ao compilador: -Wall -ansi -O2 -pedantic-errors alocacao.c -o alocacao
===============================================================
/* alocacao.c */
#include
#include
int main(void) {
int* p;
int* m;
p = (int*)malloc(sizeof(int));
printf("p = %p
", (void*)p);
*p = 1000;
printf("*p = %d
", *p);
free(p);
printf("p = %p
", (void*)p);
m = (int*)malloc(sizeof(int));
printf("m = %p
", (void*)m);
printf("*m = %d
", *m);
printf("*p = %d
", *p);
return EXIT_SUCCESS;
}
==============================================================
Saída do programa no meu pc
==============================================================
p = 0x1828010
*p = 1000
p = 0x1828010
m = 0x1828010
*m = 0
*p = 0
O Delete acima da saida de dados não deleto da mesma forma que o free();
Pessoal, esse lixo não é nada mais nada menos que o próprio endereço de memória antigo, pode ser qualquer outro tipo de valor atribuído ao ponteiro. É aleatório, só devem entender que o ponteiro não retorna ao NULL ele mantém a memória original anteriormente alocada para uso posterior. No entanto, ao chamar o malloc() novamente para o ponteiro não é garantido que ele voltará ao antigo local de memória, principalmente se ele já estiver alocado em outro ponteiro. É assim mesmo, não existe exatidão nessas paradas.
E quando declaramos o malloc assim?
int *p;
p = (int*)malloc(sizeof(int)); //Resevei o espaço para alocação --> (Conversão para tipo *)malloc(sizeof(TIPO))
p = 24; //Atribui o valor a ser alocado no espaço
????????????
[RESOLVIDO] [Pelo menos no linux]: dá certo colocando a declaração toda do malloc junto a variável dentro do free().
Ou seja, ao invés de "free(p);" seria "free(p = (int*)malloc(sizeof(int)));"
nao há necessidade de fazer o casting ali. Aqui no Codeblocks ele imprime 1000 msm sem o casting