arfneto

Pense que a média é o quociente de uma soma pelo número de parcelas. São só duas variáveis se puder ler direto para a soma. Ou 3 se precisar ler em uma variável primeiro: a parcela, a soma e o total de parcelas. Mesmo com meio milhão de notas adicionado 1 minuto depois E quem disse para ler as cinco de uma vez? Só precisa da média então depois de somadas as parcelas não servem de nada...

Olá Imagino que tenha feito progresso com seu programa. Voltei a escrever só pra te mostrar o outro lado, o lado final disso, já que eu não tinha escrito nada sobre isso e acho que você não entendeu o sentido do que eu estava tentando explicar. Supondo por um momento que seguimos o caminho de que falei, acreditando que uns 80% do programa estão já escritos por meio daquelas funções cujo código te mostrei... Restariam poucas dúvidas. Temos até as funções que leêm do disco e gravam no disco uma playlist. Então podemos copiar disso também. Mas e o importante menu? Pois é: um programa de menu nada precisa saber sobre a playlist. Quem diria? Eu tentei dizer. Veja o programa abaixo: #define _CRT_SECURE_NO_WARNINGS #include <stdio.h> int show(); // as funcoes do menu void m_apagar(); void m_excluir(); void m_incluir(); void m_mostrar(); void m_salvar(); void m_somar(); void m_trocar(); int main(int argc, char** argv) { char c = 0; do { c = show(); switch (c) { case '0': return 0; case '1': m_incluir(); case '2': m_excluir(); break; case '3': m_mostrar(); break; case '4': m_apagar(); break; case '5': m_salvar(); break; case '6': m_somar(); break; case '7': m_trocar(); break; default: break; }; // switch() } while (c != 'q'); // while() return 0; }; // main() int show() { // temos pressa entao o menu vem de menu.txt e vai para tela const char* arq_entrada = "menu.txt"; char linha[71]; char* lido = NULL; char opt = 0; FILE* entrada; entrada = fopen(arq_entrada, "r"); if (entrada == NULL) { printf("Erro tentando abrir menu '%s'\n", arq_entrada); return 'q'; }; // if() // agora le os caras e poe na tela do { lido = fgets(linha, 70, entrada); if (lido != NULL)printf("%s", linha); } while (lido != NULL); fclose(entrada); printf("Sua Opcao:_"); opt = getc(stdin); return opt; }; // show() void m_apagar() {}; void m_excluir() {}; void m_incluir() {}; void m_mostrar() {}; void m_salvar() {}; void m_somar() {}; void m_trocar() {}; Nada especial. Considere um arquivo assim: 1 - Incluir faixa 2 - Excluir faixa 3 - Mostrar PlayList 4 - Apagar PlayList 5 - Salvar PlayList em arquivo 6 - Acrescentar Musicas a partir do arquivo (+) 7 - Substituir playlist pelo conteudo do arquivo x - inventa +10 musicas 0 - Encerrar Então se chamar esse arquivo de "menu.txt" e colocar no diretório onde está rodando seu programa ele vai mostrar o tal menu. Claro que esse programa foi copiado da função que lê uma playlist do disco. E você pode ir terminando o programa inserindo chamadas às funções já testadas. É claro que vai funcionar. É por isso que a gente usa computadores afinal. Quando inserir todas as funções o programa vai estar claro pronto. Exemplo: como seria mostrar uma playlist na tela? Trivial: o cara vai teclar 3 e o menu vai chamar a opção m_mostrar() e tudo isso foi escrito em minutos usando recortar e colar. Essas rotinas nem precisariam estar no mesmo arquivo, como já expliquei. Então não precisaria sequer editar o programa principal. Basta ir onde está m_mostrar() e trocar por algo assim: int m_mostrar(Lista* playlist) { int n = 0; cls(); n = listar(playlist); if (n > 0) printf("[%d musica (s)]\n\n", n); pause(); return n; }; // m_mostrar() Como listar(playlist) já foi escrita e testada --- você tem um código --- dias atrás é claro que vai funcionar. Como ela já devolve o número de músicas é claro que eu posso mostrar na tela. Notou que não precisa nem compilar o programa para alterar o menu? Basta editar o arquivo. Quer fazer igualzinho seu professor disse? Quando estiver satisfeito com o menu apenas recorte e cole o texto do arquivo em vários printf() em outra função e troque o código... Claro que não seria esperto. Como te disse e tentei mostrar, aquele código nem está bom.

Isso faz parte do C standard há mais de 20 anos. No gcc apenas NÃO use a opção -ansi. Ou melhor: defina nas opções padrão do compilador -std=c99. Sem querer entrar em questões religiosas aqui e saindo um pouco do tópico, sugiro usar um ambiente moderno e mais sério. Code::blocks na prática nem é mais atualizado, pelo que sei. Fuja disso. De memória: em Windows usaria Eclipse, NetBeans, Visual Studio ou Visual Studio Code. Em Windows --- depois que versões grátis de Visual Studio começaram a ser oferecidas pela Microsoft --- fica fácil escolher: a chance de seu empregador ou universidade desenvolver software para Windows nesse ambiente, que é da mesma empresa que escreve o tal Windows, deve ser grande... Mas Visual Studio é um ambiente gigante. Claro que não precisa usar nada além de digitar seu programa e apertar F5 para rodar, F7 para compilar tudo e tal. Mas o tamanho do ambiente pode ser um pouco intimidador no início. O download é grande, o micro pode ficar lento se tiver pouca memória ou um disco muito antigo. Mas é o padrão da indústria. E da academia. Para Windows. Por outro lado, Visual Studio Code é grátis,e usando o compilador gcc --- download aqui --- você pode escrever programas que rodam em Linux e Mac e Windows igualzinho. E é bem atual. A versão de download do gcc para Windows foi atualizada pela última vez em 20 de março. De 2020. Tipo ontem, já que estou escrevendo em 21 de março. E a interface é bem rápida e moderna. Como o Windows inclui desde 2018 um kernel Linux grátis e distribuições como Kali, Ubuntu e SUSE instaláveis com um click direto da loja e esse IDE --- sim, esse: IDE é uma abreviatura de ambiente --- e um terminal para aplicações de console compatível com a console dos '80 do Unix mas com aceleração gráfica via GPU de hoje, é uma aposta fácil. E o ambiente é atualizado com frequência.

