Qual é a diferença entre new / delete e malloc / free?

Qual é a diferença entre new/ deletee malloc/ free?

Relacionado (duplicado?): Em que casos eu uso malloc vs new?

novo / excluir

• Alocar / liberar memória
  1. Memória alocada no 'Free Store'
  2. Retorna um ponteiro totalmente digitado.
  3. new (versão padrão) nunca retorna um NULL (será lançado em caso de falha)
  4. São chamados com o Type-ID (o compilador calcula o tamanho)
  5. Tem uma versão explicitamente para manipular matrizes.
  6. A realocação (para obter mais espaço) não é manipulada intuitivamente (por causa do construtor de cópias).
  7. Se eles chamam malloc / free é a implementação definida.
  8. Pode adicionar um novo alocador de memória para lidar com pouca memória (set_new_handler)
  9. operador new / delete pode ser substituído legalmente
  10. construtor / destruidor usado para inicializar / destruir o objeto

malloc / grátis

• Aloca / libera memória
  1. Memória alocada de 'Heap'
  2. Retorna um nulo *
  3. Retorna NULL em falha
  4. Deve especificar o tamanho necessário em bytes.
  5. A alocação de matriz requer cálculo manual de espaço.
  6. Realocando um pedaço maior de memória simples (não é necessário se preocupar com o construtor de cópias)
  7. Eles NÃO irão chamar novos / excluir
  8. Não há como dividir o código do usuário na sequência de alocação para ajudar com pouca memória.
  9. malloc / free NÃO pode ser substituído legalmente

Tabela de comparação dos recursos:

 Feature                  | new/delete                     | malloc/free                   
--------------------------+--------------------------------+-------------------------------
 Memory allocated from    | 'Free Store'                   | 'Heap'                        
 Returns                  | Fully typed pointer            | void*                         
 On failure               | Throws (never returns NULL)    | Returns NULL                  
 Required size            | Calculated by compiler         | Must be specified in bytes    
 Handling arrays          | Has an explicit version        | Requires manual calculations  
 Reallocating             | Not handled intuitively        | Simple (no copy constructor)  
 Call of reverse          | Implementation defined         | No                            
 Low memory cases         | Can add a new memory allocator | Not handled by user code      
 Overridable              | Yes                            | No                            
 Use of (con-)/destructor | Yes                            | No                            

Tecnicamente, a memória alocada por new vem do 'Free Store', enquanto a memória alocada pelo malloc vem do 'Heap'. Se essas duas áreas são iguais, é um detalhe da implementação, que é outro motivo pelo qual malloc e new não podem ser misturados.

A diferença mais relevante é que o newoperador aloca memória e depois chama o construtor, e deletechama o destruidor e, em seguida, desaloca a memória.

newchama o ctor do objeto, deletechame o dtor.

malloc& freeapenas aloque e libere memória não processada.

new/ deleteé C ++, malloc/ freevem do bom e velho C.

No C ++, newchama um construtor de objetos e deletechama o destruidor.

malloce free, vindo da idade das trevas antes do OO, apenas aloque e libere a memória, sem executar nenhum código do objeto.

Em C ++ new/ deletechame o Construtor / Destrutor de acordo.

malloc/ freesimplesmente aloque memória da pilha. new/ deletealocar memória também.

As únicas semelhanças são que malloc/ newretornam um ponteiro quais endereços alguma memória na pilha, e ambos garantia de que uma vez que um tal bloco de memória foi devolvido, não vai ser devolvido novamente a menos que você livre / excluí-lo primeiro. Ou seja, ambos "alocam" memória.

No entanto, new/ deleteexecutar outros trabalhos arbitrário para além disso, através de construtores, destruidores e sobrecarga de operador. malloc/ freeapenas aloque e libere memória.

De fato, newé suficientemente personalizável para não necessariamente devolver a memória do heap, nem sequer alocar memória. No entanto, o padrão newfaz.

A principal diferença entre new e malloc é que new chama o construtor do objeto e a chamada correspondente a excluir chama o destruidor do objeto.

Existem outras diferenças:

• newé seguro para o tipo, mallocretorna objetos do tipovoid*

• newlança uma exceção no erro, mallocretorna NULLe define errno

• newé um operador e pode ser sobrecarregado, mallocé uma função e não pode ser sobrecarregado

