arfneto

Porque não? Que significa?
 
 
o problema está no " esquema abaixo" 
 

Não conecte nunca esses roteadores via WAN. É garantia de problema. E algumas coisas não vão funcionar nem a pau.
 
Postei um roteiro detalhado disso e uma descrição de uma meia dúzia de razões para NÃO fazer isso nessa semana. Pode dar uma lida e vai achar alguns dos problemas meio deja vu 😉 coisas que já viu antes na sua rede mesmo
 
Por outro lado evite a todo custo conectar os aparelhos em cascata. Do modo como fez é  melhor.
 
 
 

Usar múltiplos roteadores em situações assim requer um planejamento prévio e sem ele pode ser bem frustrante. Mesmo com o tal planejamento pode ser um inferno 😄 
 
Imagine o cenário de uma empresa em um prédio com 7 andares e umas dezenas de equipamentos em rede. Um hipotético cenário: no piso térreo estaria o gateway da rede --- o equivalente ao seu modem da claro --- e em cada andar teriam switches e talvez roteadores para ligar as máquinas. Imagine isso, mas nos anos 90: Seriam usados roteadores e protocolos de roteamento e não seria especialmente complicado.
 
Só que hoje em dia os roteadores domésticos não são roteadores. Só tem esse nome. São adaptadores LAN/WAN e não foram projetados para serem usados em cascata. Nem para rotear. E são de muito baixo custo e por isso oferecidos "sem custo". E tem serviços integrados, de modo que mudanças na topologia podem afetar coisas inesperadas. Colocar um roteador desses em modo bridge pode deixar o assinante sem TV e sem telefones na claro/net por exemplo.
 
DHCP é outro problema e em que ser tratado com critério. Prazos longos de lease podem deixar a rede rapidamente sem endereços --- veja o caso comum dos restaurantes que ficam sem wifi todo dia na hora do almoço. Prazos curtos geram muito tráfego na rede e no caso de "roteadores" em cascata podem derrubar dezenas de conexões ao vencer um lease num roteador com a WAN em DHCP, o comum. E sempre tem o maluco que vai dizer que não pode ter mais de um servidor DHCP na rede então não pode ter um com lease alto e outro com lease de 3 ou 4 minutos, já que só tem um.
.
WiFi é outro problema porque em geral são dispositivos móveis na própria rede e usam DHCP e no trânsito podem trocar de endereço. MESH é outro problema se usar uma rede que não permita ligar os POD VIA CABO e não via rádio (wifi)
 
Não dá pra escrever muito aqui. Muito do que posso sugerir e dos problemas eu até comentei nesse tópico nessa semana e sugiro dar uma olhada: tem uns números de uma mudança que eu fiz onde a performance no final estava perto da metade, apenas com 2 roteadores.
 
Não dá pra escrever muito aqui. Muito do que posso sugerir e dos problemas eu até comentei nesse tópico nessa semana
 
 
De volta à sua rede
 
Não ficou claro como liga essas coisas, e seria legal se você postasse um desenho, mas pelos problemas imagino que tenha esses dispositivos ligados do jeito comum e tenha os problemas comuns: perda de conectividade repentina, performance medíocre em certos pontos, dispositivos inacessíveis como TV e servidores de mídia como Chromecast Fire, Apple TV ou Roku em certos pontos da rede.

O que eu sugiro:
Antes de tudo: eliminar todo possível cascateamento. Quantos dispositivos acha que pode ter na rede? É importante saber.
 
Conecte um switch ao modem da CLARO/NET, 16 ou 24 portas tanto faz. Não precisa ser gerenciavel. E ligue TODOS os outros roteadores no roteador da claro (uma porta ja foi para o switch, restam 3) ou nesse switch. É um aparelho barato. Separe uns endereços fora do DHCP para endereçar TODOS os dispositivos de rede. se o CLARO está em 192.168.0.1 deixa o DHCP a partir de 20 por exemplo. Deixe um prazo pequeno para o DHCP, uns 10 minutos algo assim. Se sua rede mesh não pode ser interligada via cabo sugiro simplesmente trocar os aparelhos WIFI nada tem a ver com a internet ou com DHCP ou TCP. É outra camada. Use as rede todas com nomes diferentes ao menos no início para poder ver as diferenças de sinal por exemplo e poder medir a cobertura. Qualquer celular com um app tipo wifi Analyzer ou Open Signal vai te dizer muito sobre as redes e a performance. Telefones daquela marca da maça por exemplo tendem a insistir numa conexão quando o sinal vai caindo e não passam logo para outra mesmo que a antena fique ao lado dele. Se tiver o mesmo nome fica difícil de testar isso... Ligue todos esses dispositivos via porta LAN. Essa é a infraestrutura da rede. Tudo via cabo. A partir daí pode concluir que precisa mesmo de um roteador, tipo esses da CISCO para pequenas empresas ou da Ubiquity, mas pode ser que  nem seja o caso. Pode até descobrir que PRECISA mesmo de uma rede mais rápida, como 5 ou 10G, se sua casa for muito muito grande ou tiver centenas de dispositivos, ou 6 dúzia de TVs rodando vídeo a 4K ou 8K a partir de servidores na própria rede 😉 Coloque todos os dispositivos  lá do lado do modem numa mesa e vá endereçando em .2 .3 .4 .5... Assim poderá acessar todos da mesma tela de qualquer lugar da casa DEPOIS. Desative o DHCP em todos eles. Pode ter que voltar a isso, mas num primeiro momento nem tente. Com os POD mesh ligados ao mesmo ponto na infraestrutura o transporte das conexões sem derrubar fica bem tranquilo, vai notar. Meu palpite grátis 🙂
 
 

A imagem é do manual. O provedor pode ter ideias ou necessidades totalmente diferentes. Ou o cliente 😉 você por exemplo vai mudar umas coisinhas.

Não deve ser o caso. O que vai determinar isso de "segmento sem acesso" é a máscara de rede. 
 
Uma razão comum de se fazer isso --- de ter mais de um servidor DHCP numa mesma rede, digamos algo clássico como 192.168.0.0/24 ou 172.16.0.0/16 -- é ter redundância para o caso do servidor DHCP parar. Qualquer coisa de que se tenha um só é claro uma fragilidade.
 
Nesse caso uma impressora por exemplo pode conseguir seu endereço de qualquer servidor DHCP na rede e ser acessada por qualquer dispositivo nessa rede. 
 
Mesmo servidores DHCP operando na mesma faixa de rede são mais coisa antiga do que novidade e se usa uma comunicação entre eles para evitar conflito e gerenciar o uso cooperativo da faixa. Afinal esses servidores são simples programas e podem se comunicar entre si.
 
