Ir ao conteúdo
  • Cadastre-se
FebenSss

Estrutura Dinâmica

Recommended Posts

Boa tarde galera, estou com um exercício aqui, porém não compreendi como fazer, tenho que criar uma estrutura voo deve ser implementada de forma dinâmica, e eu não sei como posso fazer ela ficar dinâmica, alguem pode me dar um exemplo?

struct voo{    
int numeroVoo;
int dataVoo;
int horarioVoo;
char aeroSaida[20];
char aeroChegada[20];
int rota;
int tempoVoo;
int passageirosBordo;
};

Compartilhar este post


Link para o post
Compartilhar em outros sites

Significa que ela deve ser alocada dinamicamente F5Rua4D.gif.

Este é um exemplo em C de alocação e manipulação de um registro dinâmico:


struct Tipo
{
int Valor;
};


Tipo *Ponteiro = (Tipo *) malloc(sizeof(Tipo));
Ponteiro->Valor = 20;
printf("%d\n", Ponteiro->Valor);
free(Ponteiro);

Espero ter ajudado GbhmuXl.gif.

  • Curtir 1

Compartilhar este post


Link para o post
Compartilhar em outros sites

Então man, olhei vários materias e vídeos aulas, mais não entra na cabeça essa alocação dinâmica, teria como dar um exemplo nesse código ?

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

//Declarando as variáveis.
int op;

//Estrutura de Voo.
struct VOO{
int numeroVoo;
int dataVoo;
int horarioVoo;
char aeroSaida[50];
char aeroChegada[50];
int rota;
int tempoVoo;
int passageirosBordo;
}voo;

//Função de MENU.
menu(){
printf("\n\n\t_________________________");
printf("\n\t MENU");
printf("\n\t ESCOLHA SUA OPCAO");
printf("\n\t------------------------\n\n");

printf("\n\t1- CADASTRAR VOO.");
printf("\n\t2- CONSULTAR VOO.");
printf("\n\t3- REMOVER VOO.\n\n");
printf("\n\tOPCAO: ");
scanf("%d",&op);
system("cls");
}

//Função de Cadastro de Voo.
cadastrarVoo(){
printf("\n\n\t________________________");
printf("\n\t MENU CADASTRAR VOO.");
printf("\n\t------------------------\n\n");

printf("\n\tNUMERO DO VOO: ");
scanf("%d",&voo.numeroVoo);
printf("\tDATA DO VOO: ");
scanf("%d",&voo.dataVoo);
printf("\tHORARIO DO VOO: ");
scanf("%d",&voo.horarioVoo);
printf("\tAEROPORTO DE SAIDA: ");
scanf("%s",&voo.aeroSaida);
printf("\tAEROPORTO DE CHEGADA: ");
scanf("%s",&voo.aeroChegada);
printf("\tROTA: ");
scanf("%d",&voo.rota);
printf("\tTEMPO ESTIMADO DO VOO: ");
scanf("%d",&voo.tempoVoo);
printf("\tQNT DE PASSAGEIROS: ");
scanf("%d",&voo.passageirosBordo);
}

//Função de Consulta Voo.
consultarVoo(){
printf("\n\n\t________________________");
printf("\n\t MENU CONSULTAR VOO.");
printf("\n\t------------------------\n\n");

printf("\n\tNUMERO DO VOO: ");
scanf("%d",&voo.numeroVoo);
printf(&voo.numeroVoo);
}

//Função de Remover Voo.
removerVoo(){
printf("\n\n\t________________________");
printf("\n\t MENU REMOVER VOO.");
printf("\n\t------------------------\n\n");

printf("\n\tDIGITE O NUMERO DO VOO QUE DESEJA REMOVER");
printf("\n\tNUMERO DO VOO: ");
scanf("%d",&voo.numeroVoo);
}



int main(int argc, char *argv[])
{

//voo *v = (voo*) malloc(sizeof(voo));
//free(v);

menu(); //Chamando função de MENU.
switch (op){
case 1:
cadastrarVoo();
break;
case 2:
consultarVoo();
break;
case 3:
removerVoo();
break;
}


system("PAUSE");
return 0;
}

Compartilhar este post


Link para o post
Compartilhar em outros sites

Primeira dica - Relacionado ao Dev-C++

Desativar a opção 'Smart Tabs'

Menu Tools -> Editor Options -> Desmarcar a opção 'Smart Tabs' na primeira coluna.

Sobre seu código:

Sempre que você for cadastrar um novo voo, você deve criar uma nova variável do tipo struct VOO. O nome é dinamicamente porque a cada execução, novas instâncias da estrutura são definidas. Seu programa não é estático.

Você pode utilizar ponteiros, com alocação dinâmica de memória, utilizando-se de estruturas de dados dinâmicas. Caso tenha dúvidas em relação a alocação dinâmica, esta página pode ajudar.

http://www.ime.usp.br/~pf/algoritmos/aulas/aloca.html