Esse é um enunciado bem besta. Nada diz sobre as consultas. Apenas usar as informações. Então você pode ler de um arquivo umas consultas ou colocar umas a olho e pronto. Item (sem letra) ok. Não precisa criar consultas. Não está no enunciado. Não que isso acrescente muito já que o registro de consultas tem 5 campos apenas Médicos e pacientes só tem 4 campos. E o item (a) só fala em inclusões. Então seria ler 4 campos do teclado e colocar na lista correspondente. excluir um médico? Você pega o tal Cod_Medico e vai lá na lista de Consultas e vê se tem uma com o Cod_Medico dele, e se tiver deixa pra la. Escreva algo na tela pra ficar claro que você viu, tipo O Medico 'cod_Medico' tem consulta em 'Data' e entao nao pode ser excluido e não caia na tentação ingênua de por acentos e tal. Não faz parte do problema. (b) mostrar as consultas que estão numa lista de consultas? E nao fala em ordem nem nada. Então não precisam estar ordenadas. Apenas um loop: passe por todas as consultas. Apenas um if. Liste apenas as que tem 'Data' igual a que o usuário especificou. (c) Agora isso não entendi mesmo: #define QTDE 1 // que pretende com um unico medico um unico paciente e uma so consulta? dadosM medicos[QTDE]; dadosP pacientes[QTDE]; dadosC consultas[QTDE]; int qMedicos = 0; // deve imaginar que vai precisar saber quantos medicos tem ja int qPacientes = 0; // e pacientes int qConsultas = 0; // e consultas Não vai muito longe com QTDE = 1... Use um contador para cada tabela e quando incluir alguém incremente o correspondente. Quando excluir faça o óbvio e subtraia. Assim sempre saberá até onde procurar algo nas listas. Note que pelo enunciado só pode excluir médicos que não tenham consultas... Pode ser uma pegadinha ou só uma bobagem de quem escreveu, mas o enunciado fala explicitamente em "consultas realizadas em uma data escolhida pelo usuário" e isso quer dizer passado. Já realizadas. Lucas, você tem um livro-texto? uma apostila? Você sabe até o que leu no livro. Até o que aprendeu. Ninguém vai te impedir de aprender, exceto talvez você mesmo. Deve imaginar que nas páginas que você ainda não leu do livro tenha coisas que vão tornar seu trabalho mais fácil e não mais difícil. Não me leve a mal, mas em especial nesse campo essa ideia de "ainda não aprendi isso" não é nada saudável. Em geral os caras só pagam a gente pra fazer o que a gente não sabe ainda. Ou pagam bem pouco para fazer o bem simples.

Compilar não quer dizer nada. Basta apertar o botãozinho que roda o programa e pode ver isso em muitos, muitos casos. E passar dias fazendo um programa trivial que já podia estar pronto, apenas por misturar as coisas e ir pelo caminho errado é claro possível. Trata-se do livre arbítrio afinal. O que eu te expliquei não vai mudar o seu programa. Nào sei mais como explicar isso. Apenas ele fica pronto num instante. E depois você insere as funções no seu precioso menu. Não existe nada de especial em um menu. Não vai criar nada. Só vai perder seu tempo. Devido ao contexto atual de epidemia estou meio sem trabalho. E resolvi digamos estender meu trabalho voluntário nos foruns. E nesse tempo já te expliquei mais de uma vez que não é uma mudança de modelo. É só mais esperto. Você faz seu programa primeiro. Depois vê essas coisas de menu e telinha. Não importa se seu professor diz o contrário. Ou seu instinto. As funções que te mostrei e talvez as que você escreveu funcionam com ou sem o menu. Parece que não leu os exemplos também. Em relação à sua pergunta: "como acrescentar mais dados" acho que já respondi duas vezes. E mostrei o código. Você não está lendo. Acha o texto muito longo? De novo, copiado do outro post, dentro do seu próprio programa: int m, s; char Musica[TAMANHO]; char Cantor[TAMANHO]; Lista* HEAD = NULL; printf("Qual musica Gostaria de Adicionar? "); gets_s(Musica); while ((c = getchar()) != '\n' && c != EOF) {} //USADO PRA LIMPAR OS DADOS printf("Qual o nome do Cantor/Artista dessa musica? "); gets_s(Cantor); while ((c = getchar()) != '\n' && c != EOF) {} printf("Quantos minutos de duracao?"); scanf_s("%d", &m); while ((c = getchar()) != '\n' && c != EOF) {} printf("Quantos segundos de duracao?"); scanf_s("%d", &s); while ((c = getchar()) != '\n' && c != EOF) {} strcpy(outra_musica.Artista, Cantor); strcpy(outra_musica.Nome, Musica); outra_musica.min = m; outra_musica.seg = s; // poe na lista Lista* playlist = NULL; int n = listar(playlist); // vazia playlist = inserir((void*)&outra_musica, playlist); Pela terceira vez vou te mostrar o protótipo de gets_s(0 direto da documentação oficial char *gets_s( char *buffer, size_t sizeInCharacters ); wchar_t *_getws_s( wchar_t *buffer, size_t sizeInCharacters ); Você continua usando com um único parâmetro como era na extinta (em 2011) gets() Quando as funções estão funcionando você insere no seu precioso menu. Não antes. Não durante. É bobagem. E te mostrei. O esperto é algo como fabrica() devolver uma música prontinha, preenchida e única a cada chamada. Pena você não entender isso. Não sei mais como te explicar. Mostrar eu já mostrei. O programa que te mostrei é talvez 80% do que precisa. E o resto já até te mostrei os protótipos... E pode usar o programa abaixo que lê e grava no disco uma playlist. Por falar em protótipos, veja como pode ser simples ler as musicas do disco: NNN: MMMMMMMMMMMMMMM AAAAAAAAAAAAAAA MM:SS 1: Musica 010 Artista 010 00:21 2: Musica 009 Artista 009 07:02 3: Musica 008 Artista 008 04:42 4: Musica 007 Artista 007 09:07 5: Musica 006 Artista 006 08:52 6: Musica 005 Artista 005 07:50 7: Musica 004 Artista 004 09:07 8: Musica 003 Artista 003 05:50 9: Musica 002 Artista 002 09:33 10: Musica 001 Artista 001 01:35 E gravar de volta no disco. #define _CRT_SECURE_NO_WARNINGS #include <stdio.h> #include <stdlib.h> #include <string.h> int main() { const char* mascara = "%15c%*1c%15c%*1c%2d%*1c%2d%*1c"; const char* arq_entrada = "gabarito.txt"; const char* arq_saida = "saida.txt"; int n = 0; FILE* entrada; FILE* saida; // o que vai ler de cada linha char musica[16]; char artista[16]; int min = 0; int seg = 0; // zera os campos de musica e artista memset(musica, 0, 16); memset(artista, 0, 16); entrada = fopen(arq_entrada, "r"); if (entrada == NULL) { printf("Erro tentando abrir '%s'\n", arq_entrada); return -1; }; // if() saida = fopen(arq_saida, "w"); if (saida == NULL) { printf("Erro tentando criar '%s'\n", arq_saida); return -1; }; // if() printf("NNN: MMMMMMMMMMMMMMM AAAAAAAAAAAAAAA MM:SS\n\n"); int pos = 1; while (!feof(entrada)) { n = fscanf(entrada, mascara, musica, artista, &min, &seg); if (n != 4) return -1; printf( "%3d: %15s %15s %02d:%02d\n", pos, musica, artista, min, seg ); pos = pos + 1; // grava no arquivo de saida no mesmo exato formato fprintf(saida, "%15s %15s %02d %02d\n", musica, artista, min, seg); } // while() fclose(entrada); fclose(saida); return 0; }; // main() Esse programa faz isso em um único loop. Certinho. Foi testado com os dados do próprio programa. Gerados pela tal fabrica() de músicas. Como já temos a rotina que insere e esse programa lê os 4 campos da playlist, é bem óbvio que já temos como ir lá no --- único --- loop do programa acima e chamar a rotina que insere. Isso seria claro carregar uma playlist a partir de um arquivo, como está no enunciado.... Como já temos a função que mostra a playlist na tela, basta copiar essa função e alterar onde ela mostra na tela para gravar no disco, como está no programa aqui que já funciona. E em 15 minutos seu programa tem as funções que leem e gravam a playlist no disco. E aí você põe no menu. É assim que a coisa anda. Pense nisso. Quanto à sua pergunta, como inserir, está acima, de novo.