Servidores DHCP e roteadores domésticos
 
DHCP foi introduzido num tempo em que não havia NAT nem redes domésticas e os critérios na rede eram outros para quase tudo. Hoje em dia, com a explosão do número de redes domésticas e pequenas redes em empresas, foi criado esse personagem tipo set-top-box, a caixinha que faz tudo. E claro que com a integração os custos caíram e algo se perdeu.
 
Muitas dessas caixinhas chamadas de roteadores hoje em dia --- e que nem são de fato roteadores --- sequer permite entrar com o endereço do gateway  na configuração do DHCP. Isso torna a configuração de mais de um servidor DHCP impossível se tiver um desses infelizes na rede e ele não for de fato o gateway.
 
Como as redes domésticas estão ficando cada vez mais complicadas isso está voltando e muitos dos "roteadores" modernos trazem essa configuração de volta, como alguns da série Archer na conhecida TP-Link.
 
A biblia do DHCP: RFC2131

aqui compila ok. Mude algo pra ver o que acontece. Tire essas chaves por exemplo. Não precisa delas afinal

pode usar a barra ao invés da barra invertida ou então usar duas \\ mas não pode usar uma só.
 
Isso é o que a mensagem está tentando te dizer.
 
Não use system. Para nada. De pouco serve. Está programando em C ou C++ e pode fazer qualquer coisa. Então escreva tal "coisa".
Entenda que cada chamada a system() atua em um ambiente distinto e se tem pouco ou nenhum controle do que acontece. Duas chamadas seguidas nada tem a ver uma com a outra, por exemplo. Não se compartilha variáveis, estado, nada.
 
Use CreateProcess(), threads e afins.

pode usar a barra ao invés da barra invertida ou então usar duas \\ mas não pode usar uma só.
 
Isso é o que a mensagem está tentando te dizer.
 
Não use system. Para nada. De pouco serve. Está programando em C ou C++ e pode fazer qualquer coisa. Então escreva tal "coisa".
Entenda que cada chamada a system() atua em um ambiente distinto e se tem pouco ou nenhum controle do que acontece. Duas chamadas seguidas nada tem a ver uma com a outra, por exemplo. Não se compartilha variáveis, estado, nada.
 
Use CreateProcess(), threads e afins.

pode usar a barra ao invés da barra invertida ou então usar duas \\ mas não pode usar uma só.
 
Isso é o que a mensagem está tentando te dizer.
 
Não use system. Para nada. De pouco serve. Está programando em C ou C++ e pode fazer qualquer coisa. Então escreva tal "coisa".
Entenda que cada chamada a system() atua em um ambiente distinto e se tem pouco ou nenhum controle do que acontece. Duas chamadas seguidas nada tem a ver uma com a outra, por exemplo. Não se compartilha variáveis, estado, nada.
 
Use CreateProcess(), threads e afins.

pode usar a barra ao invés da barra invertida ou então usar duas \\ mas não pode usar uma só.
 
Isso é o que a mensagem está tentando te dizer.
 
Não use system. Para nada. De pouco serve. Está programando em C ou C++ e pode fazer qualquer coisa. Então escreva tal "coisa".
Entenda que cada chamada a system() atua em um ambiente distinto e se tem pouco ou nenhum controle do que acontece. Duas chamadas seguidas nada tem a ver uma com a outra, por exemplo. Não se compartilha variáveis, estado, nada.
 
Use CreateProcess(), threads e afins.

Teste o retorno de scanf(). Sempre. É ingênuo não testar. Veja o manual.
 
Não precisa do loop em main() deste modo. Pode encerrar quando não ler o primeiro valor. Mais simples e menos chato para quem está usando. 
Pode ler os 3 valores de uma vez, assim o cara não precisa necessariamente digitar TODOS esses 4 ENTER.
Consuma o ENTER que termina cada scanf() usando p. ex. fgetc. Ou não use scanf ...
 
Na função retorne o resultado. Não precisa ficar esperando o final do loop. Mais simples e legivel
 
Entenda que 0 e (0) é a mesma coisa. E são int. Evite conversões implícitas. É um hábito ruim. Escreva 0F para float e 0. para double.
 
Esse código é equivalente para calcula()
 
float calcula(float a, float b, char c) { switch (c) { case '+': return a + b; case '-': return a - b; case '*': return a * b; case '/': if (b != 0) return a / b; fprintf( stderr, " Erro: Tentativa de dividir %f por 0.\n"); return 0.F; default: fprintf( stderr, " Erro: Operador Invalido: '%c' para %f e %f\n", c, a, b); return 0.F; } return 0.F; }  
E talvez concorde que é mais simples de ler. E resolve o problema da divisão por zero de algum modo.
 
E tem a cortesia de avisar quando o operador é inválido ou 0 para a divisão. E a saída pode ser omitida.
 
E não carrega um float até o fim do código simplesmente para retornar.
 
Não há razão para usar conio.h dos anos 80. E não é padrão. Não vem com os compiladores.
 
Não precisa da variável resposta já que não vai operar com ela.

Acho que não devia distribuir sua questão em posts diferentes. Fica mais difícil para alguém encontrar uma resposta e se beneficiar da discussão
 
Você vai usar pipe para enviar os dados para os 3 processos. E você já descreveu os processos.
 
Esse não é um exemplo racional para usar processos ou pipes. É uma bobagem. Mas é o que tem pra fazer então...
 
São 4 processos. Obiviamente o seu programa é um processo e vai criar 3 outros.
 
(1) Um processo determina os coeficientes da equação, a, b e c na fórmula clássica (2) Um processo recebe esses valores e calcula o delta (3) um processo recebe o delta e os valores de a e c e calcula uma solução (4) um processo idêntico recebe os valores de delta a e c e calcula a outra solução. Acho que deve usar fork e não threads porque o enunciado só fala em processos e está rodando em Unix ---ah  ok, Linux, Mac, Android, whatever.

Isso nada tem a ver com o PC. A tal configuração IP válida vem do servidor DHCP que deve ser seu roteador.
 
Num primeiro momento pode testar fazendo o simples: veja qual a rede que usa em seu roteador e coloque seu PC em um endereço nessa rede, fixo, nas propriedades de IPv4 na placa de rede e vai saber se o problema é do tal servidor DHCP ou de conectividade mesmo...
 
 

 
 
um exemplo. veja os endereços certos na sua rede...

verde claro (1), verde escuro(2), branco(3), preto(8), marrom escuro(7), azul escuro(4), azul claro(5) e laranja(6) deve ser a sequência deles.
 
