Em que casos eu uso malloc e / ou novo?

Vejo em C ++ que existem várias maneiras de alocar e liberar dados e entendo que, quando você liga, mallocdeve ligar freee quando você usa o newoperador, deve emparelhar deletee é um erro misturar as duas (por exemplo, ligar free()para algo que foi criado com o newoperador), mas não estou claro quando devo usar malloc/ freee quando devo usar new/ deletenos meus programas do mundo real.

Se você é um especialista em C ++, informe-me sobre quaisquer regras práticas ou convenções que você siga a esse respeito.

A menos que você seja forçado a usar C, nunca deve usá-lomalloc . Sempre use new.

Se você precisar de uma grande quantidade de dados, faça algo como:

char *pBuffer = new char[1024];

Cuidado, pois isso não está correto:

//This is incorrect - may delete only one element, may corrupt the heap, or worse...
delete pBuffer;

Em vez disso, você deve fazer isso ao excluir uma matriz de dados:

//This deletes all items in the array
delete[] pBuffer;

A newpalavra-chave é a maneira C ++ de fazê-lo e garantirá que seu tipo tenha seu construtor chamado . A newpalavra-chave também é mais segura para o tipo, enquantomalloc não é segura para o tipo.

A única maneira que eu poderia pensar que seria benéfico usar mallocseria se você precisasse alterar o tamanho do seu buffer de dados. A newpalavra-chave não possui uma maneira análoga realloc. A reallocfunção pode estender o tamanho de um pedaço de memória para você com mais eficiência.

Vale ressaltar que você não pode misturar new/ freee malloc/ delete.

Nota: Algumas respostas nesta pergunta são inválidas.

int* p_scalar = new int(5);  // Does not create 5 elements, but initializes to 5
int* p_array  = new int[5];  // Creates 5 elements

A resposta curta é: não use mallocpara C ++ sem uma boa razão para fazê-lo. mallocpossui várias deficiências quando usado com C ++, que newfoi definido para superar.

Deficiências corrigidas por novo no código C ++

1. mallocnão é tipicamente seguro de maneira significativa. Em C ++, você deve converter o retorno void*. Isso potencialmente apresenta muitos problemas:

   #include <stdlib.h>
   
   struct foo {
     double d[5];
   }; 
   
   int main() {
     foo *f1 = malloc(1); // error, no cast
     foo *f2 = static_cast<foo*>(malloc(sizeof(foo)));
     foo *f3 = static_cast<foo*>(malloc(1)); // No error, bad
   }

