Problema com Realloc [RESOLVIDO]

Hebang
(usa Arch Linux)

Enviado em 13/10/2010 - 14:19h

Gente boa!

Estou com um problema ao usar o realloc em C.

Tenho uma struct definida: Process.

Quero fazer um array dinâmico de ponteiros para "Process". Atenção: é um array de ponteiros, não de objetos.
Para isso, criei um ponteiro da seguinte forma:
struct Process* ready_list = NULL;

Quando desejo alocar espaco para um novo ponteiro para a astruct, estou usando o realloc dessa forma:
ready_list = (struct Process*)realloc( ready_list, ( ready_list_size + 1 ) * sizeof( struct Process* ) );

Onde ready_list_size é o tamanho atual do array.

Porém, o compilador acusa que o objeto alocado pelo realloc não é um para um ponteiro, e sim para um objeto.




Abaixo segue o .h e .c:

.h
#ifndef SCHEDULER_H
#define SCHEDULER_H

#include "structures.h"

extern struct Process* ready_list;
extern struct Process* io_list ;
extern unsigned int ready_list_size;
extern unsigned int io_list_size ;

void addProcessToReadyList ( struct Process* p );
void addProcessToIOList ( struct Process* p );
void removeProcessFromReadyList ( struct Process* p );
void removeProcessFromIOList ( struct Process* p );
void switchReadyList ( );

#endif








.c

#ifndef SCHEDULER_C
#define SCHEDULER_C

#include <stdlib.h>
#include "../include/scheduler.h"
#include "../include/structures.h"
#include "../include/memory_manager.h"

struct Process* ready_list = NULL;
struct Process* io_list = NULL;
unsigned int ready_list_size = 0;
unsigned int io_list_size = 0;

void startScheduler(){
resetMemory();
}

void addProcessToReadyList( struct Process* p ){
ready_list = (struct Process)realloc( ready_list, ( ready_list_size + 1 ) * sizeof( struct Process ) );
ready_list[ ready_list_size ] = *p;

ready_list_size++;
}

void addProcessToIOList( struct Process* p ){
io_list = (struct Process*)realloc( io_list, ( io_list_size + 1 ) * sizeof( struct Process ) );
io_list[ io_list_size ] = *p;

io_list_size++;
}

void removeProcessFromReadyList( struct Process* p ){
int i, index = -1;
for( i = 0; i < ready_list_size; i++ ){
if( ready_list[ i ] == p ){
index = i;
break;
}
}

if( index == -1 ){
printf( "Não pode remover da ready list!\n" );
return;
}

for( i = index; i < ready_list_size - 1; i++ )
ready_list[ i ] = ready_list[ i + 1 ];

ready_list_size--;
free( ready_list );
}

void removeProcessFromIOList( struct Process* p ){
int i, index = -1;

for( i = 0; i < io_list_size; i++ ){
if( io_list[ i ] == p ){
index = i;
break;
}
}

if( index == -1 ){
printf( "Não pode remover da IO list!\n" );
return;
}

for( i = index; i < io_list_size - 1; i++ )
io_list[ i ] = io_list[ i + 1 ];

io_list_size--;
free( io_list );
}

void switchReadyList(){
struct Process* p = ready_list[ 0 ];
int i;

for( i = 1; i < ready_list_size; i++ )
ready_list[ i - 1 ] = ready_list[ i ];

ready_list[ ready_list_size - 1 ] = p;
}

void escalonar(){
switchReadyList();

process( ready_list[ 0 ] );

if( ready_list[ 0 ]->state == (enum PROCESS_STATE)IO_IN ||
ready_list[ 0 ]->state == (enum PROCESS_STATE)IO_OUT )
{
struct Process* p = ready_list[ 0 ];
removeProcessFromReadyList( p );
addProcessToIOList( p );
}
}

#endif


Por favor, qualquer ajuda é bem vinda!

Desde já, obrigado pela atenção!

Hebang
(usa Arch Linux)

Enviado em 26/10/2010 - 18:05h

Ola!
Desculpe pela demora na resposta, mas estava ocupado com outras tarefas.

Realmente a construção correta é com ponteiro para ponteiro( struct Process** ). Agora esta tudo funcionando.
Consequentemente, no realoc, o cast e o tamanho alocado são para Process*, e não mais para Process.

Muito obrigado pela ajuda!