Não estou certo quanto ao par 7/8 mas não deve fazer diferença porque me geral tem a mesma quantia de metal por metro. Os pares 1/2 e 3/6 são os que tem mais peso. Se precisar mesmo se certificar -- e isso só vai mesmo importar se o cabo for muito muito longo, tipo 60m ou mais ou for passar numa área de muita interferência, como um forro com reatores ou transformadores como os de neon --- apenas confirme as cores que estão enroladas com o fio laranja(6) e o fio verde escuro (2) e esses serão 3 e 1.

Não há duas internet, imagino que tenha contratado dois provedores para ter mais segurança na conectividade por causa do trabalho.
 
Do ponto de vista da rede a internet não existe. A rede local, o L de LAN, apenas sabe o que não é local e encaminha para um endereço, o tal gateway. O protocolo, o TCP/IP, faz o resto junto com o DNS.
 
Há muitas maneiras de acomodar vários provedores na mesma rede, além de simplesmente trocar os cabos (e renovar os endereços IP). Como é uma necessidade comum existem também equipamentos para fazer isso, como os LOAD BALANCER. No BR acho que o mais comum é o TL-R470t+ da marca TP-Link que custa menos de R$300 mas acho que não resolve seu problema. Um compuador antigo que esteja largado lá na estante em geral é uma solução mais flexível e não precisa nem de HD. Como vai cumprir função específica pode rodar Linux a partir de um pen-drive mesmo. E não precisa de monitor ou teclado depois de configurado.
 
Note que é bem simples ter múltiplos adaptadores de rede no mesmo micro, usando outros slots PCI ou PCIx, adaptadores USB, e pode ter scripts, pequenos arquivos de comando que ativam ou desativam os adaptadores, ou usar o mouse mesmo...
 
De todo modo é preciso ter uma descrição precisa do que tem na sua rede. Os roteadores, modem, switch e os tais equipamentos locais de que falou.
 
Note que a VPN apenas acrescenta outra rede na sua configuração. A diferença disso para uma outra placa de rede é o V de VPN: a placa é virtual e some ao desligar do escritório. 
 
Muitas vezes os scripts de conexão com a VPN mudam o gateway da rede para um endereço na rede virtual e todo o tráfego com a internet passa para o túnel o PN de VPN. E assim precisa ter uma rota salva para sua rede, alvo de um comando route disponível no Windows e no Lunix que era Unix e no Mac que era Linux. Assim pode acessar sua impressora por exemplo.
 
Tudo isso é simples mas chato. 
 
 
 
É preciso ver caso a caso.
Veja que a opção acende no Windows sempre que seleciona um adaptador na lista.
 
No Linux é bem igual.

A menos que seu cabo passe ao lado de transformadores ou fontes de alta potência ou tenha perto do tamanho máximo recomendado (100m) não terá diferença entre um cabo 5e e um cabo CAT-6. O E em 5e quer dizer enhanced e na prática quer dizer que tem um pouco mais de metal por metro e é garantido para até 1Gbps em 100m, A não ser que use rede acima de 5Gbps estará bem com qualquer desses cabos.
 
Invertendo as pontas do cabo permanece o problema? pode ser apenas algo físico entre o soquete e o conector de seu cabo CAT6.
 
 
Não, não tem. A placa de rede não conhece cabos. Apenas sinais nas 8 vias no caso de conexões acima de 10Mbps
 
 

Não existe tal site. E Dev-C++ não é assim um bom IDE.
 
O maior repositório de códigos que existe provavelmente é o GitHub, hoje da Microsoft. De lá você pode baixar de tudo. Mas não há uma organização, um super-catálogo. Não por acaso o GTK+ está lá
 
Para usar qualquer biblioteca no Dev-C++ apenas encontre o código, baixe e compile. Depois configure os diretórios no Dev-C++ para que ele encontre os #include e para o linker encontrar os códigos. Talvez ache mais fácil se criar uma biblioteca sua primeiro para entender o mecanismo, mas basicamente é preencher um formulário. Pode usar varáveis de ambiente também. E está explicado na documentação do IDE.
 
Instalação com um click e catálogo você pode conseguir com algo como um package manager. Para C++ o mais simples pode ser usar o vcpkg da Microsoft. Que funciona em Windows, Linux e Mac e tem no catálogo o GTK+, o Qt, o WxWidgets, o SDL e mais de 1500 outros pacotes. Para Linux o pacman pode ser o equivalente mas não sei dizer se roda fora do Linux/MAC
 
Pode ser simples se usar o Visual Studio porque aí ele faz tudo sozinho mesmo, já que a integração com o vcpkg é automática. E se tiver noções básicas de uso do CMake facilita mais ainda porque esse é praticamente o padrão de distribuição de bibliotecas, no lugar dos antigos makefiles
 
No caso do GTK+ a documentação explica como compilar os fontes e instalar tudo. De todo modo a documentação lá sugere usar o Chocolatey como gerenciador de pacotes
 
Choco We recommend using Chocolately as a package manager in Windows. To install it, open PowerShell as an administrator, then execute: Set-ExecutionPolicy Bypass -Scope Process -Force; iex ((New-Object System.Net.WebClient).DownloadString\ ('https://community.chocolatey.org/install.ps1'))  
O '\' eu coloquei aqui apenas
 
Isso está em https://github.com/wingtk/gvsbuild
 
 
 
 
 

É um jeito de ver as coisas.
 
Mas o que acontece é que como você escreveu está errado. E por isso está dando errado. Faz sentido 🤔
 
Em C não se pode comparar strings assim, com já foi explicado acima.
 
Seu programa pode até acabar funcionando assim, mas está muito frágil. Não está bom e não vai nem mesmo funcionar em muitos ambientes. Muitos dos supostos "erros"  de que vou falar são comuns e parecem inevitáveis. Deve vir da maneira incrível como ensinam e escrevem sobre C e linguagens em geral hoje em dia.
 
Sobre isso por exemplo
 
