Trabalho de faculdade com lista encadeada (ponteiros)

[ton. 0]

Oi galera^^

 

Acabei de fazer meu cadastro mas já li muitas coisas desse fórum pra conseguir fazer esse trabalho, mas agora que está na reta final eu to travado em uns erros, me ajudem por favor!!!!

 

Todos os erros são nas linhas onde usei a função malloc e a função sizeof, alguem sabe se está errada a forma de uso????

 

Bom o programa ficou meio grande então vou postar o foco do problema e as meansagens de erro, o codigo inteiro eu tentei postar em spoiler, mas não foi ..

 

Estou usando BorlandC/C++ 5.5 como compilador e ele me dá os seguintes erros:

> Executing: C:\Arquivos de programas\ConTEXT\ConExec.exe "C:\Borland\BCC55\Bin\bcc32.exe" -Ic:\Borland\BCC55\include -Lc:\Borland\BCC55\lib "C:\Documents and Settings\Wellington\Meus documentos\UEM\Algoritmos\Algoritmos\beta.cpp"

 

Borland C++ 5.5.1 for Win32 Copyright © 1993, 2000 Borland

C:\Documents and Settings\Wellington\Meus documentos\UEM\Algoritmos\Algoritmos\beta.cpp:

Error E2031 C:\Documents and Settings\Wellington\Meus documentos\UEM\Algoritmos\Algoritmos\beta.cpp 29: Cannot cast from 'void *' to 'proc' in function IniciarLista()

Error E2034 C:\Documents and Settings\Wellington\Meus documentos\UEM\Algoritmos\Algoritmos\beta.cpp 32: Cannot convert 'void *' to 'proc *' in function IniciarLista()

Error E2034 C:\Documents and Settings\Wellington\Meus documentos\UEM\Algoritmos\Algoritmos\beta.cpp 50: Cannot convert 'void *' to 'proc *' in function InserirProcesso()

Error E2034 C:\Documents and Settings\Wellington\Meus documentos\UEM\Algoritmos\Algoritmos\beta.cpp 62: Cannot convert 'void *' to 'proc *' in function InserirProcesso()

Error E2034 C:\Documents and Settings\Wellington\Meus documentos\UEM\Algoritmos\Algoritmos\beta.cpp 86: Cannot convert 'void *' to 'proc *' in function VerificaProcessos()

Warning W8066 C:\Documents and Settings\Wellington\Meus documentos\UEM\Algoritmos\Algoritmos\beta.cpp 155: Unreachable code in function CalculoQuantum()

*** 5 errors in Compile ***

> Execution finished.

O primeiro erro é da linha em negrito da seguinte função:

 

void IniciarLista (void) //Função responsável por iniciar as listas de armazenamento dinâmico

{

Lista.Primeiro=(struct proc)malloc(sizeof(struct proc));

Lista.Primeiro->prox=NULL;

Lista.Ultimo=Lista.Primeiro;

Processamento.Primeiro= malloc(sizeof(struct proc));

Processamento.Primeiro->prox=NULL;

Processamento.Ultimo=Processamento.Primeiro;

}

Aqui segue o código todo com as linha de erro marcadas:

 

#include <stdio.h>
#include <stdlib.h>
#include <alloc.h>
#include <conio.h>

typedef struct proc										 
 {
   int chave;
   int inicio;
   int tamanho;
   int prioridade;
   int rodada;
   struct proc *prox;
 }processo;

typedef struct Cabeca									   
 {
   processo *Primeiro;
   processo *Ultimo;
 }TipoLista;


int QuantProcesso,QuantQuantum,Quantum,Rodada=0,QuantImpressao=0;		   
processo Insercao,*Rastreado,*Rastreador;				  
TipoLista Lista,Processamento;							  
void IniciarLista (void)									
 {
   Lista.Primeiro=(struct proc)malloc(sizeof(struct proc));																		// ****1º ERRO (linha 29)****
   Lista.Primeiro->prox=NULL;
   Lista.Ultimo=Lista.Primeiro;
   Processamento.Primeiro= malloc(sizeof(struct proc));																			// ****2º ERRO (linha 32)****
   Processamento.Primeiro->prox=NULL;
   Processamento.Ultimo=Processamento.Primeiro;
 }