2. É pior do que isso, no entanto. Se o tipo em questão for POD (dados antigos simples) , você poderá usar de maneira semi-sensata mallocpara alocar memória para ele, como f2no primeiro exemplo.

   Não é tão óbvio se um tipo é POD. O fato de que é possível que um determinado tipo seja alterado de POD para não-POD sem nenhum erro resultante do compilador e com problemas potencialmente muito difíceis de depurar é um fator significativo. Por exemplo, se alguém (possivelmente outro programador, durante a manutenção, muito mais tarde fizesse uma alteração que foodeixasse de ser POD, nenhum erro óbvio apareceria em tempo de compilação, como você esperaria, por exemplo:

   struct foo {
     double d[5];
     virtual ~foo() { }
   };

   tornaria o mallocde f2ruim também tornar-se, sem qualquer diagnóstico óbvias. O exemplo aqui é trivial, mas é possível introduzir acidentalmente não-PODness muito mais longe (por exemplo, em uma classe base, adicionando um membro não-POD). Se você possui C ++ 11 / boost, pode is_podverificar se essa suposição está correta e gerar um erro se não estiver:

   #include <type_traits>
   #include <stdlib.h>
   
   foo *safe_foo_malloc() {
     static_assert(std::is_pod<foo>::value, "foo must be POD");
     return static_cast<foo*>(malloc(sizeof(foo)));
   }

   Embora o impulso não possa determinar se um tipo é POD sem C ++ 11 ou outras extensões do compilador.

3. malloc retorna NULL se a alocação falhar. newvai jogar std::bad_alloc. O comportamento de usar um NULLponteiro posteriormente é indefinido. Uma exceção possui semântica limpa quando é lançada e é lançada a partir da origem do erro. Encerrar malloccom um teste apropriado a cada chamada parece tedioso e propenso a erros. (Você só precisa esquecer uma vez para desfazer todo esse bom trabalho). Uma exceção pode se propagar para um nível em que um chamador é capaz de processá-la de maneira sensata, onde NULLé muito mais difícil retornar de forma significativa. Poderíamos estender nossa safe_foo_mallocfunção para lançar uma exceção ou sair do programa ou chamar algum manipulador:

   #include <type_traits>
   #include <stdlib.h>
   
   void my_malloc_failed_handler();
   
   foo *safe_foo_malloc() {
     static_assert(std::is_pod<foo>::value, "foo must be POD");
     foo *mem = static_cast<foo*>(malloc(sizeof(foo)));
     if (!mem) {
        my_malloc_failed_handler();
        // or throw ...
     }
     return mem;
   }

4. Fundamentalmente, mallocé um recurso C e newé um recurso C ++. Como resultado, mallocele não funciona bem com os construtores, mas apenas aloca um pedaço de bytes. Poderíamos estender safe_foo_mallocainda mais o uso da veiculação new:

   #include <stdlib.h>
   #include <new>
   
   void my_malloc_failed_handler();
   
   foo *safe_foo_malloc() {
     void *mem = malloc(sizeof(foo));
     if (!mem) {
        my_malloc_failed_handler();
        // or throw ...
     }
     return new (mem)foo();
   }

5. Nossa safe_foo_mallocfunção não é muito genérica - idealmente, queremos algo que possa lidar com qualquer tipo, não apenas foo. Podemos conseguir isso com modelos e modelos variados para construtores não padrão:

   #include <functional>
   #include <new>
   #include <stdlib.h>
   
   void my_malloc_failed_handler();
   
   template <typename T>
   struct alloc {
     template <typename ...Args>
     static T *safe_malloc(Args&&... args) {
       void *mem = malloc(sizeof(T));
       if (!mem) {
          my_malloc_failed_handler();
          // or throw ...
       }
       return new (mem)T(std::forward(args)...);
     }
   };

   Agora, embora ao corrigir todos os problemas que identificamos até agora, praticamente reinventamos o newoperador padrão . Se você vai usar malloce posicionamento new, é melhor usarnew para começar!

No C ++ FQA Lite :

[16.4] Por que devo usar malloc antigo novo e não confiável ()?

FAQ: new / delete chama o construtor / destruidor; novo é do tipo seguro, malloc não é; new pode ser substituído por uma classe.

FQA: As virtudes das novidades mencionadas no FAQ não são virtudes, porque construtores, destruidores e sobrecarga de operadores são lixo (veja o que acontece quando você não tem coleta de lixo?), E o problema de segurança de tipo é realmente pequeno aqui (normalmente você tem para converter o void * retornado por malloc no tipo de ponteiro correto para atribuí-lo a uma variável de ponteiro digitada, o que pode ser irritante, mas longe de ser "inseguro").

Ah, e o uso de malloc antigo confiável torna possível usar o realloc igualmente confiável e antigo. Pena que não temos um novo operador brilhante renovado ou algo assim.

Ainda assim, new não é ruim o suficiente para justificar um desvio do estilo comum usado em uma linguagem, mesmo quando a linguagem é C ++. Em particular, as classes com construtores não triviais se comportarão de maneira fatal se você simplesmente fizer mal aos objetos. Então, por que não usar new em todo o código? As pessoas raramente sobrecarregam o operador novo, por isso provavelmente não atrapalha muito o seu caminho. E se eles sobrecarregarem de novo, você sempre pode pedir para eles pararem.

Desculpe, eu simplesmente não pude resistir. :)

Sempre use novo em C ++. Se você precisar de um bloco de memória não digitada, poderá usar o operador new diretamente:

void *p = operator new(size);
   ...
operator delete(p);

Use malloce apenas para alocar memória que será gerenciada por bibliotecas e APIs centradas em c. Use e (e as variantes) para tudo o que você controla.free newdelete[]

novo vs malloc ()

1) newé um operador , enquanto malloc()é uma função .

2) newchama construtores , enquanto malloc()não.

3) newretorna o tipo exato de dados , enquanto malloc()retorna nulo * .

4) newnunca retorna um NULL (lançará em caso de falha) enquanto malloc()retorna NULL

5) A realocação de memória não tratada por newenquanto malloc()pode

Para responder sua pergunta, você deve saber a diferença entre mallocenew . A diferença é simples:

malloc aloca memória , enquanto new aloca memória E chama o construtor do objeto para o qual você está alocando memória.

Portanto, a menos que você esteja restrito ao C, você nunca deve usar o malloc, especialmente ao lidar com objetos C ++. Isso seria uma receita para interromper seu programa.

Também a diferença entre freee deleteé a mesma. A diferença é que deletechamará o destruidor do seu objeto, além de liberar memória.