No mais, sugiro que busque informações sobre Estruturas de Dados Dinâmicas, como Pilhas, Filas, e Listas.

Para este seu problema especificamente, sugiro que foque em Listas Ligadas.

Boa sorte.

  • Curtir 1

Compartilhar este post


Link para o post
Compartilhar em outros sites

Só mais uma dúvida, como faço para guardar os cadastros feitos e depois consulta-los? eu formatei o programa e ele ficou assim:

#include <stdio.h>
#include <stdlib.h>
#define max 2

//Defininddo as Variáveis Globais.
int i;
//Estrutura de Voo.
struct voo{
int numeroVoo[max];
char dataVoo[max][8];
char horarioVoo[max][5];
char aeroSaida[max][50];
char aeroChegada[max][50];
int rota[max];
char tempoVoo[max][5];
int passageirosBordo[max];
};

//Cabeçalho das Funções.
void menu();
void cadastrarVoo();
void consultarVoo();
void removerVoo();
struct voo *ponteiro;

//Função de MENU.
void menu(){
int opMenu;

printf("\n\n\t_________________________");
printf("\n\t MENU PRINCIPAL");
printf("\n\t ESCOLHA SUA OPCAO");
printf("\n\t------------------------\n\n");

printf("\n\t1- CADASTRAR VOO.");
printf("\n\t2- CONSULTAR VOO.");
printf("\n\t3- REMOVER VOO.");
printf("\n\t4- SAIR.\n\n");
printf("\n\tOPCAO: ");
scanf("%d",&opMenu);
system("cls");
switch (opMenu){
case 1:
cadastrarVoo();
break;
case 2:
consultarVoo();
break;
case 3:
removerVoo();
break;
case 4:
printf("\n\n\tVOCE FOI DESLOGADO\n\n");
break;
default:
printf("\n\tOPCAO INVALIDA, TENTE NOVAMENTE\n\n");
system("pause");
system("cls");
menu();
break;
}
}

//Função de Cadastro de Voo.
void cadastrarVoo(){
int opCadastro;
do{
ponteiro = (struct voo *)malloc (sizeof(struct voo));

printf("\n\n\t________________________");
printf("\n\t MENU CADASTRAR VOO.");
printf("\n\t------------------------\n\n");

printf("\n\tNUMERO DO VOO: ");
scanf("%d",&ponteiro->numeroVoo[i]);
printf("\tDATA DO VOO: ");
scanf("%s",ponteiro->dataVoo[i]);
printf("\tHORARIO DO VOO: ");
scanf("%s",ponteiro->horarioVoo[i]);
printf("\tAEROPORTO DE SAIDA: ");
scanf("%s",ponteiro->aeroSaida[i]);
printf("\tAEROPORTO DE CHEGADA: ");
scanf("%s",ponteiro->aeroChegada[i]);
printf("\tROTA: ");
scanf("%d",&ponteiro->rota[i]);
printf("\tTEMPO ESTIMADO DO VOO: ");
scanf("%s",ponteiro->tempoVoo[i]);
printf("\tQNT DE PASSAGEIROS: ");
scanf("%d",&ponteiro->passageirosBordo[i]);
system("cls");
printf("\n\n\t1- CADASTRAR OUTRO VOO");
printf("\n\t2- VOLTAR AO MENU\n\n");
printf("\tOPCAO: ");
scanf("%d",&opCadastro);
system("cls");
}
}
while(opCadastro!=2);
system("cls");
menu();
}

//Função de Consulta Voo.
void consultarVoo(){
int opConsultar;
printf("\n\n\t________________________");
printf("\n\t MENU CONSULTAR VOO.");
printf("\n\t------------------------\n\n");

printf("\n\tDIGITE O NUMERO DO VOO\n");
printf("\n\tNUMERO DO VOO: ");
scanf("%d",&opConsultar);
if(ponteiro->numeroVoo[i]!=opConsultar){
printf("\n\tREGISTRO DE VOO NAO ENCONTRADO");
printf("\n\t TENTE NOVAMENTE\n\n");
system("pause");
system("cls");
consultarVoo();
}
else{
printf("\n\n\tNUMERO DO VOO ENCONTRADO!!!\n\n");
printf("\n\t------------------------------------------------");
printf("\n\tNUMERO DO VOO:%d ",ponteiro->numeroVoo[i]);
printf("\n\tDATA DO VOO:%s ",ponteiro->dataVoo[i]);
printf("\n\tHORARIO DO VOO:%s ",ponteiro->horarioVoo[i]);
printf("\n\tAEROPORTO DE SAIDA:%s ",ponteiro->aeroSaida[i]);
printf("\n\tAEROPORTO DE CHEGADA:%s ",ponteiro->aeroChegada[i]);
printf("\n\tROTA:%d ",ponteiro->rota[i]);
printf("\n\tTEMPO ESTIMADO DE VOO:%s ",ponteiro->tempoVoo[i]);
printf("\n\tQNT DE PASSAGEIROS:%d ",ponteiro->passageirosBordo[i]);
printf("\n\t------------------------------------------------\n\n");
printf("\n\t TECLE ENTER PARA RETORNAR AO MENU...\n\n\n");
system("pause");
system("cls");
menu();
}
}