void InserirProcesso (void)								 
 {														  
   Insercao.chave=QuantProcesso+1;
   printf ("\nDigite o quantum de inicio do processo [%d]: ",QuantProcesso);
   scanf ("%d",&Insercao.inicio);
   printf ("\nDigite o tamanho do processo [%d]: ",QuantProcesso);
   scanf ("%d",&Insercao.tamanho);
   printf ("\nDigite a prioridade do processo [%d]: ",QuantProcesso);
   scanf ("%d",&Insercao.prioridade);
   Insercao.rodada=0;
   if (Lista.Primeiro->prox==NULL)						  
	{													   
	 Lista.Primeiro->prox=malloc(sizeof(processo));																	// ****3º ERRO (linha 50)****		 
	 Lista.Primeiro->chave=Insercao.chave;		
	 Lista.Primeiro->inicio=Insercao.inicio;
	 Lista.Primeiro->tamanho=Insercao.tamanho;
	 Lista.Primeiro->prioridade=Insercao.prioridade;
	 Lista.Primeiro->rodada=Insercao.rodada;
	 Lista.Primeiro->prox->prox=NULL;					   
	 Lista.Ultimo=Lista.Primeiro->prox;					 
	 QuantProcesso=1;									   
	}
	else													
	{
	 Lista.Ultimo->prox=malloc(sizeof(struct proc));																		   // ****4º ERRO (linha 62)****		
	 Lista.Ultimo->chave=Insercao.chave;			
	 Lista.Ultimo->inicio=Insercao.inicio;
	 Lista.Ultimo->tamanho=Insercao.tamanho;
	 Lista.Ultimo->prioridade=Insercao.prioridade;
	 Lista.Ultimo->rodada=Insercao.rodada;
	 Lista.Ultimo->prox->prox=NULL;						 
	 Lista.Ultimo=Lista.Ultimo->prox;					  
	 QuantProcesso++;									   
	}
 }

void VerificaProcessos (void)
 {
   processo *busca;
   int contbusca;
   if (Lista.Primeiro==NULL)
	printf ("\n\tNão há processos armazenados!");
	else
		{
		 busca=Lista.Primeiro;
		 for (contbusca=1;contbusca<QuantProcesso;contbusca++)
		  if (busca->inicio==Quantum)
		   {
			Processamento.Ultimo->prox=malloc(sizeof(processo));															 // ****5º ERRO (linha 86)****
			Processamento.Ultimo->chave=busca->chave;
			Processamento.Ultimo->inicio=busca->inicio;
			Processamento.Ultimo->tamanho=busca->tamanho;
			Processamento.Ultimo->prioridade=busca->prioridade;
			Processamento.Ultimo->rodada=busca->rodada;
			Processamento.Ultimo->prox->prox=NULL;
			Processamento.Ultimo=Processamento.Ultimo->prox;
			busca=busca->prox;
			QuantQuantum++;
		   }
		   else
			busca=busca->prox;
		}
 }

void ImprimeStatus (void)
	 {
	  processo *impressora;
	  int imprimindo=0;
	  impressora=Processamento.Primeiro;
	  while (imprimindo<QuantQuantum)
			{
			  if (QuantImpressao==0)
				{
				 impressora=Lista.Primeiro;
				 printf ("\nStatus inicial dos processos seguindo o esquema 'processo{prioridade}(inicio)[tamanho]':\n");
				 while (QuantImpressao<QuantProcesso)
					   {
						 printf ("%d{%d}(&d)[%d]; ",impressora->chave,impressora->prioridade,impressora->inicio,impressora->tamanho);
						 impressora=impressora->prox;
						 QuantImpressao++;
					   }
				 impressora=Processamento.Primeiro;
				}
			  if (imprimindo==0)
				 {
				  printf ("\nStatus relativo dos processos seguindo o esquema 'processo[tamanho]':\n");
				  printf ("\nQuantum: %d;\tCiclo: %d;\nProcessos: ",&Quantum,&Rodada);
				 }
			  printf ("%d[%d]; ",impressora->chave,impressora->tamanho);
			  impressora=impressora->prox;																																						 
			  imprimindo++;
			 }
	  imprimindo=0;
	 }

