C Problema com variável em que sempre da 0

Enzo Mathias · 20 de maio de 2020

Boa noite!

Sou iniciante em C e estou com dificuldade em uma atividade.

Sempre que executo minha variável "menornum" resulta em 0, o que estou fazendo de errado?

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

main()

{
    
    int num,soma=0,pares=0,impares=0,maiornum=0,menornum=0;

while(num!=-1){
//Ao inserir -1 o usuario encerra o laço de repetição
    printf("Digite um numero:");
    scanf("%d",&num);
    if(num>0){
    if(num%2==0){
        pares++;
}else{
        impares++;
    }soma=soma+num;
}if(num==0){
    maiornum=num;
    menornum=num;
    num++;
}else if(num==-1){
    break;
//Adicionando uma pausa no -1 para que o programa não use
//-1 como menor numero digitado    
}else if(num>maiornum){
    maiornum=num;
}else if(num<menornum){
    menornum=num;
}
}
    printf("\n Quantidade de numeros pares:%d\n",pares);
    printf("\n Quantidade de numeros impares:%d\n",impares);
    printf("\n A soma dos numeros e igual a:%d\n",soma);
    printf("\n Maior numero:%d\n",maiornum);
    printf("\n Menor numero:%d\n",menornum);
    getch();
}

devair1010 · 20 de maio de 2020

@Enzo Mathias você declarou essa variável com o valor zero , então qualquer numero maior que zero não fará diferença e ela não mudará o valor , experimente inicializar a variável menor_num com um valor alto tipo 9 999 .

Enzo Mathias · 20 de maio de 2020

@devair1010

Assim que executo o programa, a variável menornume aparece como 9999.

arfneto · 20 de maio de 2020

Você acabou de declarou num e não deu nenhum valor, e já testa no loop para ver se é diferente de -1. Não é uma boa prática.

Coloque valores explícitos em todos os casos.

e menornum?

Tentou testar usando números negativos?... Aposto que não.

Nesses casos, que são muito comuns, você tem duas opções:

pode começar por ler um valor FORA do loop e esse vai ser o menor e o maior, certo? Afinal será também o único, o mais verde, o menos colorido, qualquer coisa, já que será o único. E a partir daí entra no loop até ler -1. Se o cara digitar -1 de cara está então tudo certo.
Ou pode usar constantes que estão disponíveis para isso em limits.h. INT_MAX é o maior inteiro e INT_MIN é o menor então claro que
```
    int maiornum = INT_MIN;
    int menornum = INT_MAX;
```
resolvem seu problema se colocados na declaração dessas variáveis...

devair1010 · 20 de maio de 2020

@Enzo Mathias aqui funcionou bem veja

poste o seu código novamente e use o botão <> que está desenhado lá na barra de ferramentas da janela de postar

Enzo Mathias · 20 de maio de 2020

@arfneto Obrigado, irei tentar adicionar sua sugestão.

adicionado 0 minutos depois

@devair1010 Segue codigo:

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

main()

{
	
	int num,soma=0,pares=0,impares=0,maiornum=0,menornum=9999;

while(num!=-1){
//Ao inserir -1 o usuario encerra o laço de repetição
	printf("Digite um numero:");
	scanf("%d",&num);
	if(num>0){
	if(num%2==0){
		pares++;
}else{
		impares++;
	}soma=soma+num;
}if(num==0){
	maiornum=num;
	menornum=num;
	num++;
}else if(num==-1){
    break;
//Adicionando uma pausa no -1 para que o programa não use
//-1 como menor numero digitado    
}else if(num>maiornum){
	maiornum=num;
}else if(num<menornum){
	menornum=num;
}
}
    printf("\n Quantidade de numeros pares:%d\n",pares);
    printf("\n Quantidade de numeros impares:%d\n",impares);
    printf("\n A soma dos numeros e igual a:%d\n",soma);
    printf("\n Maior numero:%d\n",maiornum);
    printf("\n Menor numero:%d\n",menornum);
    getch();
}

devair1010 · 20 de maio de 2020

@Enzo Mathias seu código funcionou certo . não tem erro .

Enzo Mathias · 20 de maio de 2020

@devair1010 Eu testei aqui de novo e realmente esta funcionando.

