possível realocar

Artigo
02/25/2013

Realocar os blocos de memória.

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

Parâmetros

memblock
Ponteiro para o bloco de memória alocada anteriormente.
size
Novo tamanho em bytes.

Valor de retorno

reallocRetorna um void o ponteiro para o bloco de memória realocada (e possivelmente movidos).

Se não houver memória suficiente disponível para expandir o bloco para o tamanho, o bloco original permanece inalterada, e NULL é retornado.

Se size for zero, então o bloco apontada por memblock é liberada. o valor de retorno é NULL, e memblock é deixado aponta um bloco liberado.

O valor de retorno aponta para um espaço de armazenamento que é garantido para ser devidamente alinhado para o armazenamento de qualquer tipo de objeto.Para obter um ponteiro para um tipo diferente de void, use um tipo de projeção no valor de retorno.

Comentários

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

O size argumento fornece o novo tamanho do bloco, em bytes.O conteúdo do bloco está inalterado até o menor dos tamanhos de novos e antigos, embora o novo bloco pode estar em um local diferente.Como o novo bloco pode ser em um novo local de memória, o ponteiro retornado por realloc não é garantida para ser o ponteiro transmitido por meio do memblock argumento.reallocfaz não zero recém-alocado memória no caso de crescimento de buffer.

reallocdefine errno para ENOMEM se a alocação de memória falhar ou se a quantidade de memória solicitada excede _HEAP_MAXREQ.Para obter informações sobre este e outros códigos de erro, consulte errno, _doserrno, _sys_errlist e _sys_nerr.

reallocchamadas mallocpara usar o C++ _set_new_mode função para definir o novo modo de manipulador.O novo modo de manipulador indica se deve, em caso de falha, malloc é chamar a rotina manipuladora de novo conforme definido por _set_new_handler.Por padrão, malloc não chama a rotina manipuladora de novo em caso de falha ao alocar memória.Você pode substituir esse comportamento padrão para que, quando realloc Falha ao alocar memória, malloc chama a rotina manipuladora de novo na mesma maneira que o new operador oferece quando falhar pelo mesmo motivo.Para substituir o padrão, chamar.

_set_new_mode(1)

no início do que aquelas programa ou o vínculo com o NEWMODE.OBJ (see Opções de link).

Quando o aplicativo está vinculado com uma versão de depuração das bibliotecas de tempo de execução C, realloc resolve para _realloc_dbg.Para obter mais informações sobre como a pilha é gerenciada durante o processo de depuração, consulte A pilha de depuração CRT.

reallocestá marcado como __declspec(noalias) e __declspec(restrict), que significa que a função é garantida que não modificar variáveis globais, e que o ponteiro retornado não é com alias.Para obter mais informações, consulte noalias e restringir.

Requisitos

Rotina	Cabeçalho necessário
realloc	<stdlib.h> e <malloc.h>

Para obter informações adicionais de compatibilidade, consulte compatibilidade na introdução.

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 );
}