realloc

Realocar blocos de memória.

Sintaxe

void *realloc(
   void *memblock,
   size_t size
);

Parâmetros

memblock
Ponteiro para o bloco de memória alocado anteriormente.

size
Novo tamanho em bytes.

Valor retornado

realloc retorna um ponteiro void para o bloco de memória realocado (e possivelmente movido).

Se não houver memória disponível suficiente para expandir o bloco para o tamanho especificado, o bloco original permanecerá inalterado e NULL será retornado.

Se size for zero, então o bloco apontado por memblock é liberado; o valor retornado é NULL e memblock é deixado apontando para um bloco liberado.

O valor retornado indica um espaço de armazenamento que está adequadamente alinhado para armazenamento de qualquer tipo de objeto. Para obter um ponteiro para um tipo que não seja void, use uma conversão de tipo no valor retornado.

Comentários

A função realloc altera o tamanho de um bloco de memória alocado. O argumento memblock aponta para o início do bloco de memória. Se memblock for NULL, realloc se comporta da mesma maneira que malloc e aloca um novo bloco de size bytes. Se memblock não NULLfor , deve ser um ponteiro retornado por uma chamada anterior para calloc, malloc, ou realloc.

O argumento size fornece o novo tamanho do bloco, em bytes. O conteúdo do bloco fica inalterado até o menor dos tamanhos novos e antigos, embora o novo bloco possa estar em um local diferente. Como o novo bloco pode estar em um novo local de memória, não há garantia de que o ponteiro retornado por realloc seja o ponteiro passado pelo memblock argumento. realloc não zera a memória recém-alocada se houver crescimento do buffer.

realloc definirá errno para ENOMEM se a alocação de memória falhar ou se a quantidade de memória solicitada exceder _HEAP_MAXREQ. Para obter informações sobre esse e outros códigos de erro, confira errno, _doserrno, _sys_errlist e _sys_nerr.

realloc chama malloc para usar a função _set_new_mode do C++ para definir o novo modo de manipulador. O novo modo do manipulador indica se, em caso de falha, malloc deverá chamar a nova rotina do manipulador, conforme definido por _set_new_handler. Por padrão, malloc não chama a nova rotina do manipulador em caso de falha ao alocar memória. Você pode substituir esse comportamento padrão para que, quando realloc falhar ao alocar memória, malloc chame a nova rotina do manipulador da mesma forma que o operador new fará quando ele falhar pelo mesmo motivo. Para substituir o padrão, chame

_set_new_mode(1);

no início do programa, ou link com NEWMODE. OBJ (consulte Opções de link).

Quando o aplicativo estiver vinculado a uma versão de depuração das bibliotecas de runtime do C, realloc será resolvido como _realloc_dbg. Para obter mais informações sobre como o heap é gerenciado durante o processo de depuração, consulte O heap de depuração do CRT.

realloc é marcado como __declspec(noalias) e __declspec(restrict), o que representa a garantia de que a função não modifica variáveis globais e que o ponteiro retornado não é um alias. Para obter mais informações, consulte noalias e restrict.

Por padrão, o estado global dessa função tem como escopo o aplicativo. Para alterar esse comportamento, confira Estado global no CRT.

Requisitos

Para obter informações sobre compatibilidade, consulte Compatibilidade.

Exemplo

// crt_realloc.c
// This program allocates a block of memory for
// buffer and then uses _msize to display the size of that
// block. Next, it uses realloc to expand the amount of
// memory used by buffer and then calls _msize again to
// display the new amount of memory allocated to buffer.

#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>

int main( void )
{
   long *buffer, *oldbuffer;
   size_t size;

   if( (buffer = (long *)malloc( 1000 * sizeof( long ) )) == NULL )
      exit( 1 );

   size = _msize( buffer );
   printf_s( "Size of block after malloc of 1000 longs: %u\n", size );

   // Reallocate and show new size:
   oldbuffer = buffer;     // save pointer in case realloc fails
   if( (buffer = realloc( buffer, size + (1000 * sizeof( long )) ))
        ==  NULL )
   {
      free( oldbuffer );  // free original block
      exit( 1 );
   }
   size = _msize( buffer );
   printf_s( "Size of block after realloc of 1000 more longs: %u\n",
            size );

   free( buffer );
   exit( 0 );
}

Size of block after malloc of 1000 longs: 4000
Size of block after realloc of 1000 more longs: 8000

Confira também

Alocação de memória
calloc
free
malloc