Muito obrigado pela sua atenção, me ajudou demais!!

arfneto · 20 de maio de 2020

Sério?

Entre com dois números:

100.000 e 100.001 vai falhar

Entre com dois números:

-2 e -3 vai falhar

Eu te disse duas maneiras de resolver. Esta usando um

#include "conio.h"

para poder usar uma função dos anos 80

getch()

que é a mesma coisa que fgetc(0) e não pode usar um

#include "limits.h"

para usar as constantes de que te falei e ficar seguro de vai funcionar? Ou mesmo ler o primeiro valor fora do loop, que é algo bem trivial --- eu acho.

E não inicializou num, mesmo eu te mostrando que está errado?

Então... está certo.

adicionado 17 minutos depois

		if (num > 0) {
			if (num % 2 == 0) {
				pares++;
			}
			else {
				impares++;
			}soma = soma + num;
		}if (num == 0) {
			maiornum = num;
			menornum = num;
			num++;
		}
		else if (num == -1) {
			break;
			//Adicionando uma pausa no -1 para que o programa não use
			//-1 como menor numero digitado    
		}
		else if (num > maiornum) {
			maiornum = num;
		}
		else if (num < menornum) {
			menornum = num;
		}

Vendo melhor o programa, esse trecho está muito, mas muito confuso para um programa tão simples. A quantidade de if e else aí impressiona.

E aquela "pausa" no meio apenas mostra que a leitura está sendo feita no lugar errado... Uma condição definitiva e que tem um resumo final deve ser testada no fim e não no começo do loop...

arfneto · 20 de maio de 2020

@Enzo Mathias entendeu que não está funcionando?

Veja os dois programas abaixo. O da esquerda, como você escreveu. O da direita uma versão comum e que funciona

Veja que no caso a direita você lê um valor inicial, que pode ser -1 se o usuário resolver terminar logo antes só pra ver o que acontece. E prepara os valores de maior e menor...

E se entrar no loop o programa roda apenas 4 instruções para os 4 resultados, e lê o próximo valor.

É mais fácil de entender o que acontece. E o da esquerda ainda tem problemas, como eu disse

Enzo Mathias · 20 de maio de 2020

@arfneto Boa noite, tudo bem?

Como C esta sendo o meu primeiro contato com uma linguagem de programação, no primeiro momento achei que tinha resolvido meu problema, mas estava errado.

Ontem mesmo após perceber que ainda estava dando erro, fiz algumas mudanças. Acredito que agora esta melhor que antes e por enquanto não tive problemas.

Segue o código:

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

main()

{
    bool primeironum = true;
    int num=0;
    int soma=0;
    int pares=0;
    int impares=0;
    int maiornum=0;
    int menornum=0;

    while(num!=-1)
    {
        
	printf("Digite um numero:");
	scanf("%d",&num);

        //Ao inserir -1 encerra o laço de repetição
        if(num==-1){
            break;    
        }


	if(num>0){
	    if(num%2==0){
		pares++;
            } else {
		impares++;
	    }
            soma=soma+num;
        }
        
        if (primeironum == true){
            maiornum = num;
            menornum = num;
            primeironum = false;
        } else {

            if(num>maiornum){
	        maiornum=num;
            }
        
            if(num<menornum){
	        menornum=num;
            }

        }

    }

    printf("\n Quantidade de numeros pares: %d\n",pares);
    printf("\n Quantidade de numeros impares: %d\n",impares);
    printf("\n A soma dos numeros e igual a: %d\n",soma);
    printf("\n Maior numero: %d\n",maiornum);
    printf("\n Menor numero: %d\n",menornum);
    getch();
}

o que acha?

Pelo visto conseguimos resolver o mesmo problemas de vários jeitos diferentes, mas consegui entender onde estava errando e "consertar" meu código sem precisar refazer tudo.

Muito obrigado pela atenção que tem dado, isso me ajuda bastante.

arfneto · 20 de maio de 2020

Você entendeu o programa que está do lado direito? É mais simples ir por aquele caminho

14 minutos atrás, Enzo Mathias disse:

Pelo visto conseguimos resolver o mesmo problemas de vários jeitos diferentes