Então só faltam as opções de editar a playlist e, se você quiser a versão completa: no início da execução ver se tem um playlist.txt no diretorio corrente e tentar ler as musicas de la no final do programa gravar a playlist nesse arquivo Pode escrever então 4 funções no programa "teste" // // fase "2" :) // Lista* apagar_da_playlist(int musica); Lista* inserir_na_playlist(struct no* musica); Lista* inserir_do_arquivo(char* arquivo); Lista* gravar_no_arquivo(char* arquivo); Já temos a rotina que insere na playlist então criar a partir do arquivo é trivial: bastar ler as músicas, montar a estrutura e chamar insere(). Não tem o que testar, porque ela já funciona. E aquele arquivo "gabarito.txt" está de volta: basta digitar igualzinho no arquivo de entrada as musicas e pronto. Tem até aquelas primeiras linhas do arquivo mostrando o número das colunas para você posicionar os dados. gabarito.txt copiado do outro post * 1 * 2 * 3 * 4 * 5 * 6 123456789012345678901234567890123456789012345678901234567890 # faixa artista HH:MM 000: 123456789012345 123456789012345 MM:SS 000: 123456789012345 123456789012345 MM:SS 000: 123456789012345 123456789012345 MM:SS 000: 123456789012345 123456789012345 MM:SS 000: 123456789012345 123456789012345 MM:SS Editado para o que precisa agora FFFFFFFFFFFFFFF AAAAAAAAAAAAAAA MM SS FFFFFFFFFFFFFFF AAAAAAAAAAAAAAA MM SS FFFFFFFFFFFFFFF AAAAAAAAAAAAAAA MM SS FFFFFFFFFFFFFFF AAAAAAAAAAAAAAA MM SS FFFFFFFFFFFFFFF AAAAAAAAAAAAAAA MM SS FFFFFFFFFFFFFFF AAAAAAAAAAAAAAA MM SS FFFFFFFFFFFFFFF AAAAAAAAAAAAAAA MM SS FFFFFFFFFFFFFFF AAAAAAAAAAAAAAA MM SS Podemos deixar os espaços para facilitar a visualização. O programa é nosso afinal. E podemos diminuir o tamanho para algo fácil de ler e digitar, tipo 15 colunas e não 50 ou 200 para os campos de artista e faixa Continuando com a parada de não trabalhar a toa, eis a saída do programa, copiada do outro tópico, para 10 músicas: # faixa artista HH:MM 1: Musica 010 Artista 010 00:21 2: Musica 009 Artista 009 07:02 3: Musica 008 Artista 008 04:42 4: Musica 007 Artista 007 09:07 5: Musica 006 Artista 006 08:52 6: Musica 005 Artista 005 07:50 7: Musica 004 Artista 004 09:07 8: Musica 003 Artista 003 05:50 9: Musica 002 Artista 002 09:33 10: Musica 001 Artista 001 01:35 Se colocar isso no arquivo "entrada.txt" e ler de volta igualzinho essa parte do seu programa estará aprovada sem stress: nada de ficar na frente do terminal inventando musicas 5 minutos para cada teste... Editado para ficar como vai estar no arquivo no disco Musica 010 Artista 010 00:21 Musica 009 Artista 009 07:02 Musica 008 Artista 008 04:42 Musica 007 Artista 007 09:07 Musica 006 Artista 006 08:52 Musica 005 Artista 005 07:50 Musica 004 Artista 004 09:07 Musica 003 Artista 003 05:50 Musica 002 Artista 002 09:33 Musica 001 Artista 001 01:35 Basta gravar no disco e tentar ler É óbvio que não precisa usar o seu programa para testar isso, certo? O programa inteiro com aquelas funções todas. Assim é que se trabalha na prática com essas coisas: apenas copie o que precisa em termos de declarações para o novo programa. O que? Só aquela struct mesmo :). Para isso existe o conceito de header, o tal arquivo .h. E lá você escreve as funções que leem do arquivo e gravam no arquivo a playlist. Depois você põe as duas funções novas testadas no arquivo. Sabendo que vão funcionar... Como testar isso? Pois é: apenas leia e grave um arquivo desses com suas funções. O arquivo de saída tem que ser igualzinho o de entrada. Como compara? Pode usar ser tão fácil como escrever Certo?