void CalculoQuantum (void)
 {
  int contador=0;
  processo *Prioritario,*buscador;
  VerificaProcessos();
  Prioritario=Processamento.Primeiro;
  while (contador<QuantQuantum)
  {
   if (Processamento.Primeiro->prox==NULL && Prioritario->tamanho>0)
	 {
	  Prioritario->tamanho--;
	  Prioritario->rodada++;
	  Quantum++;
	  VerificaProcessos();
	  Rodada++;
	  ImprimeStatus();
	 }
	 else
	   while (Prioritario->rodada>Rodada || Prioritario->tamanho<=0)
		if (Prioritario->prox==NULL)
		   {
			break;
			printf ("\n\tExecução finalizada");
		   }
		   else
			   Prioritario=Prioritario->prox;
	   buscador=Prioritario->prox;
  while (buscador->prox!=NULL)
	  if (buscador->prioridade>Prioritario->prioridade && buscador->rodada<=Rodada && buscador->tamanho>0)
		 {
		  Prioritario=buscador;
		  buscador=buscador->prox;
		 }
		 else
			 buscador=buscador->prox;
  Prioritario->tamanho--;
  Prioritario->rodada++;
  Quantum++;
  VerificaProcessos();
  contador++;
  ImprimeStatus();
  }
  Rodada++;
 }
 
int main ()
{
  int op,verificado,verificacao;
  int contcase2=0,intro=0;
  processo *case2,*verificador;

  printf ("\n\tBem vindo!");
  printf ("\nEste programa foi desenvolvido por mim, Wellington T. Zenon, RA: 45482,");
  printf ("\nacadêmico do 2º ano de Engenharia de Produção - Software da Universidade");
  printf ("\nEstadual de Maringá, para a matéria de Sistemas Operacionais, ministrada");
  printf ("\npelo Prof. Muriel de Souza Godoi.\n");
  printf ("\nO objetivo didático é simular um processador funcionado em Round-Robin, que");
  printf ("\né uma técnica de escalonamento preemptiva usada em processadores, porém de-" );
  printf ("\nve-se aplicá-la com o uso de prioridades.\n");
  printf ("\nEste programa foi projetado com o usa de Listas Encadeadas por ponteiros, ");
  printf ("\ne para quantums de valor igual a 1, portanto para verificar deve-se considar o");
  printf ("\ntempo de inicio e o tamanho dos processos relativamente ao valor 1 do quantum.\n");
  printf ("\n\tPressione 'Enter'");
  intro++;
  getch();
  clrscr();
  IniciarLista();
  while (op!='0')
   {
	printf ("\n\nEscolha uma opcao: ");
	printf ("\n1 - Insere um processo na lista;");
	printf ("\n2 - Calcula o tempo de processamento;");
	printf ("\n\n0 - Sair;\n");
	op=getche();
	switch (op)
	 {
	  case '1': InserirProcesso();
				case2=Lista.Primeiro;
				printf ("\nStatus inicial dos processos seguindo o esquema 'processo{prioridade}(inicio)[tamanho]':\n");
				while (contcase2<QuantProcesso)
					  {
					   printf ("%d{%d}(&d)[%d]; ",case2->chave,case2->prioridade,case2->inicio,case2->tamanho);
					   case2=case2->prox;
					   contcase2++;
					  }
				contcase2=0;
		break;

	  case '2': do
				  {
					CalculoQuantum();
					verificador=Processamento.Primeiro;
					verificado=0;
					for (verificacao=0;verificacao<QuantProcesso;verificacao++)
						if (verificador->tamanho>0)
						   {
							 verificacao=QuantProcesso;
							 verificado=1;
						   }
						   else
							   verificador=verificador->prox;
				  }
				  while (verificado>0);
		break;
	  default: printf ("\n\nOpcao invalida, escolha outra...");
	 }
   }
   return 0;
}