Exato. Mas há sempre as diretrizes da empresa, ou da escola, ou preferências pessoais e tudo.

E há critérios como eficiência e legibilidade que são menos subjetivos. E de correção.

Se você pensar nas leituras de seu programa vai ver que tem dois tipos de leitura: a primeira e as outras. A primeira vai iniciar os contadores se não optou pelo simples uso das contantes como te expliquei. E as outras são idênticas, exceto pelo fato de que se o cara teclar -1 você tem que sair do loop a menos que seja a última ação do loop e em seu caso não é.

Note que eu te mostrei duas maneiras de resolver essa questão de menor e maior e você não quer aceitar nem uma nem outra. E optou por testar TODA vez durante o loop se é o primeiro numero ou não.

Não é esperto testar a toda vez se é o primeiro. Depois do primeiro acontecer, e é o primeiro vai testar toda vez uma situação que nunca mais vai acontecer.

Fosse você meu aluno e perderia pontos aí pela inércia em não criar uma solução melhor que testar PELO PRIMEIRO durante o programa todo...

É muito mais simples e legível programar como está no código que te mostrei e que está do lado direito.

Se você ler o primeiro item em separado resolve os dois problemas: o iníco da sequência de maior/menor e o teste do primeiro já ser (-1). E ler no final do loop resolve o outro problema, que seria pular código dentro do loop porque leu um -1 e vai terminar. Mesmo que use um break para sair do loop vai fazer um teste a mais que é supérfluo.

     if (primeironum == true){
            maiornum = num;
            menornum = num;
            primeironum = false;
        } else {

            if(num>maiornum){
	        maiornum=num;
            }
        
            if(num<menornum){
	        menornum=num;
            }

E porque está processando apenas os números positivos de novo? Tem um outro enunciado que não mostrou? Acha que -2 não é par? Não pode somar -8? Pode.

E mantem o uso de getch() com um #include para uma biblioteca dos anos 80 para usar uma função só para parar o programa antes de terminar?

Enzo Mathias · 21 de maio de 2020

@arfneto Entendi completamente, que meu "exercício" simples precisa de uma solução tão simples quanto o mesmo, compreendi também o fato de não há necessidade alguma de testar todos os números que foram adicionas ao loop levando em conta o exemplo que você me deu.

1 hora atrás, arfneto disse:

E mantem o uso de getch() com um #include para uma biblioteca dos anos 80 para usar uma função só para parar o programa antes de terminar?

Estou utilizando uma biblioteca dos anos 80, simplesmente pelo fato de ter sido orientado pelo meu professor a utilizar a mesma, deste modo a primeiro momento entendi que era o certo a ser feito, já que me foi ensinado assim. Mas entrei aqui para apreender mais e conseguir alem.

Entendo as diversas opções de melhorias e otimizações disponíveis que possa utilizar para um único simples problema, acredito que o fato de estar apreendendo linguagem C "apenas por cima" meu professor tenha utilizados esses métodos, mas não utilizo isso como "desculpa".

Novamente, obrigado pelo tempo que disponibiliza para ajudar os outros!

arfneto · 21 de maio de 2020

Acho que vai se sair bem.

Entendeu que seu programa não funciona para números negativos? E entendeu que está testando sempre para ver se o primeiro é o primeiro, imagino...

Abaixo está uma versão mais comum para esse programa. Rode na sua máquina e compare se achar útil.

int main(int argc, char** argv)
{
	int soma = 0, pares = 0, impares = 0;
	int num = 0;
	printf("Digite um numero:");
	scanf("%d", &num);
	int maiornum = num;
	int menornum = num;
	while (num != -1)
	{	
		if (num % 2 == 0) // par
			pares++;
		else
			impares++; // impar
		soma = soma + num; // soma
		if (num > maiornum) maiornum = num;
		if (num < menornum) menornum = num;
		printf("Digite um numero:");
		scanf("%d", &num);
	};	// while()
	printf("\n Quantidade de numeros pares:%d\n", pares);
	printf("\n Quantidade de numeros impares:%d\n", impares);
	printf("\n A soma dos numeros e igual a:%d\n", soma);
	printf("\n Maior numero:%d\n", maiornum);
	printf("\n Menor numero:%d\n", menornum);
	fgetc(stdin);
}

AdrianoSiqueira · 21 de maio de 2020

Só passando para deixar minha versão :

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

int main() {
    const int flag = -1;

    int entrada = 0;
    int soma = 0;
    int quantidade = 0;
    int pares = 0;
    int impares = 0;

    int maior = INT_MIN;
    int menor = INT_MAX;

    do {
        printf("Digite um numero: ");
        scanf(" %i%*c", &entrada);

        if (entrada == flag) {
            break;
        }

        quantidade += 1;
        soma += entrada;

        if (entrada % 2 == 0) {
            pares += 1;
        } else {
            impares += 1;
        }

        if (entrada > maior) {
            maior = entrada;
        }

        if (entrada < menor) {
            menor = entrada;
        }
    } while (entrada != flag);

    if (quantidade == 0) {
        printf("[ I ] - Nao foi lido nenhum valor. \n");
    } else {
        printf("------------------------------------------ \n");
        printf("Quantidade: %i \n", quantidade);
        printf("      Soma: %i \n", soma);
        printf("     Pares: %i \n", pares);
        printf("   Impares: %i \n", impares);
        printf("     Maior: %i \n", maior);
        printf("     Menor: %i \n", menor);
        printf("------------------------------------------ \n");
    }

    return EXIT_SUCCESS;
}

arfneto · 21 de maio de 2020

do
{
    printf("Digite um numero: ");
    scanf(" %i%*c", &entrada);
    if (entrada == flag) break;
    {
        ...     
    } 
} while (entrada != flag);

@AdrianoSiqueira resumi acima o código do seu exemplo. Também poderia ser escrito como abaixo:

do
{
    printf("Digite um numero: ");
    scanf(" %i%*c", &entrada);
    if (entrada != flag)
    {
        ...
    }             
} while (entrada != flag);

Trata-se de um do-while-while talvez? Um loop com teste no início e no fim pela mesma variável.

É um while dentro de um do-while, porque reavalia a condição de saída do do-while logo no início do loop, lendo a variável de controle de novo, e as condições de saída são as mesmas:

    (entrada != flag)

Isso pode ser simplificado assim

    printf("Digite um numero: ");
    scanf(" %i%*c", &entrada);
    while (entrada != flag)
    {
        ...
        printf("Digite um numero: ");
        scanf(" %i%*c", &entrada);        
    }

E assim não teria dois testes para cada loop pelo mesmo valor. E não precisaria mais das contantes INT_MIN e INT_MAX.

Note que stdlib inclui limits então se inclui stdlib não precisa incluir limits.

E nesse caso basta incluir limits porque só está usando as duas constantes mesmo.

Simon Viegas · 21 de maio de 2020

Complementando:

@arfneto, sobre:

10 horas atrás, arfneto disse:


int main(int argc, char** argv)
{
	int soma = 0, pares = 0, impares = 0;
	int num = 0;
	printf("Digite um numero:");
	scanf("%d", &num);
	int maiornum = num;
	int menornum = num;
	while (num != -1)

Se o usuário informar -1 logo de início, o maior e o menor resultam em -1. No mínimo ficou estranho...

Sobre:

10 horas atrás, arfneto disse:


		if (num > maiornum) maiornum = num;
		if (num < menornum) menornum = num;

Ser menor ou ser maior são condições mutuamente excludentes para o contexto, ou seja: não tem como um número ser maior e ao mesmo tempo menor... logo, "pede" o uso do else.

Já no código @AdrianoSiqueira, como o maior e menor foram pré-inicializados, ficou "obrigado" a fazer uma dupla checagem sempre:

9 horas atrás, AdrianoSiqueira disse:


        if (entrada > maior) {
            maior = entrada;
        }

        if (entrada < menor) {
            menor = entrada;
        }

Pois o primeiro número válido será inicialmente o menor e o maior, OK... Entretanto, isso vai de contra a questão de ser algo "mutualmente excludente", ou seja: se for, por exemplo, inseridos 1.000.000 de números, sempre um maior que o outro, terão 999.999 checagens desnecessárias.

Sobre:

7 horas atrás, arfneto disse:

E assim não teria dois testes para cada loop pelo mesmo valor. E não precisaria mais das contantes INT_MIN e INT_MAX.

Não entendi... seria substituído por outras coisas ou não precisaria mais inicializar as variáveis?

Sobre:

7 horas atrás, arfneto disse:

Note que stdlib inclui limits então se inclui stdlib não precisa incluir limits.

Pelo que pesquisei rapidamente e entendi bem, parece que era para ocorrer isso mesmo:

, mas online não funcionou. Ex.:

Sobre:

8 horas atrás, arfneto disse:

E nesse caso basta incluir limits porque só está usando as duas constantes mesmo.

Pelo que eu vi, ainda online, o stdlib.h foi necessário para o valor retornado lá no final...:

Ou seja: pelo https://repl.it/languages/c, seria necessário incluir os dois.

arfneto · 21 de maio de 2020

3 horas atrás, Simon Viegas disse:

mas online não funcionou. Ex.

3 horas atrás, Simon Viegas disse:

Pelo que pesquisei rapidamente e entendi bem, parece que era para ocorrer isso mesmo

Essa é uma coisa interessante. Não imagino uma implementação de stdlib que não inclua limits. Basta pensar nas funções que estão na biblioteca padrão. Nunca usei um compilador online, mas é uma coisa interessante saber que isso pode acontecer. Obrigado por postar, @Simon Viegas

3 horas atrás, Simon Viegas disse:

Pelo que eu vi, ainda online, o stdlib.h foi necessário para o valor retornado lá no final.

Tem razão. Eu não tinha visto essa constante folclórica. O normal é usar stdlib.h e ela incluir claro limits porque é a biblioteca padrão e não é difícil imaginar que a biblioteca padão use constantes "padrão" como as estabelecidas em limits.h, E omo é difícil um programa desses que não use stdlib.h é raro usar limits.h diretamente, na prática.

3 horas atrás, Simon Viegas disse:

Não entendi... seria substituído por outras coisas ou não precisaria mais inicializar as variáveis?

Veja no código: ao entrar no loop a primeira variável se não for -1 é a menor e a maior e a fila anda. Basta declarar depois de ler o primeiro número, como está lá:

	printf("Digite um numero:");
	scanf("%d", &num);
	int maiornum = num;
	int menornum = num;
	while (num != -1)

É claro que você poderia escrever logo depois da leitura e não ver, como mostrou

3 horas atrás, Simon Viegas disse:

Se o usuário informar -1 logo de início, o maior e o menor resultam em -1. No mínimo ficou estranho...

Bastaria testar logo depois de ler o primeiro e encerrar o programa com uma mensagem de acordo, tipo "encerrando sem nenhum valor fornecido".

No entanto esse é um exemplo para estudantes e essa é uma condição limite. Achei mais importante mostrar que lendo o primeiro elemento antes e preparando tudo para entrar no while o loop em si fica mais simples, com instruções simples para cada objetivo, e a leitura no final e não no início como é tradição entre estudantes. Se encerrase ali o cara teria menos ainda chance de entender que fazendo assim o programa segue sem entrar no loop e sem criar artifícios como repetir testes e criar flags. Esse é um padrão recorrente como vai ver sempre aqui nos exercícios postados neste forum. Na dúvida entre do e while eis o que o iniciante escreve:

le o primeiro valor, pode pode ser algo como "deseja continuar?". Dentro do loop
logo em seguida vem o teste para ver se vai encerrar e o código que pula todo o loop
e depois vem o código normal

Isso quer dizer que vai repetir ao menos um teste para todos os ciclos, e vai ter algum tipo de seleção dentro do loop, um break ou um else gigante que inclui TODO o código normal do loop. Se eu me lembrar, quando ver o próximo desses casos vou te indicar. É divertido até.

Veja o exemplo do autor e do exemplo de @AdrianoSiqueira aqui.

Se entrar -1 no inicio fica claro estranho, mas já é estranho alguém rodar o programa para encerrar sem entrar nenhum número, e o resultado mostrado não é muito mais estranho que isso

Repetindo o exemplo

Não há dúvida de que -1 é ímpar, mas essa é uma condição limite: o cara desistiu do programa apenas. E claro que o certo seria ter dado uma mensagem de acordo, mas eu queria mostrar o genérico: se você preparar o loop assim o código fica mais simples e legível.

AdrianoSiqueira · 21 de maio de 2020

12 horas atrás, arfneto disse:
Isso pode ser simplificado assim
    printf("Digite um numero: ");
    scanf(" %i%*c", &entrada);
    while (entrada != flag)
    {
        ...
        printf("Digite um numero: ");
        scanf(" %i%*c", &entrada);        
    }
E assim não teria dois testes para cada loop pelo mesmo valor. E não precisaria mais das contantes INT_MIN e INT_MAX.

Realmente, porém o programa pede a mesma coisa em dois pontos diferentes (dentro e fora do loop). Pessoalmente eu não curto muito isso, acho que fica código repetido, sei lá....

12 horas atrás, arfneto disse:
Também poderia ser escrito como abaixo:
do
{
    printf("Digite um numero: ");
    scanf(" %i%*c", &entrada);
    if (entrada != flag)
    {
        ...
    }             
} while (entrada != flag);

Só não fiz assim unicamente por uma questão estética. Se eu colocasse o código dentro do if, o código teria três tabulações para direita ficando bem afastado da margem esquerda. Colocando fora, fica com apenas duas tabulações, deixando o código visualmente mais bonito (na minha opinião). Pessoalmente não gosto de afastar muito o código da margem, acho que dificulta a legibilidade.

arfneto · 21 de maio de 2020

4 horas atrás, Simon Viegas disse:

Ser menor ou ser maior são condições mutuamente excludentes para o contexto, ou seja: não tem como um número ser maior e ao mesmo tempo menor... logo, "pede" o uso do else

Sim, claro. Tem razão. Ou não.

Pense nesses casos:

os números entram em ordem decrescente. Nunca vai atualizar o maior, que vai ser o primeiro
os números entram em ordem crescente. Nunca vai atualizar o menor, que vai ser o primeiro
só tem um número: teria que executar os dois lados

Foi assim que começou o tópico afinal...

    if (num > maiornum)
        maiornum = num;
    else
        if(num <= menornum)
	        menornum = num;

Escrevendo como eu escrevi o else seria mais correto, porque essa questão já foi resolvida antes de entrar no loop.

Porque eu não escrevi assim?

Porque eu mudei a condição depois e não voltei ao loop. My bad.

Condição limite

E ainda sobra uma condição limite, que é o caso de cada número que se repete na série. Você tem que colocar o igual em um dos lados do else. Muitos programas assim falham porque o aluno usa só > e < e quando vem todos os números iguais o programa falha... Pensem nisso

AdrianoSiqueira · 21 de maio de 2020

@arfneto Sobre o cabeçalho limits.h. Eu uso Linux com GCC, se eu não adicionar ela eu não consigo acessar as constantes.

arfneto · 21 de maio de 2020

5 minutos atrás, AdrianoSiqueira disse:

Realmente, porém o programa pede a mesma coisa em dois pontos diferentes (dentro e fora do loop). Pessoalmente eu não curto muito isso, acho que fica código repetido, sei lá....

Tem razão. Mas o modo como escreveu, e que é o mais comum, repete o teste da condição final em todos os ciclos do loop. E fica mais difícil de ler porque é algo híbrido, um while-do-while pela condição que mostrei: a variável de controle do loop é redefinida logo no início de cada ciclo do próprio loop.

AdrianoSiqueira · 21 de maio de 2020

2 minutos atrás, arfneto disse:

Tem razão. Mas o modo como escreveu, e que é o mais comum, repete o teste da condição final em todos os ciclos do loop.

De fato. Eu até pensei em mudar o do-while por um while(true) para tirar a verificação redundante, mas sempre escuto que isso é feio de mais.

arfneto · 21 de maio de 2020

2 minutos atrás, AdrianoSiqueira disse:

Sobre o cabeçalho limits.h. Eu uso Linux com GCC, se eu não adicionar ela eu não consigo acessar as constantes.

Eu ia em testar isso no gcc no próximo programa que eu fosse escrever com ele. Eu quase não uso. Estranho mesmo nenhum programa da biblioteca padrão usar essas contantes. Recriaram esses valores dentro das rotinas por alguma razão. Obrigado por postar!

arfneto · 21 de maio de 2020

Esse problema envolve avaliar 3 coisas em uma série de números inteiros lida do teclado e terminada por -1

a distribuição dos pares e ímpares
a soma dos números
os limites: o maior e o menor número

Os erros mais comuns para o programa --- e que apareceram no tópico --- afetam muitos desses programas para iniciantes então acho que é algo útil para o forum.

Condições comuns de erro:

números muito grandes e o aluno achou que usar algo como 99999 resolveria para achar o maior e 0 para o menor
números negativos desprezados quando a entrada é um inteiro
série de constantes: com todos os números iguaizinhos e o aluno pega esse número como maior ou menor para sempre porque não salvou o maior e menor ao menos uma vez
séries crescentes ou decrescentes onde sempre entra para o maior ou menor e o outro lado da condição nunca é visitado

No geral o loop do programa deve avaliar as 3 condições e ler o próximo número. Pode ler antes ou depois e aí temos as condições que se viu aqui nos tópicos anteriores.

Como a maioria desses exercícios, a lógica é como a do comando for: inicialização, condição final do loop e teste.

O loop mínimo pode ser algo assim, e reflete claramente o enunciado. @AdrianoSiqueira note que se escrever assim não tem artifícios no loop, apenas a lógica do problema. E sequer precisa de constantes limite.

	while (num != -1)
	{	
		if (num % 2 == 0) // par
			pares++;
		else
			impares++; // impar
		soma = soma + num; // soma
		if (num > maiornum)
			maiornum = num; // maior
		else
		    if (num <= menornum) menornum = num; // menor
		printf("Digite um numero: ");
		scanf("%d", &num);
	};	// while()

Note que o segundo if só funciona se na inicialização se tiver considerado os valores de menor e maior ANTES de entrar no loop, ou vai falhar para séries crescentes ou decrescentes

Note que no segundo if um dos sinas tem que ter = ou vai falhar para séries constantes

Note que se não ler ao final do loop vai ter que acrescentar uma condição extra no início logo depois da leitura e que vai saltar todo o loop.

Se mudar a lógica para usar do{}while não vai mudar muito porque vai ter que saltar o loop de todo modo

,

Uma solução mínima incluindo o sugerido por @Simon Viegas , uma mensagem para o final prematuro e o else para o > <= com a ressalva que está acima: se não inicializar de acordo pode falhar para séries crescentes ou decrescentes...

Assim como está ok

int main(int argc, char** argv)
{
	int soma = 0, pares = 0, impares = 0;
	int num = 0;
	printf("Digite um numero: ");
	scanf("%d", &num);
	if (num == -1)
	{
		printf("Encerrando sem dados apresentados\n");
		return;
	}
	int maiornum = num; // o primeiro e o maior
	int menornum = num; // e o menor
	while (num != -1)
	{	
		if (num % 2 == 0) // par
			pares++;
		else
			impares++; // impar
		soma = soma + num; // soma
		if (num > maiornum)
			maiornum = num; // maior
		else
		    if (num <= menornum) menornum = num; // menor
		printf("Digite um numero: ");
		scanf("%d", &num);
	};	// while()
	printf("\n Quantidade de numeros pares:%d\n", pares);
	printf("\n Quantidade de numeros impares:%d\n", impares);
	printf("\n A soma dos numeros e igual a:%d\n", soma);
	printf("\n Maior numero:%d\n", maiornum);
	printf("\n Menor numero:%d\n", menornum);
	fgetc(stdin);
}

Alguns resultados

Digite um numero:-2
Digite um numero:-3
Digite um numero:2
Digite um numero:3
Digite um numero:-1

 Quantidade de numeros pares:2

 Quantidade de numeros impares:2

 A soma dos numeros e igual a:0

 Maior numero:3

 Menor numero:-3

 ---

 Digite um numero:-1
Encerrando sem dados apresentados

---

Digite um numero:-2
Digite um numero:-2
Digite um numero:-2
Digite um numero:-2
Digite um numero:3
Digite um numero:-1

 Quantidade de numeros pares:4

 Quantidade de numeros impares:1

 A soma dos numeros e igual a:-5

 Maior numero:3

 Menor numero:-2