Qual é o equivalente a novo/excluído de C ++ em C?

Question

Qual é o equivalente a novo/excluído de C ++ em C?

Ou é o mesmo em C/C ++?

Answer 1

Não há new/delete expressão em C.

O equivalente mais próximo é o malloc e free funções, se você ignorar os construtores/destruidores e tipo de segurança.

#include <stdlib.h>

int* p = malloc(sizeof(*p));   // int* p = new int;
...
free(p);                       // delete p;

int* a = malloc(12*sizeof(*a));  // int* a = new int[12];
...
free(a);                         // delete[] a;

Answer 2

Observe que os construtores podem lançar exceções no C ++. O equivalente a player* p = new player(); seria algo assim em C.

struct player *p = malloc(sizeof *p);
if (!p) handle_out_of_memory();
int err = construct_player(p);
if (err)
{
    free(p);
    handle_constructor_error();
}

O equivalente a delete p é mais simples, porque os destruidores nunca devem "jogar".

destruct(p);
free(p);

Answer 3

Uso de new e delete No C ++ combina duas responsabilidades - alocando/liberando memória dinâmica e inicializando/liberando um objeto.

Como dizem todas as outras respostas, a maneira mais comum de alocar e lançar memória dinâmica está chamando malloc e free. Você também pode usar funções específicas do SO para obter um grande pedaço de memória e alocar seus objetos nisso, mas isso é mais raro - apenas se você tiver requisitos bastante específicos que o MALLOC não satisfaz.

Em C, a maioria das APIs fornecerá um par de funções que cumprem os outros papéis de new e delete.

Por exemplo, a API do arquivo usa um par de funções abertas e próximas:

// C++
fstream* fp = new fstream("c:\\test.txt", "r");
delete fp;

// C
FILE *fp=fopen("c:\\test.txt", "r"); 
fclose(fp);

Pode ser que fopen usos malloc para alocar o armazenamento para o FILE Struct, ou pode alocar estaticamente uma tabela para o número máximo de ponteiros de arquivo no processo de início do processo. O ponto é que a API não exige que o cliente use malloc e free.

Outras APIs fornecem funções que apenas executam a inicialização e a liberação de parte do contrato - equivalente ao construtor e destruidor, o que permite que o código do cliente use armazenamento automático, estático ou dinâmico. Um exemplo é a API do Pthreads:

pthread_t thread;

pthread_create( &thread, NULL, thread_function, (void*) param); 

Isso permite o cliente mais flexibilidade, mas aumenta o acoplamento entre a biblioteca e o cliente - o cliente precisa saber o tamanho do pthread_t Tipo, enquanto que se a biblioteca lidar com a alocação e a inicialização, o cliente não precisará saber o tamanho do tipo, para que a implementação possa variar sem alterar o cliente. Nem introduz tanto acoplamento entre o cliente e a implementação quanto o C ++. (Muitas vezes é melhor pensar em C ++ como um modelo de metaprogramação com vtables do que uma linguagem OO)

Answer 4

Não é diretamente uma réplica exata, mas equivalentes compatíveis são malloc e gratuitos.

<data-type>* variable = (<data-type> *) malloc(memory-size);
free(variable);

Sem construtores/destruidores - C de qualquer maneira não os possui :)

Para obter o tamanho da memória, você pode usar sizeof operador.

Se você quiser trabalhar com matrizes multidimensionais, precisará usá -lo várias vezes (como novo):

int** ptr_to_ptr = (int **) malloc(12 * sizeof(int *)); //assuming an array with length 12.
ptr[0] = (int *) malloc(10 * sizeof(int));   //1st element is an array of 10 items
ptr[1] = (int *) malloc(5 * sizeof(int));    //2nd element an array of 5 elements etc

Answer 5

Use funções MALLOC / GRATUITAS.