Há uma grande diferença entre malloce new.mallocaloca memória. Isso é bom para C, porque em C, um pedaço de memória é um objeto.

No C ++, se você não está lidando com tipos de POD (que são semelhantes aos tipos C), deve chamar um construtor em um local de memória para realmente ter um objeto lá. Tipos não POD são muito comuns no C ++, pois muitos recursos do C ++ tornam um objeto automaticamente não POD.

newaloca memória e cria um objeto nesse local de memória. Para tipos não POD, isso significa chamar um construtor.

Se você fizer algo assim:

non_pod_type* p = (non_pod_type*) malloc(sizeof *p);

O ponteiro que você obtém não pode ser desreferenciado porque não aponta para um objeto. Você precisaria chamar um construtor antes de poder usá-lo (e isso é feito usando o posicionamento new).

Se, por outro lado, você fizer:

non_pod_type* p = new non_pod_type();

Você recebe um ponteiro que é sempre válido, porque new criou um objeto.

Mesmo para os tipos de POD, há uma diferença significativa entre os dois:

pod_type* p = (pod_type*) malloc(sizeof *p);
std::cout << p->foo;

Esse trecho de código imprimiria um valor não especificado, porque os objetos POD criados por mallocnão são inicializados.

Com new, você pode especificar um construtor para chamar e, assim, obter um valor bem definido.

pod_type* p = new pod_type();
std::cout << p->foo; // prints 0

Se você realmente deseja, pode usar use newpara obter objetos POD não inicializados. Veja esta outra resposta para obter mais informações sobre isso.

Outra diferença é o comportamento em caso de falha. Quando falha ao alocar memória, mallocretorna um ponteiro nulo, enquanto newlança uma exceção.

O primeiro exige que você teste todos os ponteiros retornados antes de usá-lo, enquanto o último sempre produzirá ponteiros válidos.

Por esses motivos, no código C ++ você deve usar new, e não malloc. Mas, mesmo assim, você não deve usar new"ao ar livre", porque ele adquire os recursos que você precisa liberar mais tarde. Ao usar, newvocê deve passar o resultado imediatamente para uma classe de gerenciamento de recursos:

std::unique_ptr<T> p = std::unique_ptr<T>(new T()); // this won't leak

A alocação dinâmica é necessária apenas quando a vida útil do objeto deve ser diferente do escopo em que é criado (isso também é válido para tornar o escopo menor e maior) e você tem um motivo específico para armazená-lo por valor. trabalhos.

Por exemplo:

 std::vector<int> *createVector(); // Bad
 std::vector<int> createVector();  // Good

 auto v = new std::vector<int>(); // Bad
 auto result = calculate(/*optional output = */ v);
 auto v = std::vector<int>(); // Good
 auto result = calculate(/*optional output = */ &v);

A partir do C ++ 11, temos que std::unique_ptrlidar com a memória alocada, que contém a propriedade da memória alocada.std::shared_ptrfoi criado para quando você precisa compartilhar a propriedade. (você precisará disso menos do que o esperado em um bom programa)

Criar uma instância se torna realmente fácil:

auto instance = std::make_unique<Class>(/*args*/); // C++14
auto instance = std::make_unique<Class>(new Class(/*args*/)); // C++11
auto instance = std::make_unique<Class[]>(42); // C++14
auto instance = std::make_unique<Class[]>(new Class[](42)); // C++11

O C ++ 17 também adiciona, o std::optionalque pode impedir que você exija alocações de memória

auto optInstance = std::optional<Class>{};
if (condition)
    optInstance = Class{};

Assim que 'instância' sai do escopo, a memória é limpa. Transferir propriedade também é fácil:

 auto vector = std::vector<std::unique_ptr<Interface>>{};
 auto instance = std::make_unique<Class>();
 vector.push_back(std::move(instance)); // std::move -> transfer (most of the time)

Então, quando você ainda precisa new? Quase nunca a partir do C ++ 11. A maioria dos que você usa std::make_uniqueaté chegar a um ponto em que atinge uma API que transfere a propriedade por meio de ponteiros brutos.

 auto instance = std::make_unique<Class>();
 legacyFunction(instance.release()); // Ownership being transferred

 auto instance = std::unique_ptr<Class>{legacyFunction()}; // Ownership being captured in unique_ptr

No C ++ 98/03, você precisa fazer o gerenciamento manual de memória. Se você estiver nesse caso, tente atualizar para uma versão mais recente do padrão. Se você está preso:

 auto instance = new Class(); // Allocate memory
 delete instance;             // Deallocate
 auto instances = new Class[42](); // Allocate memory
 delete[] instances;               // Deallocate