// constantes : const int SEM_ERRO = 0; const int TAMANHO_MAXIMO = 50; void jogo(); void pessoa(); void lugar(); void ano(); void coisa(); void escolha6(); int main (){  
nunca use void. Retorne algo. E passe argumentos. Todas essas 6 funções são um desastre em termos de flexibilidade e manutenção e não rodaria um programa assim em nenhuma empresa ou escola com um mínimo de critério. não use valores globais. NUNCA. Por nada. Para essas constantes é mais inteligente usar #define. NUNCA use gets(). Foi marcada como obsoleta há mais de uma década além de ser inconveniente. use fgets() não use fflush() se não souber exatamente o que é. E quando souber verá que só está definido para a saída TESTE o retorno de scanf(). É ingênuo seguir sem testar. Leia o manual Não use system(). Não estará fazendo nada. Não estará aprendendo nada.  Não use uma pausa no fim do programa. Se faz isso por causa do IDE apenas programe o IDE para não fechar a console ao final da execução. E se ele não tiver essa opção use um melhor. São grátis hoje em dia. return SEM_ERRO; Se acha return 0; pouco expressivo entenda que C tem as constantes EXIT_SUCCESS e EXIT_FAILURE exatamente para isso e conhecidas em toda parte. Prefira essas. Seu programa só tem esse return. Acha que vale a pena se preocupar com isso?
seu programa tem 6 funções void xxx() pouco úteis. Porque não tem uma 

int menu();   
por exemplo?
 
printf("\nMenu\n\n1-Novo jogo\n\n2-Explicação do jogo\n\n3-Ranking\n\n4-Sair do jogo\n\nDigite a opção:\n\n");  
Não escreva assim...
Compare:
printf("\ \n\ Menu\ \n\ \n\ 1-Novo jogo\ \n\ \n\ 2-Explicação do jogo\ \n\ \n\ 3-Ranking\ \n\ \n\ 4-Sair do jogo\ \n\ \n\ Digite a opção: ");  
Assim é mais fácil de ler e de alinhar o texto...
E não mude de linha antes de ler uma resposta. Não é boa prática. Em geral as pessoas esperam o cursor logo após a pergunta.
 

É um jeito de ver as coisas.
 
Mas o que acontece é que como você escreveu está errado. E por isso está dando errado. Faz sentido 🤔
 
Em C não se pode comparar strings assim, com já foi explicado acima.
 
Seu programa pode até acabar funcionando assim, mas está muito frágil. Não está bom e não vai nem mesmo funcionar em muitos ambientes. Muitos dos supostos "erros"  de que vou falar são comuns e parecem inevitáveis. Deve vir da maneira incrível como ensinam e escrevem sobre C e linguagens em geral hoje em dia.
 
Sobre isso por exemplo
 
// constantes : const int SEM_ERRO = 0; const int TAMANHO_MAXIMO = 50; void jogo(); void pessoa(); void lugar(); void ano(); void coisa(); void escolha6(); int main (){  
nunca use void. Retorne algo. E passe argumentos. Todas essas 6 funções são um desastre em termos de flexibilidade e manutenção e não rodaria um programa assim em nenhuma empresa ou escola com um mínimo de critério. não use valores globais. NUNCA. Por nada. Para essas constantes é mais inteligente usar #define. NUNCA use gets(). Foi marcada como obsoleta há mais de uma década além de ser inconveniente. use fgets() não use fflush() se não souber exatamente o que é. E quando souber verá que só está definido para a saída TESTE o retorno de scanf(). É ingênuo seguir sem testar. Leia o manual Não use system(). Não estará fazendo nada. Não estará aprendendo nada.  Não use uma pausa no fim do programa. Se faz isso por causa do IDE apenas programe o IDE para não fechar a console ao final da execução. E se ele não tiver essa opção use um melhor. São grátis hoje em dia. return SEM_ERRO; Se acha return 0; pouco expressivo entenda que C tem as constantes EXIT_SUCCESS e EXIT_FAILURE exatamente para isso e conhecidas em toda parte. Prefira essas. Seu programa só tem esse return. Acha que vale a pena se preocupar com isso?
seu programa tem 6 funções void xxx() pouco úteis. Porque não tem uma 

int menu();   
por exemplo?
 
printf("\nMenu\n\n1-Novo jogo\n\n2-Explicação do jogo\n\n3-Ranking\n\n4-Sair do jogo\n\nDigite a opção:\n\n");  
Não escreva assim...
Compare:
printf("\ \n\ Menu\ \n\ \n\ 1-Novo jogo\ \n\ \n\ 2-Explicação do jogo\ \n\ \n\ 3-Ranking\ \n\ \n\ 4-Sair do jogo\ \n\ \n\ Digite a opção: ");  
Assim é mais fácil de ler e de alinhar o texto...
E não mude de linha antes de ler uma resposta. Não é boa prática. Em geral as pessoas esperam o cursor logo após a pergunta.
 

É um jeito de ver as coisas.
 
Mas o que acontece é que como você escreveu está errado. E por isso está dando errado. Faz sentido 🤔
 
Em C não se pode comparar strings assim, com já foi explicado acima.
 
Seu programa pode até acabar funcionando assim, mas está muito frágil. Não está bom e não vai nem mesmo funcionar em muitos ambientes. Muitos dos supostos "erros"  de que vou falar são comuns e parecem inevitáveis. Deve vir da maneira incrível como ensinam e escrevem sobre C e linguagens em geral hoje em dia.
 
Sobre isso por exemplo
 
// constantes : const int SEM_ERRO = 0; const int TAMANHO_MAXIMO = 50; void jogo(); void pessoa(); void lugar(); void ano(); void coisa(); void escolha6(); int main (){  
nunca use void. Retorne algo. E passe argumentos. Todas essas 6 funções são um desastre em termos de flexibilidade e manutenção e não rodaria um programa assim em nenhuma empresa ou escola com um mínimo de critério. não use valores globais. NUNCA. Por nada. Para essas constantes é mais inteligente usar #define. NUNCA use gets(). Foi marcada como obsoleta há mais de uma década além de ser inconveniente. use fgets() não use fflush() se não souber exatamente o que é. E quando souber verá que só está definido para a saída TESTE o retorno de scanf(). É ingênuo seguir sem testar. Leia o manual Não use system(). Não estará fazendo nada. Não estará aprendendo nada.  Não use uma pausa no fim do programa. Se faz isso por causa do IDE apenas programe o IDE para não fechar a console ao final da execução. E se ele não tiver essa opção use um melhor. São grátis hoje em dia. return SEM_ERRO; Se acha return 0; pouco expressivo entenda que C tem as constantes EXIT_SUCCESS e EXIT_FAILURE exatamente para isso e conhecidas em toda parte. Prefira essas. Seu programa só tem esse return. Acha que vale a pena se preocupar com isso?
seu programa tem 6 funções void xxx() pouco úteis. Porque não tem uma 

int menu();   
por exemplo?
 