//Função de Remover Voo.
void removerVoo(){
printf("\n\n\t________________________");
printf("\n\t MENU REMOVER VOO.");
printf("\n\t------------------------\n\n");

printf("\n\tDIGITE O NUMERO DO VOO QUE DESEJA REMOVER");
printf("\n\tNUMERO DO VOO: ");
}



int main(int argc, char *argv[])
{
menu(); //Chamando função de MENU.

system("PAUSE");
return 0;
}

Compartilhar este post


Link para o post
Compartilhar em outros sites

Uma lista duplamente ligada/encadeada em C é implementada com estruturas que possuem ponteiros para outras estruturas, geralmente nomeadas próxima e anterior, criando a ideia de uma lista.

A partir de um elemento qualquer da lista, todos os outros podem ser encontrados. Isto porque estão todos "ligados". A imagem a seguir descreve esta relação:

c+program+of+doubly+linked+list-+delete+-+inser.png

O esqueleto de um programa que utiliza uma lista duplamente encadeada (ou duplamente ligada) para realizar o que você deseja é o seguinte:


#include <stdlib.h>

typedef struct {
int numeroDoVoo;

voo *proximo;
voo *anterior;
} voo;

voo primeiroVoo;
voo ultimoVoo;
voo *listaDeVoos;

(voo*) adicionaNovoVoo( voo* vooAnterior, int num )
{
voo *novoVoo = malloc( 1 * sizeof voo );

if( novoVoo == NULL )
return -1; // Erro na alocação de memória

novoVoo->numeroDoVoo = num;
novoVoo->proximo = NULL;
novoVoo->anterior = vooAnterior;

if( vooAnterior == NULL )
primeiroVoo = *novoVoo;

ultimoVoo = *novoVoo;

return novoVoo;
}

void menu()
{
int num;

// Esta é a parte do menu de adicionar vôos.
printf( "Digite o numero do voo para cadastro: " );
scanf( "%d", &num );

listaDeVoos = adicionaNovoVoo( listaDeVoos, num );
}

int main()
{
listaDeVoos = NULL;
listaDeVoos->proximo = NULL;
listaDeVoos->anterior = NULL;

menu();

limpaLista();
return EXIT_SUCCESS;
}
#include <stdio.h>

Sempre que um novo vôo é adicionado, o ponteiro listaDeVoos vai apontar para o novo voo que foi adicionado. As variáveis primeiroVoo e ultimoVoo apontam, sempre, para os primeiro e último vôos que foram adicionados ao sistema.

Para você fazer uma varredura por todos os vôos, pode fazer o seguinte:

voo *vooIterator;
for( vooIterator = &primeiroVoo; vooIterator != &ultimoVoo; vooIterator = vooIterator->proximo )
{
// Faça algo aqui com o ponteiro vooIterator. Por exemplo, para que todos os vôos tenham seu número incrementado em uma unidade:
vooIterator->num++;
}

Ele inicia na primeira lista e, até chegar à última, vai passando de uma lista para outra, através do ponteiro vooIterator.

Para apagar o registro de um vôo do sistema:

void apagaRegistroDeVoo( voo* vooASerApagado )
{
voo *ant, *prox;

if( vooASerApagado == NULL )
return -1; // Erro -- Não se pode apagar um vôo não existente

ant = vooASerApagado->anterior;
prox = vooASerApagado->proximo;

ant->proximo = prox;
prox->anterior = ant;

free( vooASerApagado );
}

Primeiramente, o programa retira o registro da lista, fazendo com que os elementos que eram ligados a ele se liguem entre si e deixem ele de lado. A seguir, a memória que havia sido reservada para ele é liberada.

IMPORTANTE: Toda a memória reservada com malloc (e afins) deve ser liberada quando não for mais ser utilizada ou, na pior das hipóteses, ao encerrar o programa.

É um bom costume se definir uma função de limpeza da lista e fazer com que ela seja chamada logo antes do return da função principal. Eu deixei a função lá, mas não a defini. Deixo isso de desafio para você!

Esta é a base para o que você quer fazer. Veja se você consegue implementar a partir destas ideias.

Caso algo não tenha ficado claro, basta perguntar.

  • Curtir 1

Compartilhar este post


Link para o post
Compartilhar em outros sites

Crie uma conta ou entre para comentar

Você precisar ser um membro para fazer um comentário

Criar uma conta

Crie uma nova conta em nossa comunidade. É fácil!

Crie uma nova conta

Entrar

Já tem uma conta? Faça o login.

Entrar agora





Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas publicações sobre tecnologia do Brasil. Leia mais

Direitos autorais

Não permitimos a cópia ou reprodução do conteúdo do nosso site, fórum, newsletters e redes sociais, mesmo citando-se a fonte. Leia mais

×