Olá! Parece ter vários problemas em seu programa. Isso compila em seu ambiente? Que sistema operacional e IDE/compilador você usa? Não entendi por exemplo essa: void inserir(t_ponto* ini_ponto); Se com essa função pretende inserir algo na lista do tipo t_ponto como vai ser isso? A maneira convencional de fazer isso seria Lista* inserir(void* elemento, Lista* lista); Mas poderia ser algo como Lista* inserir( int elemento, Lista* lista ); No seu caso de usar apenas um int. Tem gente que escreve Lista* inserir( int elemento, Lista** lista ); passando o endereço do ponteiro e o elemento a inserir De volta ao seu programa: Do modo como declarou parece não ter nem um nem outro. Como passou só o valor do ponteiro e não retornou nada ele vai sumir lá dentro da função. E o elemento a inserir seria qual? Não leia valores dentro de uma rotina que trata sua estrutura de dados, a sua lista. Pense bem: só vai perder seu tempo. Só vai poder testar isso de modo interativo, por exemplo. Não use isso. Postei hoje uma solução pra lista que funciona ok, e um exemplo em C++ e outro em java nesse tópico. Veja lá o que expliquei e pode te ajudar. E tem um programa C com funções. Que funcionam. Sugiro muito ler esse post ou a discussão toda. Afinal é um programa de lista em C mesmo De volta a seu código para inserir() t_ponto *proximo_ponto; if (ini_ponto == NULL) exit(1); printf("Digite x:"); scanf("%d",&proximo_ponto->x); proximo_ponto -> proximo = (t_ponto*)malloc(sizeof(t_ponto)); proximo_ponto = proximo_ponto->proximo; Seu compilador aceitou isso? Acabou de declarar proximo_ponto, um ponteiro. E espera atribuir algo a proximo_ponto->proximo? na linha seguinte? claro que vai dar erro. Não devia compilar na verdade. Não acha confusa essa nomenclatura para suas variáveis? proximo_ponto = proximo_ponto->proximo; por exemplo? buscar() t_ponto* buscar(int valor, t_ponto* ini_ponto){}; Você declarou valor como parâmetro para depois tentar ler via scanf()? Sério? Vou dizer a mesma coisa de antes: tire isso daí. Passe o valor que quer buscar como parâmetro e retorne o endereço dele. Só isso. remover() Fez a mesma coisa que em buscar. Sugiro muito mudar. Sem scanf(). Sem printf() main() main(0 deve ser a primeira função de seu programa. Em especial se espera que outros venham a ler seu programa. Discuti isso em outro tópico aqui hoje. (Durante essas épocas de isolamento passei por muitos tópicos no forum :D) Não use menu em programas que ainda não estão funcionando. Nem leitura do teclado. Só vai atrasar tudo.

Não exatamente aleatória porque vai reproduzir sempre a mesma sequência. Então é como se um usuário voltase sempre e digitasse tudo de novo até o seu programa funcionar... Tudo que você precisa fazer é terminar as funções. As funções objetivas que estão faltando. Não insista nesse lance do menu que só vai te atrasar. Eu já te mostrei onde colocar isso depois quando estiver pronto. Esse "teste" é o seu programa de fato. Apenas implemente as outras funções e depois coloque as chamadas de função --- já testadas --- no menu. Não faça ao contrário. Já te expliquei porque. Programe as coisas importantes, como o gerenciamento da playlist. Imagino que tenha uma especificação... Coisas como criar playlist remover playlist apagar uma musica da lista mudar a ordem as músicas Coisas objetivas. Funções do programa. Vou reproduzir aqui o seu código de inserir por exemplo, com as funções: int m, s; char Musica[TAMANHO]; char Cantor[TAMANHO]; Lista* HEAD = NULL; printf("Qual musica Gostaria de Adicionar? "); gets_s(Musica); while ((c = getchar()) != '\n' && c != EOF) {} //USADO PRA LIMPAR OS DADOS printf("Qual o nome do Cantor/Artista dessa musica? "); gets_s(Cantor); while ((c = getchar()) != '\n' && c != EOF) {} printf("Quantos minutos de duracao?"); scanf_s("%d", &m); while ((c = getchar()) != '\n' && c != EOF) {} printf("Quantos segundos de duracao?"); scanf_s("%d", &s); while ((c = getchar()) != '\n' && c != EOF) {} strcpy(outra_musica.Artista, Cantor); strcpy(outra_musica.Nome, Musica); outra_musica.min = m; outra_musica.seg = s; // poe na lista Lista* playlist = NULL; int n = listar(playlist); // vazia playlist = inserir((void*)&outra_musica, playlist); É só isso. Mas não deve usar isso agora. Entenda isso. Depois que programar o resto você põe isso em 15 minutos. E não tem o que testar... É só preencher um formulário.... Tem uma especificação desse programa? Um enunciado? Já te disse que a declaração de get_s está errada, certo? no primeiro parágrafo do primeiro post. E comentei sobre usar scanf() E get_s() em seguida, certo?

Sim. Eu falei disso porque se está em outra rede na sua rede local, como uma subnet or exemplo, os pacotes podem não passar por seja o que for o gateway porque os broadcasts ficam na rede local apenas, a menos de programações especiais para retransmiti-los... Isso é o primeiro nível de teste. Desligou aqueles recursos de fast-switching do windows nas opções de energia? Desativou hibernar e suspender pra testar? Testou com outro teamviewer na rede local?

Imagino que tenha lido o Manual do TeamViewer sobre WOL. Leu? Testou isso na rede local usando outro micro ou um celular? Pode ser que o sinal esteja ativo mas os LED não. Para usar a partir de outra rede precisa garantir a conectividade entre essas redes. A existência de rotas. Para usar via internet tem mais uns passos e talvez precise de algum tipo de programação adicional com as portas. Especialmente se tem mais de um micro na mesma rede que deseja ligar por esse recurso. Está de fato falando de usar a placa de rede que está na placa-mãe certo? Se está usando outra placa, PCI ou PCIx -- isso que chama de "off-board: --- precisa ver se o software para estas placas inclui esse suporte. Não é sempre o caso. Lembro que a grafia correta é "habilitei" e "ressaltar"... Note que BIOS é masculino, já que é um sistema. básico. de entrada e saída. Existe uma pequena chance de ter um jumper na placa-mãe que também tem que habilitar, para que mantenha tensão de até 800mA na placa-mãe quando desligada. Em máquinas como os Optiplex acho que sempre está habilitado mas é algo a conferir. Em geral ficam bem no canto da placa, próximos da fonte de alimentação. Não. Não continua enviando pacotes. Apenas podem responder a pacotes WOL --- os tais magic packets --- em tráfego na rede e que contenham seu endereço MAC repetidos 16x. Nada mais. Responder ligando a força apenas. Não há resposta a WOl via rede. E não é o caso da maioria das máquinas. Pelo contrário. Pode testar em sua rede por exemplo. São vários passos pra isso funcionar. Curiosamente era mais fácil há 30 anos atrás... E tinha a opção de ligar também via telefone WOR que era útil em alguns casos.

Você pode pegar esse programa e colocar as outras funções. E depois colocar o menu e fica tudo pronto... A função que apaga a lista --- não uma música --- é a que tem mais chance de dar erro. pode usar algo assim que funciona: Lista* apagar(Lista* l) { // apagar e como listar() printf("***** apagar() *****\n\n"); if (l == NULL) { printf("Lista nao iniciada\n"); return -1; } if (l->musica == NULL) { printf("Lista vazia\n"); return NULL; } // nao esta vazia entao varre a lista e apaga // os caras todos Lista* aux = l; Lista* temp = NULL; do { temp = aux->proxima; // salva o endereco da proxima free(aux->musica); // apaga essa musica free(aux); // apaga o no da lista aux = temp; } while (aux != NULL); // do-while() return NULL; }; // apagar() Entendeu o que expliquei? Entendeu o lance da tal fabrica() de musicas?

Claro. Claro que não. Esse programa começa assim: Lista* playlist = NULL; Então é lógico que as músicas não "estão no programa". O programa que te mostrei tem tipo 6 linhas Lista* playlist = NULL; int n = listar(playlist); // vazia playlist = inserir((void*)fabrica(1), playlist); // primeira listar(playlist); // uma musica playlist = inserir((void*)fabrica(1), playlist); // outra listar(playlist); // duas musicas agora E cria a lista e insere as tais duas musicas # faixa artista HH:MM 1: Musica 002 Artista 002 09:29 2: Musica 001 Artista 001 09:33 Como poderia ser um modelo? O que te mostrei é um modelo. Se você preferir pode sim claro digitar os 8 campos das duas músicas e as opções do seu menu. Não faz diferença exceto o tempo que vai perder e a dificuldade em repetir um teste. Eu sempre posto isso nesse forum e explico isso pra um grande número de pessoas: não misture as coisas. Não limpe a tela num programa de teste. Não crie um menu antes das funções estarem ultra-prontas. Não perca seu tempo. Isso não resolve nada. Preste atenção: seu menu vai ler titulo, artista e duração da faixa. Só isso. Então qual o propósito de efetivamene ficar lendo isso? Veja (em seu código): printf("Qual musica Gostaria de Adicionar? "); gets_s(Musica); while ((c = getchar()) != '\n' && c != EOF) {} //USADO PRA LIMPAR OS DADOS printf("Qual o nome do Cantor/Artista dessa musica? "); gets_s(Cantor); while ((c = getchar()) != '\n' && c != EOF) {} printf("Quantos minutos de duracao?"); scanf_s("%d", &m); while ((c = getchar()) != '\n' && c != EOF) {} printf("Quantos segundos de duracao?"); scanf_s("%d", &s); while ((c = getchar()) != '\n' && c != EOF) {} InserirInicio(Musica, Cantor, m, s); E a tal struct (em seu código): struct Musicas { char Nome[TAMANHO]; char Artista[TAMANHO]; int min, seg; struct Musicas* prox; } *Head; Se leu o que eu escrevi deve ter entendido que assim não é bom. E visto o exemplo de declaração. Mas o que importa é que está lendo exatamente os campos que tem na struct. E na ordem. Para que? De novo em seu código: int m, s; char Musica[TAMANHO]; char Cantor[TAMANHO]; Head = NULL; Essas são as variáveis que você leu. Bem óbvio: uma para cada campo da struct. Se você tem a função que eu te mostrei Lista* inserir(void* musica, Lista* playlist); // por exemplo E leu essas coisas, então simplesmente aloca uma musica, preenche e insere. Não é o que está no programa que te mostrei? Trocando os nomes ficaria (depois de ler os valores, claro): // cria uma outra musica Musica outra_musica; strcpy(outra_musica.Artista, Cantor); strcpy(outra_musica.Nome, Musica); outra_musica.min = m; outra_musica.seg = s; // poe na lista Lista* playlist = NULL; int n = listar(playlist); // vazia playlist = inserir((void*)&outra_musica, playlist); É isso. Pense de outro modo: se você tivesse uma rotina --- que já mostrei aqui em muitos casos --- que devolvesse um elemento prontinho você poderia seguir sua vida com seu programa sem perder tempo. Vamos imaginar uma função da hora declarada assim: Musica* fabrica(); // devolve uma musica, unica e preenchida Cada vez que eu chamo esse trem vem uma struct Musica preenchida. Sempre diferente e numeradinha. Já não serve? Agora veja esse sofisticado main() com 5 linhas usando a tal rotina fabrica(): int main() { fabrica(0); // inicia a fabrica de musicas Lista* playlist = NULL; // cria e insere 10 musicas for (int i = 0; i < 10; i = i + 1) playlist = inserir((void*)fabrica(1), playlist); int n = listar(playlist); // 10 musicas? printf("listar() retornou %d\n", n); return 0; }; // main() E veja a saida ***** inserir() ***** ***** inserir() ***** ***** inserir() ***** ***** inserir() ***** ***** inserir() ***** ***** inserir() ***** ***** inserir() ***** ***** inserir() ***** ***** inserir() ***** ***** inserir() ***** ***** listar() ***** # faixa artista HH:MM 1: Musica 010 Artista 010 00:21 2: Musica 009 Artista 009 07:02 3: Musica 008 Artista 008 04:42 4: Musica 007 Artista 007 09:07 5: Musica 006 Artista 006 08:52 6: Musica 005 Artista 005 07:50 7: Musica 004 Artista 004 09:07 8: Musica 003 Artista 003 05:50 9: Musica 002 Artista 002 09:33 10: Musica 001 Artista 001 01:35 listar() retornou 10 Pois é: criou a lista com 10 músicas e listou com sucesso. E se você quiser reptir o teste com as mesmas músicas é só rodar o programa de novo. A matemática garante que vão ser geradas as mesmas músicas, até a mesma duração de todas as faixas. Quer testar com 1.000 músicas? Mude o parâmetro de 10 para 1000. Agora seria o caso de programar o resto das funções. Entendeu o que estou tentando te mostrar? Eis o programa de teste com a tal fabrica(), uma rotina de 15 linhas: #define _CRT_SECURE_NO_WARNINGS #include <stdio.h> #include <stdlib.h> #include <string.h> #define TAMANHO 15 struct musica { char Nome[TAMANHO]; char Artista[TAMANHO]; int min, seg; }; // musica typedef struct musica Musica; struct no { void* musica; struct no* proxima; }; // no typedef struct no Lista; Musica* fabrica(); Lista* inserir(void*, Lista*); int listar(Lista*); int main() { fabrica(0); // inicia a fabrica de musicas Lista* playlist = NULL; // cria e insere 10 musicas for (int i = 0; i < 10; i = i + 1) playlist = inserir((void*)fabrica(1), playlist); int n = listar(playlist); // 10 musicas? printf("listar() retornou %d\n", n); return 0; }; // main() Musica* fabrica(int parm) { // a cada chamada retorna uma musica novinha static int n = 0; if (parm == 0) { srand(200401); n = 1; return NULL; } Musica* m = (Musica*)malloc(sizeof(Musica)); sprintf(m->Nome, "Musica %03d", n); sprintf(m->Artista, "Artista %03d", n); m->min = rand() % 10; m->seg = rand() % 60; n = n + 1; return m; }; // fabrica() Lista* inserir(void* m, Lista* l) { printf("***** inserir() *****\n"); // cria um elemento Lista* novo = (Lista*)malloc(sizeof(Lista)); novo->musica = m; novo->proxima = l; return novo; }; // inserir() int listar(Lista* l) { int total = 0; Lista* aux = l; printf("***** listar() *****\n\n"); if (l == NULL) { printf("Lista nao iniciada\n"); return -1; } if (l->musica == NULL) { printf("Lista vazia\n"); return 0; } // nao esta vazia entao cria um ponteiro para // o tipo de dados que estamos usando printf( " # faixa artista HH:MM\n\n" ); do { Musica* pM = (Musica*)aux->musica; // a musica total = total + 1; printf( "%3d: %15s %15s %02d:%02d\n", total, pM->Nome, pM->Artista, pM->min, pM->seg ); aux = aux->proxima; } while (aux != NULL); // do-while() printf("\n"); return total; }; // listar() Veja uma parte da saída de um teste para 999 músicas mudando só o 10 para 999 em main(). E claro que esse poderia ser um parâmetro de execução e não precisaria compilar o programa de novo, certo? # faixa artista HH:MM 1: Musica 999 Artista 999 02:53 2: Musica 998 Artista 998 00:38 3: Musica 997 Artista 997 00:01 4: Musica 996 Artista 996 00:47 5: Musica 995 Artista 995 01:47 6: Musica 994 Artista 994 05:07 7: Musica 993 Artista 993 05:47 8: Musica 992 Artista 992 00:05 9: Musica 991 Artista 991 00:19 10: Musica 990 Artista 990 03:06 11: Musica 989 Artista 989 04:48 ... 988: Musica 012 Artista 012 01:16 989: Musica 011 Artista 011 00:19 990: Musica 010 Artista 010 00:21 991: Musica 009 Artista 009 07:02 992: Musica 008 Artista 008 04:42 993: Musica 007 Artista 007 09:07 994: Musica 006 Artista 006 08:52 995: Musica 005 Artista 005 07:50 996: Musica 004 Artista 004 09:07 997: Musica 003 Artista 003 05:50 998: Musica 002 Artista 002 09:33 999: Musica 001 Artista 001 01:35 listar() retornou 999 E se testar com 999 as primeiras 10 músicas serão as mesmas de quando testou com 10... Cantor, Musica, m e s...

A lógica é dividir por 360 e pegar o resto. Essa é a última volta. E o quociente é o número de voltas.... Sim. Igualzinho. É como se girasse pra direita quando negativo e pra esquerda se positivo.

Olá for(i=0; i<10; i++){ vet3[i*2] = vet1; } for(i=0; i<10; i++){ vet3[i*2+1] = vet2; } Não consigo entender o que pretende fazer com o código acima. Só precisa da interseção: vai ter no máximo 10 caras se os vetores forem iguais. Note que os 10 caras podem estar em ordem diferente. Percorra um dos vetores, 1 ou 2, e se e somente se um elemento dele estiver presente no outro você coloca no vetor 3. Só isso. Casos pra pensar, com 5 caras 0 1 2 3 4 4 3 2 1 0 vet3: 0 1 2 3 4 talvez em outra ordem 0 1 1 1 1 1 1 1 1 1 vet3: 1 1 2 3 1 1 2 3 8 8 8 vet3: 2 3 1 2 3 4 5 6 7 8 9 0 vet3: nada

oh... Ele não trabalha pra mim, nem ensina pra mim, nem eu ensino pra ele. Mas o programa não está nada bom. Nada mesmo. Podemos discutir isso outra hora. Existe uma filosofia por trás de como fazer e como não fazer as coisas em cada linguagem. Em especial se você está ensinando ou aprendendo. Uma pena você não ter um livro-texto. Sábia decisão ir por partes. Mas não foi o que fez com o programa... Entendo. Boa decisão usar Visual Studio 2019. Sobre as tais listas ligadas Uma lista encadeada é uma estrutura de dados que a gente usa como camada de abstração, uma ferramenta para representar no programa coisas concretas como uma fila ou uma playlist, como o seu caso. O fato de ser simplesmente ou duplamente ou multiplamente encadeada é irrelevante para o princípio da coisa: É uma lista de coisas e cada coisa aponta para outra de alguma maneira. Nem precisa ter ponteiros por exemplo. Mas precisa ter algum tipo de encadeamento Num mundo ideal é transparente: a implementação de uma abstração. Você usa as funções e pronto. Elas não são sequer dependentes do tipo de dados que está armazenando, ou ficariam menos úteis, certo? Quanto mais genéricas melhor. Linguagens como C++ e java e muitas outas tem listas como parte da linguagem, e funcionam para listar qualquer coisa, claro. São chamadas containers nessas linguagens. E faz sentido não? Veja um exemplo bem besta: Em C++ #include <iostream> #include <list> using namespace std; int main() { printf("lista em C++\n"); list<int> lista = { 1,2,3,4,5 }; lista.push_front(8); // 8 no inicio lista.push_back(9); // 9 no fim for (auto n : lista) printf("%d\n", n); }; mostra lista em C++ 8 1 2 3 4 5 9 Em java import java.util.ArrayList; import java.util.List; public class Main { public static void main(String[] args) { List<Integer> lista = new ArrayList<Integer>(); for( int i =1; i<6; i=i+1) lista.add(i); System.out.println("lista de int em java\n"); lista.add(0); lista.add(9); lista.forEach( i -> System.out.println(i)); } } Que mostra lista de int em java 1 2 3 4 5 0 9 Veja que em java não tem pronta faunção pra inserir no início e no fim. Só no fim. E veja como é parecido ... Como fazer isso em C? Pensando em seu exemplo, veja essas declarações #define TAMANHO 15 struct musica { char Nome[TAMANHO]; char Artista[TAMANHO]; int min, seg; }; // musica typedef struct musica Musica; Musica uma_musica; // exemplos Musica outra; Musica* pMusica; Isso é o que você vai listar. Esse typedef serve só para ficar mais legível e não ter que ficar repetindo toda hora na declaração esse struct musica. struct no { void* musica; struct no* proxima; }; // no typedef struct no Lista; Lista playlist; // exemplo Lista* pList; Lista* inserir(void*, Lista*); int listar(Lista*); Aqui está uma possível lista. Um (void*) em C é um ponteiro "genérico". A razão de usar algo assim está no fato de que depois se pode usar essas funções para qualquer coisa, porque NUNCA SE MISTURA DADOS COM O CODIGO DA ESTRUTURA DE ABSTRAÇÃO ou ela deixa de ser abstrata afinal A primeira função: listar() Faz sentido porque ela tem que funcionar mesmo antes da Lista existir, ou quando ela está vazia Então vamos usar... o Bloco de Notas do Windows e criar gabarito.txt porque a gente quer uma lista formatada e não quer perder tempo com printf() que é uma m. * 1 * 2 * 3 * 4 * 5 * 6 123456789012345678901234567890123456789012345678901234567890 # faixa artista HH:MM 000: 123456789012345 123456789012345 MM:SS 000: 123456789012345 123456789012345 MM:SS 000: 123456789012345 123456789012345 MM:SS 000: 123456789012345 123456789012345 MM:SS 000: 123456789012345 123456789012345 MM:SS Aí copiamos isso direto pros printf() Listar() é a única rotina da implementação que precisa entrar no mérito do que tem dentro da lista, porque precisa mostrar os elementos. Na verdade mesmo isso podia ser genérico, usando um conceito chamado de callback. Quem sabe na próxima versão. Uma possível listar() usando o gabarito.txt int listar(Lista* l) { int total = 0; Lista* aux = l; printf("***** listar() *****\n\n"); if (l == NULL) { printf("Lista nao iniciada\n"); return -1; } if (l->musica == NULL) { printf("Lista vazia\n"); return 0; } // nao esta vazia entao cria um ponteiro para // o tipo de dados que estamos usando printf( " # faixa artista HH:MM\n\n" ); do { Musica* pM = (Musica*)aux->musica; // a musica total = total + 1; printf( "%3d: %15s %15s %02d:%02d\n", total, pM->Nome, pM->Artista, pM->min, pM->seg ); aux = aux->proxima; } while (aux != NULL); // do-while() return total; }; // listar() E como inserir? Como a gente só insere no início algo assim já serve: Lista* inserir(void* m, Lista* l) { printf("***** inserir() *****\n"); // cria um elemento Lista* novo = (Lista*)malloc(sizeof(Lista)); novo->musica = m; novo->proxima = l; return novo; }; // inserir() Note que isso funciona mesmo que a lista esteja vazia então não precisa criar aqueles clássicos métodos criar_lista(). Um exemplo criando uma lista com duas músicas int main() { // cria uma musica Musica uma_musica; strcpy(uma_musica.Artista, "artista 1"); strcpy(uma_musica.Nome, "nome 1"); uma_musica.min = 3; uma_musica.seg = 35; // cria uma outra musica Musica outra_musica; strcpy(outra_musica.Artista, "artista 2"); strcpy(outra_musica.Nome, "nome 2"); outra_musica.min = 4; outra_musica.seg = 28; // poe na lista Lista* playlist = NULL; int n = listar(playlist); // vazia playlist = inserir((void*)&uma_musica, playlist); listar(playlist); // uma musica playlist = inserir((void*)&outra_musica, playlist); listar(playlist); // duas musicas return 0; } Apenas declara duas músicas e põe na lista Lista nao iniciada ***** inserir() ***** ***** listar() ***** # faixa artista HH:MM 1: nome 1 artista 1 03:35 ***** inserir() ***** ***** listar() ***** # faixa artista HH:MM 1: nome 2 artista 2 04:28 2: nome 1 artista 1 03:35 Assim já vê que listar() funciona com a lista vazia, e inserir()... insere. E o gabarito funciona. Essas mensagens com ***** são só para dar mais segurança de que método está rodando. Eis o programa de teste #define _CRT_SECURE_NO_WARNINGS #include <stdio.h> #include <stdlib.h> #include <string.h> #define TAMANHO 15 struct musica { char Nome[TAMANHO]; char Artista[TAMANHO]; int min, seg; }; // musica typedef struct musica Musica; struct no { void* musica; struct no* proxima; }; // no typedef struct no Lista; Lista* inserir(void*, Lista*); int listar(Lista*); int main() { // cria uma musica Musica uma_musica; strcpy(uma_musica.Artista, "artista 1"); strcpy(uma_musica.Nome, "nome 1"); uma_musica.min = 3; uma_musica.seg = 35; // cria uma outra musica Musica outra_musica; strcpy(outra_musica.Artista, "artista 2"); strcpy(outra_musica.Nome, "nome 2"); outra_musica.min = 4; outra_musica.seg = 28; // poe na lista Lista* playlist = NULL; int n = listar(playlist); // vazia playlist = inserir((void*)&uma_musica, playlist); listar(playlist); // uma musica playlist = inserir((void*)&outra_musica, playlist); listar(playlist); // duas musicas return 0; } Lista* inserir(void* m, Lista* l) { printf("***** inserir() *****\n"); // cria um elemento Lista* novo = (Lista*)malloc(sizeof(Lista)); novo->musica = m; novo->proxima = l; return novo; }; // inserir() int listar(Lista* l) { int total = 0; Lista* aux = l; printf("***** listar() *****\n\n"); if (l == NULL) { printf("Lista nao iniciada\n"); return -1; } if (l->musica == NULL) { printf("Lista vazia\n"); return 0; } // nao esta vazia entao cria um ponteiro para // o tipo de dados que estamos usando printf( " # faixa artista HH:MM\n\n" ); do { Musica* pM = (Musica*)aux->musica; // a musica total = total + 1; printf( "%3d: %15s %15s %02d:%02d\n", total, pM->Nome, pM->Artista, pM->min, pM->seg ); aux = aux->proxima; } while (aux != NULL); // do-while() return total; }; // listar()

Não, não está tudo errado. O programa não está bom, mas pode ser útil. Foi um professor universitário que escreveu esse código? Em relação ao que você não entendeu, provavelmente seria mais produtivo você ir perguntando sobre essas coisas que não entendeu, eu acho... Você entendeu o conceito desse troço de lista encadeada? E entende o que signifoca alocar memória e liberar? adicionado 6 minutos depois Você tem um livro texto? Qual é? Tem uma apostila ao menos? Algum site de referência? É importante isso. Que compilador você usa? IDE, sistema? Essas coisas

Entendeu o que eu escrevi sobre a ordem das declarações e a função inserir e tal? Vi que não mudou nada. adicionado 8 minutos depois Não entendo esse tipo de construção: scanf_s("%d", &op); while ((c = getchar()) != '\n' && c != EOF){} Se suas opções são também dígitos que são char porque usar scanf() para ler op e getchar() para descartar o resto da linha? Não podia usar apenas getchar()?

Entendo. Então sabe que em java tem módulos e packages e tem uma infinidade de arquivos e import. A ideia é a mesma: separar unidades de código em arquivos separados. Escrever interfaces que seriam os headers e tal

Pode parecer antigo, mas um livro texto pode ser legam nessas horas. Ou um site de documentação, tipo Tutorials Point ou Docs na Microsoft onde tem uma quantia ignorante de exemplos em C e C++ ou muitos outros

Use o botão code <> para inserir seu código num bloco e ajude o pessoal a ajudar você... Seu programa não está bom. Essa é a declaração de gets_s(): char *gets_s( char *buffer, size_t sizeInCharacters ); Sobre InserirInicio() void InserirInicio(char Musica[TAMANHO], char Cantor[TAMANHO], int m, int s); Não acha que deveria retornar algo, como o novo endereço da lista? E Se insere apenas no início porque não chama a função de inserir() apenas? E se criou a struct Musicas para poder criar uma lista de ... Musicas porque não insere Musicas?? Porque Cantor no parâmetro e Artista na struct? Algo assim Lista* inserir(Musica* uma_musica); Não declare os protótipos ANTES das variáveis: grande chance de suas funções usarem essas variáveis, certo? Não use: //------------ INSERIR FUNÇÕES int menu(); void InserirInicio(char Musica[TAMANHO], char Cantor[TAMANHO], int m, int s); void Listar(); //----------- INSERIR STRUCT struct Musicas { char Nome[TAMANHO]; char Artista[TAMANHO]; int min, seg; struct Musicas* prox; } *Head; Escreva assim: //----------- INSERIR STRUCT struct Musicas { char Nome[TAMANHO]; char Artista[TAMANHO]; int min, seg; struct Musicas* prox; } *Head; //------------ INSERIR FUNÇÕES int menu(); void InserirInicio(char Musica[TAMANHO], char Cantor[TAMANHO], int m, int s); void Listar();

Você tem um livro texto? Qual é? Uma apostila? Veja a declaração de scanf() e printf(). Os parâmetros posicionais para printf() não usam &. Escreva só printf("%d\n", numero[i]);

Luis, não tem a ver com plataforma. Isso que eu expliquei é válido desde o Unix nos '80. O compilador não aceitava nos tempos da sua faculdade porque provavelmente não te explicaram corretamente que deveria declarar os protótipos antes. Nada mudou até hoje, exceto pela criação de ambientes integrados --- IDE --- e que em projetos grandes não são assim importantes. Nos '80 não haviam esses "terminais". Vou deixar um mini-exemplo no final. Os programas de estudantes são muito diferentes dos programas que são escritos para resolver algo objetivo. A maior diferença é que um programa de estudante depois de pronto não é mais usado. E um programa comum passa a ser usado só depois de pronto. E em outras máquinas. Sem o fonte, sem IDE... Mas pensando em um programa grande de estudante, imagine esse programa aqui de estacionamento sendo escrito por grupos de digamos 3 alunos. Eis a lógica disso: conforme seu programa cresce partes dele vão ficando prontas e você não quer ficar compilando tudo toda hora.Nesse programa de estacionamento você pode optar por implementar estruturas de dados: uma fila para os manobristas, uma fila para os carros. Separar a parte de check-in e check-out para ficar mais fácil controlar a performance dos manobristas e a rotatividade do serviço. Então você vai escrever essas coisas em separado porque são mesmo distintas. E levar a programas em separado com funções main() especializadas para testar cada parte. É muito mais esperto. E permite que mais pessoas trabalhem no sistema ao mesmo tempo em partes separadas. Então vai acabar com algo como fila.h fila.c check-in.h check-in.c check-out.h check-out.c estaciona.c E um monte de programas de teste. E em estaciona.c estará a função main() para o seu programa de estacionamento. E nesse arquivo apenas #include para esses .h todos. Seu programa principal só tem a lógica do estacionamento. Se aparece um problema na fila você vai lá em fila.c e arruma. Ou liga pro cara do seu grupo que fez essa parte e diz pra ele arrumar. E para testar ELE testa com os programas de teste da fila. Não mexe no programa de estacionamento que ele nem tem. E depois que ele arrumar essa parte e te mandar o código você apenas gera o estaciona.exe de novo porque ele sempre vai pegar as últimas versões de cada parte. Por outro lado, veja um exemplo de um programa simples, em um único arquivo No início do texto eu já posso ver como são declaradas as funções que estão em main(). Note que os protótipos não tem sequer nomes para as variáveis. Não precisa. Mas eu já começo a ler main() que é o que importa e já posso ver as declarações. É mais esperto. Antes Depois E aqui tem as funções em alguma ordem. Como nenhuma ordem é assim absoluta elas estão em ordem alfabética. Ajuda a achar o código certo? Claro que no mundo moderno você pode em qualquer lugar do projeto --- se estiver usando um IDE --- apertar F12 e ir direto para a definição da função no seu projeto de centenas de arquivos e milhares de linhas. ah o progresso. adicionado 31 minutos depois Acho que não levou mesmo a sério o que eu te expliquei sobre não ler dados e enfiar no meio de seus testes. Seu problema seria bem mais simples se escrevesse a partir de primitivas assim como te mostrei. Veja esse trecho: // trecho printf("(1) Registrar Veiculo\n"); printf("(2) Saida de Veiculo\n"); printf("--------------------------\n"); scanf("%d%*c", &opcao); switch(opcao){ case 1: registrar(); break case 2: saida(); break } Isso é problemático: não misture as coisas. Imagine que prisma seja o número daquele quadradinho com base magnética que os caras põem nos carros em alguns estacionamentos... E no programa principal poderia usar switch(opcao) { case REGISTRO: // le a placa do carro e arruma a hora certa // para emitir o ticket define um prisma para o manobrista // levar o carro placa = le-placa(); // usa seja la o que for pra ler a placa hora = formata_data_e_hora(); // arruma "dd-mm-aa hh:mm:ss" prisma = registrar(placa, hora); // registra o carro vai gerar um ticket break; case SAIDA: // o dono do carro trouxe o ticket: chama uma funcao que identfica o prisma prisma = identifica_prima( numero_ticket); // com o prisma da a saida do carro saida(prisma); break } mas enquanto está escrevendo seu programa já pode usar prisma = registrar("ABC-1234", "15/03/20 15:55:00"); emitir_ticket( prisma ); saida( prisma ); Entendeu a diferença??? É muito mais simples. Não é sério a cada vez que vai testar o programa abrir um menu na tela e ficar 5 minutos digitando coisas. Não leva a nada. Sugiro usar um paradigma como o do ticket que te mostrei antes: crie um registro do carro com aquelas informações e associe a uma identificação . Prisma? Não seria nada original, mas funciona no mundo todo. E grave isso num vetor e no disco. Tipo um arquivo frota.dat e um array Prisma carros[Tamanho_do_Patio]; // um registro para cada carro no patio onde Prisma é um registro como eu expliquei. Não seria original. Lá estará um registro para cada carro no pátio. Também não é uma ideia original, mas funciona.

Entendo. Ainda está um pouco longe de funcionar. Você precisa colocar esses métodos dentro de uma classe. Não é assim omo escreveu, Board1() Board2(). Entendeu o que eu escrevi sobre as instâncias? É difícil pensar no jogo em um computador só, a menos que o adversário seja o computador, certo?

Não, Luis, não devem. Não creio que seja uma questão só de opinião ou de política de empresa ou academia. A primeira função deve ser sempre main() e em muitos casos não há sequer outra função no mesmo arquivo. Há várias razões para isso. Vou te explicar algumas: Quando você vai ler um programa que você recebeu, um programa que você não fez, porque alguém está te pagando para isso ou porque você é voluntário para isso ou porque alguém te pediu muito pra fazer isso, você quer ler main() porque é onde o programa começa. Assim é. Em C++ por exemplo em geral cada classe estará em outro arquivo. Quando você cria uma nova classe um IDE moderno já cria arquvos .h e .cpp para a classe, por exemplo. Em java também é assim. No início do programa é pra ter apenas #include para os headers e talvez as declarações para a classe local. Se tiver funções escritas no mesmo arquivo se declaram os protótipos para as funções no início do texto, logo antes de main(), e no caso de ter declarado structs nesse arquivo você declara os protótipos imediatamente antes de main() porque quase certamente alguns deles vão declarar parâmetros desses tipos decjarados acima no arquivo. Quando o código das funções for ficando pronto em geral elas vão sendo passadas para outros arquivos, porque você não quer o trabalho de compilar tudo de novo a toda hora e nem o risco de fazer algo errado e zoar tudo. Esse é um conceito muito importante. Como sabe há muito material online em C e é fácil ver do que eu estou falando: abra algum projeto desses. Mas considere as razões práticas. main() perdida no meio de dezenas ou centenas de funções enfurece grande parte dos programadores. Sobre código assim . . . void registrar() { printf("--------------------------------------- REGISTROS ----------------------------------------\n"); printf("Informe a placa do carro que você deseja registrar: \n"); scanf("%s%s", cliente_1.placa, cliente_1.hora); printf("\nVeiculo de placa: %s", cliente_1.placa); printf("\nEntrada: %s", cliente_1.hora); printf("--------------------------------------- XXXXXXXX- ------------------------------------------\n"); } Nesse mesmo forum postei algo assim hoje Escreva int registrar(char* placa, char* hora); e retorne 0 se acha que deu certo. Por exemplo. E assim você pode escrever int resultado = registrar("ABC-1234", "21/03/20 15:16:17"); Não misture entrada e saída com suas funções. Só vai atrasar sua vida. Pense nisso. E sobre seu código e o que parece ser norma aqui, entenda a declaração de scanf(): essa rotina não é pra isso, mas já que está usando para ler um único campo do teclado entenda que ela retorna um valor, e USE.

Considere um ticket de estacionamento comum e implemente igualzinho. Veja esse: É só copiar. Implemente as funções em separado: check-in / check-out . Cobrança. E salve os valores em arquivo, tipo um registro de transações, para poder reconstruir se o programa parar... Não seria uma ideia nova associar cada carro a um PRISMA e cada prisma uma vaga, certo?