printf("\nMenu\n\n1-Novo jogo\n\n2-Explicação do jogo\n\n3-Ranking\n\n4-Sair do jogo\n\nDigite a opção:\n\n");  
Não escreva assim...
Compare:
printf("\ \n\ Menu\ \n\ \n\ 1-Novo jogo\ \n\ \n\ 2-Explicação do jogo\ \n\ \n\ 3-Ranking\ \n\ \n\ 4-Sair do jogo\ \n\ \n\ Digite a opção: ");  
Assim é mais fácil de ler e de alinhar o texto...
E não mude de linha antes de ler uma resposta. Não é boa prática. Em geral as pessoas esperam o cursor logo após a pergunta.
 

Note que na prática certamente seria preciso um parâmetro com o tamanho do array. Se o tamanho é sempre 5 deveria estar na declaração [5] e não [ ] 
 
Isso é só uma prova de conceito para ver como escrever.
 
Eis um exemplo de como escrever:
 
saida
 
Vetor de char original: Valores em char: '1' '2' '3' '4' '8' Vetor de 'int' convertido: Valores em decimal: 1 2 3 4 8 Vetor convertido (versão de um parametro): Valores em decimal: 1 2 3 4 8  
Código
 
#include <stdio.h> #include <stdlib.h> int* Converte(char[]); int converte(char origem[], int destino[]); int mostra_char(char[], const char*); int mostra_int(int[], const char*); int main(void) { char ent[5] = {'1', '2', '3', '4', '8'}; int sai[5] = {0}; mostra_char((int*) ent, "Vetor de char original:"); converte(ent, sai); mostra_int(sai, "Vetor de 'int' convertido:"); int* outro = Converte(ent); mostra_int( outro, "Vetor convertido (versão de um parametro):"); free(outro); // apaga return 0; } int* Converte(char origem[]) { int* destino = (int*)malloc(5 * sizeof(int)); if (destino == NULL) return NULL; for (int i = 0; i < 5; i += 1) *(destino + i) = origem[i] - '0'; return destino; } int converte(char origem[], int destino[]) { for (int i = 0; i < 5; i += 1) destino[i] = origem[i] - '0'; return 0; } int mostra_char(char v[], const char* tit) { if (tit != NULL) printf("%s\n", tit); printf("\tValores em char: "); for (int i = 0; i < 5; i += 1) printf("'%c' ", v[i]); printf("\n"); return 0; } int mostra_int(int v[], const char* tit) { if (tit != NULL) printf("%s\n", tit); printf("\tValores em decimal: "); for (int i = 0; i < 5; i += 1) printf("%d ", v[i]); printf("\n"); return 0; }  
 
Sobre seu código
 
 
porque só tem 4?
 
Está muito confuso como escreveu. Não entendi. Mas não está certo.

Note que na prática certamente seria preciso um parâmetro com o tamanho do array. Se o tamanho é sempre 5 deveria estar na declaração [5] e não [ ] 
 
Isso é só uma prova de conceito para ver como escrever.
 
Eis um exemplo de como escrever:
 
saida
 
Vetor de char original: Valores em char: '1' '2' '3' '4' '8' Vetor de 'int' convertido: Valores em decimal: 1 2 3 4 8 Vetor convertido (versão de um parametro): Valores em decimal: 1 2 3 4 8  
Código
 
#include <stdio.h> #include <stdlib.h> int* Converte(char[]); int converte(char origem[], int destino[]); int mostra_char(char[], const char*); int mostra_int(int[], const char*); int main(void) { char ent[5] = {'1', '2', '3', '4', '8'}; int sai[5] = {0}; mostra_char((int*) ent, "Vetor de char original:"); converte(ent, sai); mostra_int(sai, "Vetor de 'int' convertido:"); int* outro = Converte(ent); mostra_int( outro, "Vetor convertido (versão de um parametro):"); free(outro); // apaga return 0; } int* Converte(char origem[]) { int* destino = (int*)malloc(5 * sizeof(int)); if (destino == NULL) return NULL; for (int i = 0; i < 5; i += 1) *(destino + i) = origem[i] - '0'; return destino; } int converte(char origem[], int destino[]) { for (int i = 0; i < 5; i += 1) destino[i] = origem[i] - '0'; return 0; } int mostra_char(char v[], const char* tit) { if (tit != NULL) printf("%s\n", tit); printf("\tValores em char: "); for (int i = 0; i < 5; i += 1) printf("'%c' ", v[i]); printf("\n"); return 0; } int mostra_int(int v[], const char* tit) { if (tit != NULL) printf("%s\n", tit); printf("\tValores em decimal: "); for (int i = 0; i < 5; i += 1) printf("%d ", v[i]); printf("\n"); return 0; }  
 
Sobre seu código
 
 
porque só tem 4?
 
Está muito confuso como escreveu. Não entendi. Mas não está certo.

Note que na prática certamente seria preciso um parâmetro com o tamanho do array. Se o tamanho é sempre 5 deveria estar na declaração [5] e não [ ] 
 
Isso é só uma prova de conceito para ver como escrever.
 
Eis um exemplo de como escrever:
 
saida
 
Vetor de char original: Valores em char: '1' '2' '3' '4' '8' Vetor de 'int' convertido: Valores em decimal: 1 2 3 4 8 Vetor convertido (versão de um parametro): Valores em decimal: 1 2 3 4 8  
Código
 
#include <stdio.h> #include <stdlib.h> int* Converte(char[]); int converte(char origem[], int destino[]); int mostra_char(char[], const char*); int mostra_int(int[], const char*); int main(void) { char ent[5] = {'1', '2', '3', '4', '8'}; int sai[5] = {0}; mostra_char((int*) ent, "Vetor de char original:"); converte(ent, sai); mostra_int(sai, "Vetor de 'int' convertido:"); int* outro = Converte(ent); mostra_int( outro, "Vetor convertido (versão de um parametro):"); free(outro); // apaga return 0; } int* Converte(char origem[]) { int* destino = (int*)malloc(5 * sizeof(int)); if (destino == NULL) return NULL; for (int i = 0; i < 5; i += 1) *(destino + i) = origem[i] - '0'; return destino; } int converte(char origem[], int destino[]) { for (int i = 0; i < 5; i += 1) destino[i] = origem[i] - '0'; return 0; } int mostra_char(char v[], const char* tit) { if (tit != NULL) printf("%s\n", tit); printf("\tValores em char: "); for (int i = 0; i < 5; i += 1) printf("'%c' ", v[i]); printf("\n"); return 0; } int mostra_int(int v[], const char* tit) { if (tit != NULL) printf("%s\n", tit); printf("\tValores em decimal: "); for (int i = 0; i < 5; i += 1) printf("%d ", v[i]); printf("\n"); return 0; }  
 
Sobre seu código
 
 
porque só tem 4?
 
Está muito confuso como escreveu. Não entendi. Mas não está certo.