[ton. 0]

Bom acho q qdo a pessoa ver o tamanho do tópico vai desistir de ler^^

 

eu procurei alguma coisa sobre função 'malloc' e 'sizeof' e não achei o erro ainda, parece q está tudo certo Y_Y

 

se alguem aí já tiver usado essas funções pra ponteiros me ajuda pls!!!!!!

[Beraldo 864]

Já tentou fazer o casting com (struct proc *) (ponteiro para estrutura)?

[ton. 0]

não...

 

mas ja resolvi o problema xD~

 

eu estava salvando em .cpp, que é pra C++, mas esse programa é em C

 

x]~

 

mas vlw pela resposta

[ton. 0]

Agora q compilou q a diversão começa xD

 

aiuhsdiuashduhuiahsuidhasuidhasd

 

to com um problema novo, o programa está imprimindo corretamente os numeros inteiro inseridos nos vetores pelo usuário, porém ele não imprime variaveis inteiras (tipo um contador), ao inves disso ele imprime um numero gigante!!!!! tipo 45897

 

se alguem tiver alguma ideia do que possa ser, sou grato!

 

x]~

[Beraldo 864]

Nos printf's você colocou:

%d{%d}(&d)[%d];

Não seria isto?

%d{%d}(%d)[%d];

[ton. 0]

aham!!! era isso e tb pq eu coloquei tipo

 

printf ("Quantum: %d",&Quantum);

 

e o sinal '&' indica o endereço na memória, então ele estava imprimindo o endereça da memória da variável e não o valor dela x]~

 

vlw!!!

 

=]

 

 

agora surgiu outro problema...

 

eu preciso que duas funções acessem umas as outras condicionalmente...

 

Função 1 e Função 2(Verifica os dados da função 1)

 

Função 1(VerificaProcesso) sempre vai terminar acessando a Função 2(ValidaProcesso) e a Função 2 caso verifique que os dados não são consistentes reinicia a função 1.....

 

O código:

 

void ValidaProcessos ()
{
  processo *busca2;
  int validacao;
  busca2=Processamento.Primeiro;
		 do
		   {
			if (busca2->tamanho>0)
			   validacao=1;
			else
				if (busca2->prox==NULL && validacao!=1)
				  {
				   Quantum++;
				   VerificaProcessos();
				  }
			   else
				   busca2=busca2->prox;
		   }
		 while (validacao!=1 && busca2->prox!=NULL);
 }


void VerificaProcessos (void)							  //Função reponsável por verificar a entrada de novos porcessos a cada Quantum
 {
   processo *busca;
   if (Lista.Primeiro->prox==NULL)						 //Verifica se há processos
	printf ("\n\tNão há processos armazenados!");
	else
		{
		 busca=Lista.Primeiro;
		 do											   //Do-While para varrer os processos buscando os processos que se iniciarao no quantum atual
		  if (busca->inicio==Quantum)					 //Iserção do processo na lista de processos ativos no caso dele se iniciar nesse quantum
		   {
			Processamento.Ultimo->prox=malloc(sizeof(processo));
			Processamento.Ultimo->chave=busca->chave;
			Processamento.Ultimo->inicio=busca->inicio;
			Processamento.Ultimo->tamanho=busca->tamanho;
			Processamento.Ultimo->prioridade=busca->prioridade;
			Processamento.Ultimo->rodada=busca->rodada;
			Processamento.Ultimo->prox->prox=NULL;
			Processamento.Ultimo=Processamento.Ultimo->prox;
			busca=busca->prox;
			QuantQuantum++;
		   }
		   else
			busca=busca->prox;
		 while (busca->prox!=NULL);
		 ValidaProcessos();
		}
 }

Tem algum modo de declarar uma função dentro de outra função????