• new[], que aloca matrizes, é mais intuitivo e seguro para tipos do que malloc

• mallocalocações derivadas podem ser redimensionadas via realloc, newalocações derivadas não podem ser redimensionadas

• mallocpode alocar um pedaço de memória de N bytes, newdeve ser solicitado que aloque uma matriz de, digamos, chartipos

Observando as diferenças, um resumo é malloc e C-esque, o novo é C ++-esque. Use o que achar melhor para sua base de código.

Embora seja legal que o novo e o malloc sejam implementados usando algoritmos diferentes de alocação de memória, na maioria dos sistemas novos é implementado internamente usando o malloc, não produzindo diferença no nível do sistema.

Existem algumas coisas que newisso mallocnão funciona:

1. new constrói o objeto chamando o construtor desse objeto
2. new não requer conversão de tipo de memória alocada.
3. Ele não requer que uma quantidade de memória seja alocada, mas requer que vários objetos sejam construídos.

Portanto, se você usar malloc, precisará fazer as coisas acima explicitamente, o que nem sempre é prático. Além disso, newpode estar sobrecarregado, mas mallocnão pode estar.

Em uma palavra, se você usa C ++, tente usar newo máximo possível.

Além disso,

o novo global e a exclusão podem ser substituídos, malloc / free não.

ainda mais novos e excluir podem ser substituídos por tipo.

newe deletesão primitivas em C ++ que declaram uma nova instância de uma classe ou a excluem (chamando assim o destruidor da classe para a instância).

malloce freesão funções C e alocam e liberam blocos de memória (em tamanho).

Ambos usam o heap para fazer a alocação. malloce, freeno entanto, são mais "de baixo nível", pois apenas reservam um pedaço de espaço de memória que provavelmente será associado a um ponteiro. Nenhuma estrutura é criada em torno dessa memória (a menos que você considere uma matriz C uma estrutura).

new e delete são operadores em c ++; que pode ser sobrecarregado também. malloc e free são funções em c;

malloc retorna nulo ptr quando falha enquanto novo lança exceção.

o endereço retornado pelo malloc precisa ser convertido novamente pelo tipo convertido, pois retorna o malloc (tamanho *) (void *) New, retornando o ponteiro digitado.

• new é um operador, enquanto malloc () é uma função.
• new retorna o tipo exato de dados, enquanto malloc () retorna void * (ponteiro do tipo void).
• malloc (), a memória não é inicializada e o valor padrão é lixo, enquanto que no caso de novo, a memória é inicializada com valor padrão, como 'zero (0)' no caso de int.
• delete e free () podem ser usados ​​para ponteiros 'NULL'.

• Para usar o malloc(), precisamos incluir <stdlib.h> ou <alloc.h>no programa que não é necessário new.
• newe deletepode ser sobrecarregado, mas mallocnão pode.
• Usando o posicionamento new, podemos passar o endereço onde queremos alocar memória, mas isso não é possível no caso de malloc.

Este código para uso da palavra-chave delete ou da função free. Porém, ao criar um objeto ponteiro usando 'malloc' ou 'new' e desalocar a memória do objeto usando delete, mesmo esse ponteiro de objeto pode ser uma função de chamada na classe. Depois disso, use free em vez de delete e também funciona após a instrução free, mas quando os dois são usados, apenas o objeto ponteiro não pode chamar para funcionar na classe .. o código é o seguinte:

#include<iostream>


using namespace std;

class ABC{
public: ABC(){
    cout<<"Hello"<<endl;
  }

  void disp(){
    cout<<"Hi\n";
  }

};

int main(){

ABC* b=(ABC*)malloc(sizeof(ABC));
int* q = new int[20];
ABC *a=new ABC();
b->disp();

cout<<b<<endl;
free(b);
delete b;
//a=NULL;
b->disp();
ABC();
cout<<b;
return 0;
}

resultado :

Hello
Hi
0x2abfef37cc20

1.novo syntex é mais simples que malloc ()

2.new/delete é um operador em que malloc () / free () é uma função.

3.new/delete executa mais rápido que malloc () / free () porque o novo código de montagem é diretamente colado pelo compilador.

4.nós podemos alterar o novo / excluir significado no programa com a ajuda do operador.