@Prodigy085 Eu escrevi uma versão de insert usando unique_ptr e vou deixar aqui.
 
No geral acho mesmo que o programa ficou menor e mais fácil de ler. Mas é um outro jeito de pensar, porque se por um lado dá uma paz na mente de não ter que pensar na ordem, dos destrutores, nos delete e em RAII. Por outro lado um erro na lógica e a estrutura toda some  
 
Esse exemplo é mais completo então sugiro marcar esse como resposta até aparecer uma resposta melhor, que pode ser o seu código revisado   
 
Veja a versão de insert()
 
int LinkedList::insert(Item data, size_t pos) { // insere 'data' na posicao pos if (pos > (1 + m_size)) return -1; // não da Upn novo(new Node(data)); if (pos < 2) { // aceita 0 ou 1 para o inicio novo->next.swap(m_head); m_head.swap(novo); // novo inicio m_size += 1; return 0; }; // avanca 'pos'- 2 Nodes Node* p = m_head.get(); // comeca aqui for (size_t i = 0; i < pos - 2; i += 1) p = p->next.get(); // salva o sucessor desse Upn temp = std::move(p->next); novo->next.swap(temp); p->next.swap(novo); // novo vem aqui m_size += 1; return 0; }  
que retorna -1 se a posição pedida é inválida.
 
Essa versão aceita 0 ou 1 para inserir no início e size()+1 para inserir no fim, porque sempre tem essa ambiguidade. Então se usar insert(,4) o novo registro vai ser o quarto e parece mais intuitivo assim. De todo modo é só um exemplo e é a minha versão.
 
Se existe insert(,n) então as outras ficam triviais...
 
Claro que insert(,1) ou insert(,0) inserem no início e insert(,1+size()) insere no fim então dá para escrever push_front() e push_back() para inserir no início e no fim da lista como esperado, usando insert():
 
int LinkedList::push_back(Item data) { // insere no final return insert(data, 1 + m_size); } int LinkedList::push_front(Item data) { // insere no inicio return insert(data, 1); }  
O código
 
node.h
 
#ifndef NODE_H #define NODE_H #include <iostream> #include <memory> #include <string> using Item = std::string; struct Node { Item data; std::unique_ptr<Node> next; explicit Node(Item& d) : data(d) { next.release(); } ~Node() { std::cerr << "Destruindo Node \"" << data << "\"\n"; } friend std::ostream& operator<<( std::ostream& out, const Node& node) { out << "(" << node.data << ")\n"; return out; } }; #endif  
LinkedList.h
 
#ifndef LINKEDLIST_H #define LINKEDLIST_H #include <iostream> #include <optional> using namespace std; #include "Node.h" using Ost = std::ostream; using Upn = std::unique_ptr<Node>; class LinkedList { private: Upn m_head; size_t m_size; public: LinkedList(); ~LinkedList(); public: void clear(); bool empty(); int insert(Item data, size_t pos); [[nodiscard]] optional<Item> pop_back(); [[nodiscard]] optional<Item> pop_front(); int push_back(Item data); int push_front(Item data); int size(); // para teste int cria_uns(size_t); friend Ost& operator<<(Ost& out, const LinkedList& l); }; #endif  
Inclui os atributos [[nodiscard]] --- C++17 --- em pop_back() e pop_front() para mostrar como a linguagem evolui e a razão das coisas.
Ao retirar um cara da lista se não colocar em algum lugar o compilador vai avisar. Porque isso é bom? Porque vai tirar um cara da lista e ele vai desaparecer. Pode muito bem ser um erro do programa.  E erros custam tempo e dinheiro.
 
Exemplo
 
cout << "\nTenta retirar o ultimo duas vezes\n"; auto ultimo = list.pop_back(); cout << "Ultimo: \"" << ultimo.value_or("Lista Vazia") << "\"\n"; ultimo = list.pop_back(); cout << "Ultimo: \"" << ultimo.value_or("Lista Vazia!") << "\"\n";  
Isso está certo e tira os 2 últimos caras da lista e mostra na tela. Está no exemplo e mostra algo assim
 
0014 (F I N A L +2) 0015 (F I N A L +3) ] Tenta retirar o ultimo duas vezes Destruindo Node "F I N A L +3" Ultimo: "F I N A L +3" Destruindo Node "F I N A L +2" Ultimo: "F I N A L +2"  
Claro que foi escrito com recortar e colar  . Mas e se por engano fosse digitado assim
 
cout << "\nTenta retirar o ultimo duas vezes\n"; auto ultimo = list.pop_back(); cout << "Ultimo: \"" << ultimo.value_or("Lista Vazia") << "\"\n"; list.pop_back(); cout << "Ultimo: \"" << ultimo.value_or("Lista Vazia!") << "\"\n";  
O programa ainda tira os dois caras, mas faltou atribuir o ítem extraido. Era pra ser ultimo = list.pop_back(); ao invés de list.pop_back(); só. E agora vai mostrar
 
0014 (F I N A L +2) 0015 (F I N A L +3) ] Tenta retirar o ultimo duas vezes Destruindo Node "F I N A L +3" Ultimo: "F I N A L +3" Destruindo Node "F I N A L +2" Ultimo: "F I N A L +3"  
repetindo o último valor errado... Claro que aqui fica óbvio porque o destrutor do Node é chamado automaticamente e mostra que o Node sendo apagado é outro. Mas o normal seria
 
0014 (F I N A L +2) 0015 (F I N A L +3) ] Tenta retirar o ultimo duas vezes Ultimo: "F I N A L +3" Ultimo: "F I N A L +3"  
E alguém vai ter que descobrir como acontece uma coisa dessas. E se fosse em outro ponto de um programa enorme podia custar horas até descobrir que na pressa alguém esqueceu de atribuir o valor extraído...
 
Com o uso desse atributo quando compila o programa aparece C4834:
 
mainv3.cpp(73,9): warning C4834: discarding return value of function with 'nodiscard' attribute e pelo menos avisa o programador de que algo POSSA estar errado. E aqui estava.
 
Em C++20
 
Em C++20 isso mudou e se pode até escrever a razão no aviso usando uma simples mensagem
 
[[nodiscard("não usar o valor extraido pode ser uma grande bobagem. eu avisei")]] optional<Item> pop_back();  
E ao compilar o compilador avisa
 
mainv3.cpp(73,9): warning C4858: discarding return value: não usar o valor extraido pode ser uma grande bobagem. eu avisei  
E não é que estava errado mesmo?  
 
De volta ao programa exemplo
 
Eis LinkedList.cpp 
 