Certifique-se de rastrear a propriedade corretamente para não haver vazamentos de memória! A semântica de movimento também não funciona.

Então, quando precisamos de malloc em C ++? O único motivo válido seria alocar memória e inicializá-la mais tarde através do posicionamento new.

 auto instanceBlob = std::malloc(sizeof(Class)); // Allocate memory
 auto instance = new(instanceBlob)Class{}; // Initialize via constructor
 instance.~Class(); // Destroy via destructor
 std::free(instanceBlob); // Deallocate the memory

Mesmo assim, o acima exposto é válido, isso também pode ser feito através de um novo operador. std::vectoré um bom exemplo disso.

Finalmente, ainda temos o elefante na sala: C. Se você precisar trabalhar com uma biblioteca C em que a memória seja alocada no código C ++ e liberada no código C (ou vice-versa), você será forçado a usar o malloc / free.

Se você estiver nesse caso, esqueça as funções virtuais, funções membro, classes ... Somente estruturas com PODs nele são permitidas.

Algumas exceções às regras:

• Você está escrevendo uma biblioteca padrão com estruturas de dados avançadas onde o malloc é apropriado
• Você precisa alocar grandes quantidades de memória (na cópia de memória de um arquivo de 10 GB?)
• Você tem ferramentas impedindo o uso de certas construções
• Você precisa armazenar um tipo incompleto

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.

Se você trabalha com dados que não precisam de construção / destruição e exigem realocações (por exemplo, uma grande variedade de entradas), acredito que o malloc / free é uma boa escolha, pois fornece realloc, muito mais rápido que o new-memcpy -delete (está na minha caixa do Linux, mas acho que isso pode depender da plataforma). Se você trabalha com objetos C ++ que não são POD e requer construção / destruição, deve usar os operadores new e delete.

De qualquer forma, não vejo por que você não deveria usar os dois (desde que você libere sua memória alocada e exclua objetos alocados com novos) se puder tirar vantagem do aumento de velocidade (às vezes significativo, se estiver realocando matrizes grandes do POD) que o realloc pode fornecer.

A menos que você precise, você deve manter o novo / excluir em C ++.

Se você tiver o código C que deseja portar para o C ++, poderá deixar nele chamadas malloc (). Para qualquer novo código C ++, eu recomendo usar new.

Se você estiver usando C ++, tente usar new / delete em vez de malloc / calloc, pois são operadores. Para malloc / calloc, você precisa incluir outro cabeçalho. Não misture dois idiomas diferentes no mesmo código. O trabalho deles é semelhante em todos os aspectos: ambos alocam memória dinamicamente do segmento de heap na tabela de hash.

new inicializará os valores padrão da estrutura e vinculará corretamente as referências nela.

Por exemplo

struct test_s {
    int some_strange_name = 1;
    int &easy = some_strange_name;
}

Portanto new struct test_s, retornará uma estrutura inicializada com uma referência de trabalho, enquanto a versão em malloc'ed não possui valores padrão e as referências internas não são inicializadas.

De uma perspectiva mais baixa, new inicializará toda a memória antes de fornecer a memória, enquanto o malloc manterá o conteúdo original da memória.

No cenário a seguir, não podemos usar new, pois ele chama construtor.

class  B  {
private:
    B *ptr;
    int x;
public:
    B(int n)  {
        cout<<"B: ctr"<<endl;
        //ptr = new B;  //keep calling ctr, result is segmentation fault
        ptr = (B *)malloc(sizeof(B));
        x = n;
        ptr->x = n + 10;
    }
    ~B()  {
        //delete ptr;
        free(ptr);
        cout<<"B: dtr"<<endl;
    }
};

As newe deleteos operadores podem operar em classes e estruturas, enquanto malloce freesó trabalhar com blocos de memória que precisam ser fundido.

O uso new/deleteajudará a melhorar seu código, pois você não precisará converter a memória alocada na estrutura de dados necessária.

Caso raro a considerar usar malloc / free em vez de new / delete é quando você está alocando e realocando (tipos simples de pod, não objetos) usando realloc, pois não há função semelhante à realloc no C ++ (embora isso possa ser feito usando um mais abordagem C ++).

malloc () é usado para atribuir memória dinamicamente em C, enquanto o mesmo trabalho é feito por new () em c ++. Portanto, você não pode misturar convenções de codificação de 2 idiomas. Seria bom se você pedisse diferença entre calloc e malloc ()