Enviado em 05/11/2022 - 05:18h
Daniel2003 escreveu:
Boa tarde pessoal,
O código abaixo tem como objetivo mostrar qual quadrante que esta os determinados números em o usuário digitar, o meu problema esta no final do código, quando digitado "S" ou "s" o código não roda novamente.
Segue código:
#include <stdio.h>
Por que aqui você está comparando
x com
-4 ?
Eu diria que este
else pode imprimir informações erradas. Por exemplo se
x valer qualquer coisa negativa, e
y for exatamente zero, eu não sei se a coordenada estará no segundo ou no terceiro quadrante, mas com certeza o quadrante não será o quarto. Semelhantemente, se
x for exatamente zero e
y for positivo, eu não sei se a coordenada pode ser chamada de no primeiro ou no segundo quadrante, mas com certeza não será do quarto quadrante.
Recomendo rever as condições testadas acima. Infelizmente eu não lembro como devem ser considerados os casos em que um dos componentes do par ordenado é igual a zero. Segundo este
site (
https://brasilescola.uol.com.br/matematica/sistema-cartesiano-ortogonal.htm ) os eixos das abcissas (
y=0 ) e o eixo das ordenadas (
x=0 ) não fazem parte de nenhum quadrante. E creio ainda que a origem, que faz parte dos dois eixos (
x=0 e
y=0 ao mesmo tempo) é um caso ainda mias especial.
A função
scanf () (e suas correlatas
fscanf (),
sscanf () etc.) é uma das mais complexas da biblioteca padrão de funções do C. Eu recomendo que você leia a documentação da função com calma.
Resumidamente. algumas conversões, tais como as que leem números (
%d ,
%i ,
%x ,
%f , entre outras) ou blocos de caracteres que não são de espaço (
%s e relacionadas) fazem o descarte automático de espaços (espaço simples, tabulações e quebras de linha) que porventura antecedam o valor que provavelmente se quer ler, inciando a conversão propriamente dita assim que aparecer um caráter que não seja espaço, e interrompendo a leitura assim que aparecer novamente algum espaço ou caráter inválido no contexto da conversão (ou, caso você tenha especificado uma largura máxima de caracteres a serem convertidos, quando esse número de caracteres tiver sido consumido pela conversão). É importante lembrar que o eventual caráter que fez a conversão parar (ou aquele que vem após se ter alcançado a largura máxima da conversão) não são consumidos pela conversão, mas ficarão presentes no fluxo de leitura para a próxima operação de leitura ou conversão que porventura for solicitada pelo programa.
Já as conversões que leem caracteres individuais (como
%c ) ou blocos de texto que potencialmente conterão espaços (
%[ e correlatas) não fazem este mesmo descarte automático, justamente para que você tenha a possibilidade de extrair espaços que talvez lhe interessem como parte de dados relevantes de entrada.
A função permite que você indique que quer provocar manualmente o descarte de uma quantidade qualquer de espaços em branco. Para tanto, basta você colocar um espaço em branco como parte da
string de formatação que você passa como parâmetro à função. Esse recurso normalmente é usando antes de alguma conversão ou outro caráter não-espaço fixo que tenha de aparecer na entrada.
Quando, durante uma operação de leitura qualquer no terminal, você aperta a tecla
Enter (ou
Return , para quem usa Apple), isso provoca o aparecimento de um caráter de quebra de linha no fluxo de entrada. Esse caráter de quebra de linha é considerado na categoria de espaços em branco.
Se você tiver, por exemplo, um programa que, usando
scanf () com a conversão
"%d" , interage com o usuário pedindo, a cada interação, que ele digite um valor inteiro, e ele digitar, em cada uma dessas interações, um valor inteiro qualquer e imediatamente em seguida apertar
Enter , cada uma das operações de leitura vai começar fazendo o descarte automático de espaços que sobraram da interação anterior, vai converter o valor digitado pelo usuário, e vai deixar a quebra de linha correspondente à tecla
Enter para a próxima interação.
Esse mesmo programa, após ler todos os valores numéricos que lhe interessam, tem de lembrar que para a próxima operação de leitura provavelmente haverá uma quebra de linha pendente no fluxo de entrada. Se esse espaço não interessar e a próxima leitura não tiver descarte automático, o programador terá de providenciar o descarte explícito.
Conforme já indicado por um colega nosso em outra postagem, as comparações acima estão erradas, porque você está comparando um caráter (o valor de
d ) com valores de ponteiros para caracteres (i.e. os endereços em si, não o conteúdo que está armazenado nesses endereços).
Lembre sempre que caracteres individuais são representados entre apóstrofos (por exemplo:
's' ), ao passo que aspas são usadas para indicar sequências de caracteres, e que, quando essas sequências aparecem no programa, seu valor tem o tipo de dados de ponteiro para caracteres, usado para representar endereços de memória, não o conteúdo residente nesses endereços.
Esse tipo de erro, de comparar dados de tipos distintos de uma forma que não faz sentido, costuma ser indicado por compiladores modernos, desde que você não suprima nem ignore as mensagens que o compilador pode lhe enviar ao encontrar situações assim.
Caso você esteja usando um compilador semelhante ao GCC ou CLang, eu recomendo que você use sempre as opções de compilação
-Wextra -Werror -pedantic-errors -O2 , assim explicadas:
•
-Wextra : o compilador vai ser extremamente criterioso no diagnóstico e alerta sobre código suspeito.
•
-Werror : o compilador vai tratar alertas como erros (forçando você a corrigir as situações causadoras).
•
-pedantic-errors : o compilador vai forçar a compilação a aderir mais rigidamente àquilo que o padrão da linguagem permite, limitando o uso de extensões específicas do compilador e construções especificamente vedadas no padrão, mesmo que o compilador de outro modo as aceitasse.
•
-O2 : habilita o segundo nível de otimização de código pelo compilador. Além de geralmente produzir código mais eficiente, tal eficiência frequentemente depende de análise do ciclo de vida de variáveis, e isso permite ao compilador identificar e alertar sobre situações em que uma variável pode acabar sendo usada sem ter sido previamente inicializada. Habilita também a identificação e o alerta sobre trechos de código que podem nunca ser alcançados (por exemplo: um bloco referente a
if ,
while ou
for cuja condição de controle seja sempre falsa).
Tendo dito isso, note que a lógica de avaliação acima (mesmo depois de você corrigir de
string para caráter individual) não reflete a pergunta que é apresentada ao usuário. Esta dá a entender que o programa só aceitará
S ou
N (ou
s ou
n ) como resposta, mas na prática você aceita qualquer valor, mas só repete a execução caso a resposta seja
S ou
s , interrompendo o programa com qualquer outra coisa que tenha sido digitada.
Minha sugestão é que ou você mude a pergunta (por exemplo, para algo como “
Digite 's' para executar novamente, ou qualquer outra coisa para sair. )”) ou que mantenha a pergunta, mas mude a lógica de validação da resposta, a fim de limitá-la apenas às alternativas que você indicou como respostas válidas, ciente de que essa eventual mudança pode implicar ter de repetir a pergunta, caso o usuário não responda de modo adequado.
Um comentário geral sobre o programa é que você construiu um programa interativo, mas não se preocupou muito com a validação dos dados lidos em cada interação com o usuário. Tudo bem que, nesta altura do seu aprendizado, o objetivo maior é treinar lógica e construção de algoritmos, mas é bom você já ir se acostumando com a dura realidade de que usuários cometem erros, e às vezes são deliberadamente mal-intencionados.
Considere o seguinte caso: com o seu programa do jeito como está imagine que, na primeira pergunta, o usuário responda digitando
S seguindo da tecla
Enter . O que vai acontecer? Eu não executei seu código aqui, mas eis o que a análise dele mostra (e fique à vontade para me corrigir, caso eu tenha me equivocado no que vai abaixo).
• Por terem sido declarados como variáveis automáticas dentro de
main , os valores iniciais de
x e de
y são desconhecidos.
• A primeira operação de leitura tenta converte um valor e armazená-lo em
x , mas como o usuário digitou um caráter inválido, esse caráter vai interromper a leitura sem que o valor de
x seja alterado, e o caráter inválido vai permanecer no fluxo de entrada.
• A segunda operação de leitura vai falhar pelo mesmo motivo, deixando
y com o mesmo valor desconhecido que tinha antes, e o caráter inválido vai permanecer no fluxo de entrada.
• A lógica de diagnóstico de quadrantes (que tem de ser corrigida, lembra?) vai imprimir um diagnóstico completamente espúrio, com base em dados numéricos de valores indeterminados.
• A leitura com a conversão
%c vai finalmente consumir a letra
S digitada pelo usuário. A quebra de linha vai permanecer no fluxo de leitura.
• Ao comparar o caráter lido com endereços de memória, provavelmente (certeza quase absoluta, pois muito dificilmente alguma das
strings vai residir num endereço de memória
83 , que é o valor inteiro correspondente ao caráter
S , de acordo com o ASCII) o resultado da comparação será falso, e o programa será encerrado.
A função
scanf () lhe fornece meios de perceber se os dados recebidos atendem ou não aquilo que você gostaria de ter. O principal mecanismo de validação de conversões bem sucedidas é o valor retornado pela função. Convém que você sempre o teste, para confirmar se alguma das conversões (pois pode haver mais de uma, num caso geral) pedidas na
string de formatação suas conversões pode ter falhado. Além disso, há maniras de embutir na
string formatação elementos que forçam a presença (ou a ausência) de caracteres específicos, bem como de lhe informar a contagem de caracteres consumidos até o momento.
Por exemplo, se eu quiser que o usuário digite apenas um valor numérico de ponto flutuante, sem ser precedido nem sucedido de nenhum outro caráter (nem mesmo espaços), a não ser uma quebra de linha imediatamente o número, eis uma possível maneira de fazer (ainda não perfeita, mas só para dar uma ideia). Se parece trabalhosa, é porque é complicado mesmo validar dados de entrada, especialmente quando o mesmo fluxo pode ser usado para ler diferentes elementos.
double x;
Note que
%n não é considerada uma conversão, embora provoque atribuição de valor de outro argumento, e portanto não afeta o valor retornado por
scanf () (no trecho acima, os valores retornados nas duas chamadas são atribuídos a
r ). Também conversões com atribuição de valor suprimida (i.e., aquelas com um asterisco após o sinal porcento (
"%*" )) também não incrementam o valor de retorno de
scanf ().
De novo a dica: leia a documentação de
scanf ().
Algo que pode ser feito para não ter de repetir essa complicação toda a cada leitura é encapsulá-la numa função que receba a mensagem a ser exibida e um ponteiro para a variável a ser modificada, e cuide, dentro de si, de fazer a validação, entregando ao usuário apenas a informação de se a leitura foi bem sucedida ou não.
#include <errno.h>
... Então Jesus afirmou de novo: “(...) eu vim para que tenham vida, e a tenham plenamente.” (João 10:7-10)