// // sem o compilador certo não da para // usar <ranges> nem <format> // //#define CPP23__ #ifndef CPP23__ #include <cstdio> #else #include <format> #include <ranges> #endif #include <iostream> #include "LinkedList.h" LinkedList::LinkedList() : m_head(nullptr), m_size(0) { std::cerr << "Lista criada\n"; } LinkedList::~LinkedList() { std::cerr << "Lista destruida." " Os Nodes não tem mais dono\n"; } void LinkedList::clear() { m_size = 0; m_head.reset(); } bool LinkedList::empty() { return m_size == 0; } optional<Item> LinkedList::pop_back() { // retorna e extrai o ultimo if (empty()) return {}; // o simples if (m_size == 1) return pop_front(); // avanca ate o ultimo node Node* p = m_head.get(); // comeca aqui for (size_t i = 0; i < m_size - 2; i += 1) p = p->next.get(); Upn ultimo = std::move(p->next); m_size = m_size - 1; // ajusta return ultimo->data; // vai ser apagado a seguir } [[nodiscard]] optional<Item> LinkedList::pop_front() { if (empty()) return {}; Item primeiro = m_head->data; m_head.swap(m_head->next); m_size = m_size - 1; return primeiro; } int LinkedList::push_back(Item data) { // insere no final return insert(data, 1 + m_size); } int LinkedList::push_front(Item data) { // insere no inicio return insert(data, 1); } int LinkedList::size() { return m_size; } int LinkedList::insert(Item data, size_t pos) { // insere 'data' na posicao pos if (pos > (1 + m_size)) return -1; // não da Upn novo(new Node(data)); if (pos < 2) { // aceita 0 ou 1 para o inicio novo->next.swap(m_head); m_head.swap(novo); // novo inicio m_size += 1; return 0; }; // avanca 'pos'- 2 Nodes Node* p = m_head.get(); // comeca aqui for (size_t i = 0; i < pos - 2; i += 1) p = p->next.get(); // salva o sucessor desse Upn temp = std::move(p->next); novo->next.swap(temp); p->next.swap(novo); // novo vem aqui m_size += 1; return 0; } // essas duas funcoes dependem de <ranges> e <format> // e se não tiver isso usa C e sprintf() #ifndef CPP23__ Ost& operator<<(Ost& out, const LinkedList& l) { out << "(" << l.m_size << " Elementos)\n"; if (l.m_size == 0) return out; out << "[\n"; Node* p = l.m_head.get(); char num[10]{}; for (size_t i = 1; i <= l.m_size; i += 1) sprintf(num, "%04d\t", i), out << "\t" << string(num) << *p, p = p->next.get(); out << "]\n"; return out; } int LinkedList::cria_uns(size_t qtd) { // cancela se a lista não estiver vazia if ((m_size != 0) || (qtd == 0)) return -1; // sem sentido char item[20]{}; for (size_t i = 1; i <= qtd; i += 1) sprintf(item, "Item %06d", i), push_back(string(item)); return 0; } #else Ost& operator<<(Ost& out, const LinkedList& l) { out << "(" << l.m_size << " Elementos)\n"; if (l.m_size == 0) return out; out << "[\n"; Node* p = l.m_head.get(); for (int i = 1; i <= l.m_size; i += 1) out << "\t" << std::format("{:0>4}\t", i) << *p, p = p->next.get(); out << "]\n"; return out; }; int LinkedList::cria_uns(size_t qtd) { // cancela se a lista não estiver vazia if ((m_size != 0) || (qtd == 0)) return -1; // sem sentido for (auto i : std::views::iota(0, (int)qtd)) push_back(std::format("Item {:0>6}", qtd - i)); return 0; } #endif  
E o código do teste
 
#include <iostream> #include "LinkedList.h" using namespace std; int main(void) { LinkedList list; cout << list; cout << "Tentando extrair primeiro valor = " << list.pop_back().value_or("[Lista Vazia]") << "\n"; // chama insert na lista vazia cout << "Tenta inserir terceiro elemento\n"; auto res = list.insert("Item 000000", 3); cout << "retornou " << res << "\n"; cout << list; cout << "Tenta inserir na posicao 0\n"; list.insert("Item 0", 0); cout << list; cout << "Tenta retirar o primeiro duas vezes\n"; auto primeiro = list.pop_front(); cout << "Primeiro: \"" << primeiro.value_or("Lista Vazia") << "\"\n"; primeiro = list.pop_front(); cout << "Primeiro: \"" << primeiro.value_or("Lista Vazia!") << "\"\n"; // insere 4 e lista auto t = 7; cout << "Inserindo " << t << " elementos:\n"; list.cria_uns(t); cout << list; // insere um cara no inicio cout << "\nTenta inserir no inicio\n"; list.insert("No inicio", 0); cout << list; cout << "\nTenta inserir de novo no inicio\n"; list.insert("Novo inicio", 1); cout << list; cout << "\nTenta inserir no final\n"; list.insert("F I N A L", list.size()); cout << list; cout << "\nTenta inserir +1 no final\n"; list.insert("F I N A L +1", list.size()); cout << list; cout << "\nTenta inserir depois do final\n"; list.insert("F I N A L +2", 1 + list.size()); cout << list; cout << "\nTenta inserir depois do final\n"; list.insert("F I N A L +3", 1 + list.size()); cout << list; cout << "\nTenta inserir um segundo registro\n"; list.insert("SEGUNDO REGISTRO", 2); cout << list; cout << "\nTenta inserir um quinto registro\n"; list.insert("QUINTO REGISTRO", 5); cout << list; cout << "\nTenta retirar o ultimo duas vezes\n"; auto ultimo = list.pop_back(); cout << "Ultimo: \"" << ultimo.value_or("Lista Vazia") << "\"\n"; ultimo = list.pop_back(); cout << "Ultimo: \"" << ultimo.value_or("Lista Vazia!") << "\"\n"; // clear() // tenta apagar todo mundo no automatico cout << "\n====> testando clear()\n"; list.clear(); cout << "\n====> retornou de clear()\n"; cout << list; // vazia claro return 0; }  
E a saída do EXEMPLO
 
Lista criada (0 Elementos) Tentando extrair primeiro valor = [Lista Vazia] Tenta inserir terceiro elemento retornou -1 (0 Elementos) Tenta inserir na posicao 0 (1 Elementos) [ 0001 (Item 0) ] Tenta retirar o primeiro duas vezes Primeiro: "Item 0" Primeiro: "Lista Vazia!" Inserindo 7 elementos: (7 Elementos) [ 0001 (Item 000001) 0002 (Item 000002) 0003 (Item 000003) 0004 (Item 000004) 0005 (Item 000005) 0006 (Item 000006) 0007 (Item 000007) ] Tenta inserir no inicio (8 Elementos) [ 0001 (No inicio) 0002 (Item 000001) 0003 (Item 000002) 0004 (Item 000003) 0005 (Item 000004) 0006 (Item 000005) 0007 (Item 000006) 0008 (Item 000007) ] Tenta inserir de novo no inicio (9 Elementos) [ 0001 (Novo inicio) 0002 (No inicio) 0003 (Item 000001) 0004 (Item 000002) 0005 (Item 000003) 0006 (Item 000004) 0007 (Item 000005) 0008 (Item 000006) 0009 (Item 000007) ] Tenta inserir no final (10 Elementos) [ 0001 (Novo inicio) 0002 (No inicio) 0003 (Item 000001) 0004 (Item 000002) 0005 (Item 000003) 0006 (Item 000004) 0007 (Item 000005) 0008 (Item 000006) 0009 (F I N A L) 0010 (Item 000007) ] Tenta inserir +1 no final (11 Elementos) [ 0001 (Novo inicio) 0002 (No inicio) 0003 (Item 000001) 0004 (Item 000002) 0005 (Item 000003) 0006 (Item 000004) 0007 (Item 000005) 0008 (Item 000006) 0009 (F I N A L) 0010 (F I N A L +1) 0011 (Item 000007) ] Tenta inserir depois do final (12 Elementos) [ 0001 (Novo inicio) 0002 (No inicio) 0003 (Item 000001) 0004 (Item 000002) 0005 (Item 000003) 0006 (Item 000004) 0007 (Item 000005) 0008 (Item 000006) 0009 (F I N A L) 0010 (F I N A L +1) 0011 (Item 000007) 0012 (F I N A L +2) ] Tenta inserir depois do final (13 Elementos) [ 0001 (Novo inicio) 0002 (No inicio) 0003 (Item 000001) 0004 (Item 000002) 0005 (Item 000003) 0006 (Item 000004) 0007 (Item 000005) 0008 (Item 000006) 0009 (F I N A L) 0010 (F I N A L +1) 0011 (Item 000007) 0012 (F I N A L +2) 0013 (F I N A L +3) ] Tenta inserir um segundo registro (14 Elementos) [ 0001 (Novo inicio) 0002 (SEGUNDO REGISTRO) 0003 (No inicio) 0004 (Item 000001) 0005 (Item 000002) 0006 (Item 000003) 0007 (Item 000004) 0008 (Item 000005) 0009 (Item 000006) 0010 (F I N A L) 0011 (F I N A L +1) 0012 (Item 000007) 0013 (F I N A L +2) 0014 (F I N A L +3) ] Tenta inserir um quinto registro (15 Elementos) [ 0001 (Novo inicio) 0002 (SEGUNDO REGISTRO) 0003 (No inicio) 0004 (Item 000001) 0005 (QUINTO REGISTRO) 0006 (Item 000002) 0007 (Item 000003) 0008 (Item 000004) 0009 (Item 000005) 0010 (Item 000006) 0011 (F I N A L) 0012 (F I N A L +1) 0013 (Item 000007) 0014 (F I N A L +2) 0015 (F I N A L +3) ] Tenta retirar o ultimo duas vezes Destruindo Node "F I N A L +3" Ultimo: "F I N A L +3" Destruindo Node "F I N A L +2" Ultimo: "F I N A L +2" ====> testando clear() Destruindo Node "Novo inicio" Destruindo Node "SEGUNDO REGISTRO" Destruindo Node "No inicio" Destruindo Node "Item 000001" Destruindo Node "QUINTO REGISTRO" Destruindo Node "Item 000002" Destruindo Node "Item 000003" Destruindo Node "Item 000004" Destruindo Node "Item 000005" Destruindo Node "Item 000006" Destruindo Node "F I N A L" Destruindo Node "F I N A L +1" Destruindo Node "Item 000007" ====> retornou de clear() (0 Elementos) Lista destruida. Os Nodes não tem mais dono  
Claro que é só recortar e colar muitas vezes.
 
 

mas não usou nenhuma das sugestões
 
E o programa não funciona como escreveu e marcou como solução. Você escreveu um programa em C praticamente. E se o cara digitar "123456teste"? testou isso? Acho que não. "123456"? Acho que não.
 
Use o botão code como explicado no primeiro post do forum.
 
Veja a diferença
 
#include <iostream> using namespace std; int main() { char num[5]; int i, comp[5]; bool flag; do { flag = false; cout << "Digite somente numeros de ate 5 digitos: " << endl; cin >> num; for (i = 0; i < 5; i++) { comp[i] = num[i]; if (comp[i] < 48 || comp[i] > 57) { flag = true; } } } while (flag == true); cout << num << endl; return 0; }  
Tente algo assim
 
#include <iostream> #include <string> using namespace std; int main(void) { string linha; unsigned num = 0; cout << "Digite um numero sem sinal de ate 5 digitos\n\n"; while (true) { cout << "\tNumero: "; getline(cin, linha); if (cin.fail()) return(-1); if (cin.bad()) continue; if ((linha.size() == 0) or (linha.size() > 5)) continue; auto alguma_letra = false; for (auto i = 0; i < linha.size(); i += 1) if ((linha[i] < '0') || (linha[i] > '9')) { alguma_letra = true; break; } if (alguma_letra) continue; // le de novo num = atoi(linha.c_str()); //converte break; }; cout << "\n\tNumero: " << num << "\n"; return 0; }  

Se vai ordenar a lista in-place, ordenando a própria lista e não retornando outra ordenada, talvez seja melhor simplesmente modificar insere() e já inserir na ordem. Afinal se depois de classificar usar uma de suas outras funções de inserção vai zoar a classificação de todo modo e a única maneira de garantir que vai estar em ordem é classificar toda hora...
 
Sobre a classificação o simples é uma função de comparação entre dois nós. No seu caso o dado é um simples número.
 
É provavelmente melhor usar um ponteiro no nó e não o dado. Assim pode ter mais listas apontando para os mesmos dados, por exemplo.
 
Evite retornar void. Em geral é um desperdício. Muitas vezes um erro mesmo. USe parâmetros e retorne resultados. Por exemplo, criar lista deveria retornar o endereço de uma lista. 
 
LISTA* li = (LISTA*)malloc(sizeof(LISTA)); if (li == NULL) { printf("Memory Allocation Error"); exit(-1); } else { startLISTA(li);  
por exemplo estaria bem melhor como
 
LISTA* li = startLISTA();