C Tecla reservada para finalizar toda execução em C

Matheus Patrick · 18 de novembro de 2021

Estou tentando colocar a tecla "Esc" reservada, para que qualquer hora que o usuário teclar, o programa finalize! Tente fazer com o do{}while(**!=27); sendo o 27 a tecla reservada para Esc na tabela ASCII, e o * uma var do tipo char recebendo a função getch(); Mas único resultado que obtive foi termino de linha; abaixo uma das funções do programa do meu trabalho......

void login(){
    system("Color 0f");
    cabecalho_login();
    char user[15], pass[15], c, esc;//recebe usuario e senha digitados;
    int a=0;
    fflush(stdin);
    printf("Informe suas credenciais e aperte enter...\n\n");
    printf("Usuário: ");
    gets(user);
    fflush(stdin);
    printf("Senha: ");
    do{//para inserir mascara de senha;
        c=getch();
        if(isprint(c)){
            pass[a]=c;
            a++;
            printf("*");
        }else if(c==8&&a){
            pass[a]='\0';
            a--;
            printf("\b \b");
        }
    }while(c!=13);
    pass[a]='\0';
    FILE* arquivo;//verificação de login;
	FUNCIONARIO fun;
	arquivo = fopen("system_plug.txt", "rb");//r de read(leitura);
	if(arquivo == NULL){
		printf("\n\nErro na abertura do banco de dados, se o erro persistir consulte o suporte!\n\n\n");
	}else{
		while(fread(&fun, sizeof(FUNCIONARIO), 1, arquivo) == 1){//enquanto ele ainda achar uma linha a ser lida no arquivo, segue loop;
			if((strcmp(user, fun.user)==0)&&(strcmp(pass, fun.password)==0)){
                printf("\n\nSucesso!!!\n\n\n");
                system("Color 0a");
                Sleep(200);
                cadastro_pac();
			}else{
                printf("\n\nUsuário não encontrado na base. Favor verificar...\n\n\n");
                system("Color 0c");
                system("PAUSE");
                login();
			}
		}
	}
	fclose(arquivo);
}

quero que o usuário a qualquer momento, que teclar o esc, o programa finalize a função! Agradeço desde já...

arfneto · 18 de novembro de 2021

12 minutos atrás, Matheus Patrick disse:

quero que o usuário a qualquer momento, que teclar o esc, o programa finalize a função! Agradeço desde já...

Para parar a qualquer momento precisa de mais um thread de execução, monitorando o teclado enquanto o programa segue, como o sistema faz com o control-C.

Não basta usar isso durante a leitura? Desabilite o ECO e conforme o cara digita se for um ESC encerra e se não for processa e mostra a letra, como todo mundo.

Ou use mesmo control-C para encerrar o programa. e não ESC

Está usando Linux ou Windows?

POSTE um programa completo compilável

Matheus Patrick · 18 de novembro de 2021

Entendi a lógica citada, mas sou bem iniciante na linguagem e não sei como essas ações são feitas em C...

Segue código completo do arquivo

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>//para utilizar o getch();
#include <ctype.h>//para utilizar o isdigit();
#include <locale.h>//para poder usar caracteres especiais no terminal;
#include <string.h>
#include <time.h>//necessário para usar localtime() e struct tm no calculo de idade;
#include <windows.h>//para a função Sleep();
//--------------------------------------------------------------------------
typedef struct funcionario FUNCIONARIO;
struct funcionario{
	char user[30], password[15];
};
typedef struct data DATA;
struct data{
	int dia, mes, ano;
};
typedef struct endereco ENDERECO;
struct endereco{
	char rua[30], bairro[20], cidade[20], estado[3], numero[10], cep[10];
};
typedef struct paciente PACIENTE;
struct paciente{
	char nome[30], cpf[16], tell[15], email[50], lista_comorbidades[256];
	DATA nascimento, diagnostico;
	ENDERECO residencia;
};
//--------------------------------------------------------------------------
void cabecalho_bem_vindo();//prototipos das funções usadas;
void cabecalho_login();
void cabecalho_cadastro_fun();
void cabecalho_cadastro_pac();
void pre_login();
void login();
void cadastro_fun();
int so_numeros();//função que permite apenas numeros;
void cadastro_pac();
//--------------------------------------------------------------------------
int main(){
    setlocale(LC_ALL, "Portuguese");
    pre_login();
    //login();
    return 0;
}
void cabecalho_bem_vindo(){
    system("cls");
	printf("\n-------------------------------------------------------------------\n\n");
	printf("                      Bem Vindo ao PIM IV\n\n");
	printf("-------------------------------------------------------------------\n\n\n");
}
void cabecalho_login(){
    system("cls");
	printf("\n-------------------------------------------------------------------\n\n");
	printf("                              Login\n\n");
	printf("-------------------------------------------------------------------\n\n\n");
}
void cabecalho_cadastro_fun(){
    system("cls");
	printf("\n-------------------------------------------------------------------\n\n");
	printf("                     Cadastro de Funcionários\n\n");
	printf("-------------------------------------------------------------------\n\n\n");
}
void cabecalho_cadastro_pac(){
    system("cls");
	printf("\n-------------------------------------------------------------------\n\n");
	printf("                     Cadastro de Pacientes\n\n");
	printf("-------------------------------------------------------------------\n\n\n");
}
void pre_login(){
    FILE* arquivo;//verificação de login;
	arquivo = fopen("system_plug.txt", "rb");//r de read(leitura);
	if(arquivo == NULL){
		cadastro_fun();
	}
    cabecalho_bem_vindo();
    int opcao_selec;
    printf("Digite o numero correspondente a opção desejada e aperte enter...\n\n");
    printf("1 - login\n");
    printf("2 - Cadastrar novo Funcionário\n");
    printf("3 - Sair\n\n");
    opcao_selec=so_numeros();
    switch(opcao_selec){
        case 1:
            login();
        break;
        case 2:
            cadastro_fun();
        break;
        case 3:
            printf("\n\nMuito obrigado pela preferência!!!\n\n\n");
            exit(0);
        break;
        default:
            printf("\n\nOpção inválida!!!\n\n\n");
            system("PAUSE");
            pre_login();
        break;
    }
}
int so_numeros(){
    char digitado[50], c;
    int i=0, numero=0;
	do{
       c=getch();//captura o caractere digitado pelo usuário;
	   if (isdigit(c)!=0){//se for número;
          digitado[i] = c;//armazena no vetor de caracteres;
          i++;
          printf ("%c", c);//exibe o caractere digitado;
       }else if(c==8&&i){//se for pressionada a tecla BACKSPACE e houver caracteres já digitados;
          digitado[i]='\0';//o índice atual do vetor de caracteres recebe a terminação da string;
          i--;
          printf("\b \b");//o caractere digitado é apagado da tela;
       }
    }while(c!=13);//o loop vai ser executado até que a tecla pressionada seja o ENTER (código 13 na tabela ASCII);
    digitado[i]='\0';
    numero = atoi(digitado);//a variável numero recebe o valor do vetor de caracteres convertido para inteiro;
    return numero;
}
void login(){
    system("Color 0f");
    cabecalho_login();
    char user[15], pass[15], c, esc;//recebe usuario e senha digitados;
    int a=0;
    fflush(stdin);
    printf("Informe suas credenciais e aperte enter...\n\n");
    printf("Usuário: ");
    gets(user);
    fflush(stdin);
    printf("Senha: ");
    do{//para inserir mascara de senha;
        c=getch();
        if(isprint(c)){
            pass[a]=c;
            a++;
            printf("*");
        }else if(c==8&&a){
            pass[a]='\0';
            a--;
            printf("\b \b");
        }
    }while(c!=13);
    pass[a]='\0';
    FILE* arquivo;//verificação de login;
	FUNCIONARIO fun;
	arquivo = fopen("system_plug.txt", "rb");//r de read(leitura);
	if(arquivo == NULL){
		printf("\n\nErro na abertura do banco de dados, se o erro persistir consulte o suporte!\n\n\n");
	}else{
		while(fread(&fun, sizeof(FUNCIONARIO), 1, arquivo) == 1){//enquanto ele ainda achar uma linha a ser lida no arquivo, segue loop;
			if((strcmp(user, fun.user)==0)&&(strcmp(pass, fun.password)==0)){
                printf("\n\nSucesso!!!\n\n\n");
                system("Color 0a");
                Sleep(200);
                cadastro_pac();
			}else{
                printf("\n\nUsuário não encontrado na base. Favor verificar...\n\n\n");
                system("Color 0c");
                system("PAUSE");
                login();
			}
		}
	}
	fclose(arquivo);
}
void cadastro_fun(){
    system("Color 0f");
    FILE* arquivo;
	FUNCIONARIO fun;//fun de funcionario;
	cabecalho_cadastro_fun();
	if(arquivo == NULL){
		printf("\n\nErro na abertura do banco de dados, se o erro persistir consulte o suporte!\n\n\n");
	}else{
	    char verifique[11]="pim4chave1", key[11], user_temp[30];
	    fflush(stdin);
	    printf("\nInsira a chave KEY adquirida na obtenção do software: \n\n");
	    gets(key);
	    if(strcmp(verifique, key)==0){
            system("Color 0a");
            Sleep(150);
            system("Color 0f");
            do{
            int x=0;
			fflush(stdin);//buffer para limpar o teclado;
			system("cls");
			cabecalho_cadastro_fun();
			printf("Digite o nome de usuário: ");
			gets(user_temp);
			do{//laço que só termina quando as senhas coincidirem;
                char pass1[30], pass2[30], c, d;
                int a=0, b=0;
                fflush(stdin);
                printf("Digite a sua senha: ");
                do{//para inserir mascara de senha;
                    c=getch();
                    if(isprint(c)){//Analisa se o valor de c é imprimível;
                        pass1[a]=c;
                        a++;
                        printf("*");
                    }else if(c==8&&a){
                        pass1[a]='\0';
                        a--;
                        printf("\b \b");
                    }
                }while(c!=13);//13 é o valor de ENTER na tabela ASCII;
                pass1[a]='\0';
                fflush(stdin);
                printf("\nDigite a sua senha novamente: ");
                do{//para inserir mascara de senha;
                    d=getch();
                    if(isprint(d)){
                        pass2[b]=d;
                        b++;
                        printf("*");
                    }else if(d==8&&b){
                        pass2[b]='\0';
                        b--;
                        printf("\b \b");
                    }
                }while(d!=13);
                pass2[b]='\0';
                if ((strcmp(pass1, pass2)==0) && (strlen(pass1)!=0)){//comparo as senhas, e vejo se estão vazias;
                    strcpy(fun.password, pass2);
                    strcpy(fun.user, user_temp);
                    x=1;
                    arquivo = fopen("system_plug.txt", "ab");
                    fwrite(&fun, sizeof(FUNCIONARIO), 1, arquivo);
                    printf("\n\nFuncionário cadastrado com sucesso!!\n\n\n");
                }else{
                    printf("\n\nSenhas não coincidem ou há campos vazios, favor refazer...\n\n\n");
                }
			}while(x == 0);
                printf("Deseja realizar mais algum cadastro(s/n)?\n");
            }while(getche() == 's');
            fclose(arquivo);
            pre_login();
        }else{
            printf("\nA chave KEY informada esta incorreta! Favor verificar...\n\n");
            system("Color 0c");
            system("PAUSE");
            cadastro_fun();
        }
	}
}
void cadastro_pac(){
    system("Color 0f");
    FILE* arquivo;
    FILE* arquivo_envio;
    int diferenca_ano, diferenca_mes, diferenca_dia;
    char aux[8]="Nenhuma";
	PACIENTE pac;//pac de paciente;
	if(arquivo == NULL || arquivo_envio == NULL){
		printf("Erro na abertura do banco de dados, se o erro persistir consulte o suporte!\n\n");
	}else{
		do{
            char digitado[20], c, dia_filtro[3], mes_filtro[3], ano_filtro[5];
            int i=0, v=0;
            //--------------------------------------------------------------------------------------------------------
            system("cls");
            cabecalho_cadastro_pac();
            printf("\nInforme os dados pessoais do paciente:\n\n");     //Nome;
            do{//filtro que impede seguir com campos vazios;
                fflush(stdin);
                printf("Nome: ");
                gets(pac.nome);
                if(v>=0 && strlen(pac.nome)==0){//não se executa na primeira vez que roda e nem se for digitado;
                    printf("Campos vazios...\n");
                }
                v++;
            }while(strlen(pac.nome)==0);
            //--------------------------------------------------------------------------------------------------------
            v=0;                                                        //CPF;
            do{//filtro que impede seguir com campos vazios;
                if(v>0 && strlen(digitado)<11){
                    printf("\nCampos vazios...\n");
                }
                printf ("CPF: ");
                do{//mascara de CPF;
                   c=getch();
                   if (isdigit(c)!=0){
                      if (i < 11){
                          digitado[i] = c;
                          i++;
                          printf ("%c", c);
                          if (i == 3 || i == 6){
                              printf (".");
                          }else if(i == 9){
                            printf ("-");
                          }
                      }
                   }
                   else if(c==8&&i){
                      if (i==3 || i==6 || i==9){
                          printf("\b \b");
                          digitado[i]='\0';
                          i--;
                          printf("\b \b");
                      }else{
                            digitado[i]='\0';
                            i--;
                            printf("\b \b");
                      }
                   }
                }while(c!=13);
                digitado[i]='\0';
                v++;
                i=0;
                c=' ';
            }while(strlen(digitado)<11);
            strcpy(pac.cpf, digitado);
            //--------------------------------------------------------------------------------------------------------
            printf("\n");                                               //Telefone;
            v=0;
            i=0;
            c=' ';
            do{//filtro que impede seguir com campos vazios;
                if(v>=0 && strlen(digitado)<11){
                    printf("\nCampos vazios...\n");
                }
                printf ("Telefone: (");
                do{//mascara para celular com DD separado;
                   c=getch();
                   if (isdigit(c)!=0){
                      if (i < 11){
                          digitado[i] = c;
                          i++;
                          printf ("%c", c);
                          if(i==2){
                            printf (")");
                          }else if(i==7){
                            printf ("-");
                          }
                      }
                   }
                   else if(c==8&&i){
                      if (i==2 || i==7){
                          printf("\b \b");
                          digitado[i]='\0';
                          i--;
                          printf("\b \b");
                      }else{
                            digitado[i]='\0';
                            i--;
                            printf("\b \b");
                      }
                   }
                }while(c!=13);
                digitado[i]='\0';
                v++;
                i=0;
                c=' ';
            }while(strlen(digitado)<11);
            strcpy(pac.tell, digitado);
            //--------------------------------------------------------------------------------------------------------
            v=0;                                                            //Data de Nascimento;
            i=0;
            c=' ';
            do{//filtro que impede seguir com campos vazios;
                if(v>=0 && strlen(digitado)<8){
                    printf("\nCampos vazios...");
                }
                printf ("\nData de nascimento (Dia Mês Ano): ");
                do{//mascara para data;
                   c=getch();
                   if (isdigit(c)!=0){
                      if (i < 8){
                          digitado[i] = c;
                          i++;
                          printf ("%c", c);
                          if (i == 2 || i == 4){
                              printf ("/");
                          }
                      }
                   }
                   else if(c==8&&i){
                      if (i==2 || i==4){
                          printf("\b \b");
                          digitado[i]='\0';
                          i--;
                          printf("\b \b");
                      }else{
                            digitado[i]='\0';
                            i--;
                            printf("\b \b");
                      }
                   }
                }while(c!=13);//ENTER (código 13 na tabela ASCII);
                digitado[i]='\0';
                v++;
                i=0;
                c=' ';
            }while(strlen(digitado)<8);

            dia_filtro[0]=digitado[0];//convertendo e separando a data digitada;
            dia_filtro[1]=digitado[1];
            mes_filtro[0]=digitado[2];
            mes_filtro[1]=digitado[3];
            ano_filtro[0]=digitado[4];
            ano_filtro[1]=digitado[5];
            ano_filtro[2]=digitado[6];
            ano_filtro[3]=digitado[7];
            pac.nascimento.dia=atoi(dia_filtro);
            pac.nascimento.mes=atoi(mes_filtro);
            pac.nascimento.ano=atoi(ano_filtro);
            //--------------------------------------------------------------------------------------------------------
            v=0;                                                            //Email;
            printf("\n");
            do{//filtro que impede seguir com campos vazios;
                fflush(stdin);
                printf("E-mail: ");
                gets(pac.email);
                if(v>=0 && strlen(pac.email)==0){
                    printf("Campos vazios...\n");
                }
                v++;
            }while(strlen(pac.email)==0);
            //--------------------------------------------------------------------------------------------------------
            v=0;                                                            //Endereço>Rua;
            printf("\nAgora o endereço:\n");
            do{//filtro que impede seguir com campos vazios;
                fflush(stdin);
                printf("Rua: ");
                gets(pac.residencia.rua);
                if(v>=0 && strlen(pac.residencia.rua)==0){
                    printf("Campos vazios...\n");
                }
                v++;
            }while(strlen(pac.residencia.rua)==0);
            //--------------------------------------------------------------------------------------------------------
            v=0;                                                            //Endereço>Bairro;
            do{//filtro que impede seguir com campos vazios;
                fflush(stdin);
                printf("Bairro: ");
                gets(pac.residencia.bairro);
                if(v>=0 && strlen(pac.residencia.bairro)==0){
                    printf("Campos vazios...\n");
                }
                v++;
            }while(strlen(pac.residencia.bairro)==0);
            //--------------------------------------------------------------------------------------------------------
            v=0;                                                            //Endereço>Cidade;
            do{//filtro que impede seguir com campos vazios;
                fflush(stdin);
                printf("Cidade: ");
                gets(pac.residencia.cidade);
                if(v>=0 && strlen(pac.residencia.cidade)==0){
                    printf("Campos vazios...\n");
                }
                v++;
            }while(strlen(pac.residencia.cidade)==0);
            //--------------------------------------------------------------------------------------------------------
            v=0;                                                            //Endereço>Estado;
            i=0;
            c=' ';
            do{
                if(v>0 && strlen(digitado)<2){
                    printf("\nCampos vazios...\n");
                }

                printf ("Estado(Sigla): ");
                do{//limitando o usuario a digitar apenas a sigla do estado;
                   c=getch();
                   if (isalpha(c)!=0){//se for letra;
                      if (i < 2){
                          digitado[i] = c;
                          i++;
                          printf ("%c", c);
                      }
                   }
                   else if(c==8&&i){
                            digitado[i]='\0';
                            i--;
                            printf("\b \b");
                   }
                }while(c!=13);
                digitado[i]='\0';
                v++;
                i=0;
                c=' ';
            }while(strlen(digitado)<2);

			strcpy(pac.residencia.estado, digitado);
            for(i=0; i<strlen(pac.residencia.estado); i++){// Converte para maiusculas;
             pac.residencia.estado[i] = toupper (pac.residencia.estado[i]);
            }
            //--------------------------------------------------------------------------------------------------------
            printf("\n");                                                   //Endereço>Número;
            v=0;
            do{//filtro que impede seguir com campos vazios;
                fflush(stdin);
                printf("Número: ");
                gets(pac.residencia.numero);
                if(v>=0 && strlen(pac.residencia.numero)==0){
                    printf("Campos vazios...\n");
                }
                v++;
            }while(strlen(pac.residencia.numero)==0);
            //--------------------------------------------------------------------------------------------------------
            v=0;                                                              //Endereço>CEP;
            i=0;
            c=' ';
            do{//filtro que impede seguir com campos vazios;
                if(v>0 && strlen(digitado)<8){
                    printf("\nCampos vazios...\n");
                }
                printf("CEP: ");
                do{//filtro de cep;
                   c=getch();
                   if (isdigit(c)!=0){
                      if (i < 8){
                          digitado[i] = c;
                          i++;
                          printf ("%c", c);
                          if (i == 5){
                              printf ("-");
                          }
                      }
                   }
                   else if(c==8&&i){
                      if (i==5){
                          printf("\b \b");
                          digitado[i]='\0';
                          i--;
                          printf("\b \b");
                      }else{
                            digitado[i]='\0';
                            i--;
                            printf("\b \b");
                      }
                   }
                }while(c!=13);
                digitado[i]='\0';
                i=0;
                c=' ';
                v++;
            }while(strlen(digitado)<8);
            strcpy(pac.residencia.cep, digitado);
            //--------------------------------------------------------------------------------------------------------
			i=0;                                                            //Data Diagnóstico;
            c=' ';
            v=0;
            printf ("\nSobre o diagnóstico:\n");
            do{//filtro que impede seguir com campos vazios;
                if(v>0 && strlen(digitado)<8){
                    printf("\nCampos vazios...\n");
                }
                printf ("Data (Dia Mês Ano): ");
                do{//mascara para data;
                   c=getch();
                   if (isdigit(c)!=0){
                      if (i < 8){
                          digitado[i] = c;
                          i++;
                          printf ("%c", c);
                          if (i == 2 || i == 4){
                              printf ("/");
                          }
                      }
                   }
                   else if(c==8&&i){
                      if (i==2 || i==4){
                          printf("\b \b");
                          digitado[i]='\0';
                          i--;
                          printf("\b \b");
                      }else{
                            digitado[i]='\0';
                            i--;
                            printf("\b \b");
                      }
                   }
                }while(c!=13);//ENTER (código 13 na tabela ASCII);
                digitado[i]='\0';//convertendo e separando a data digitada;
                c=' ';
                i=0;
                v++;
            }while(strlen(digitado)<8);

            dia_filtro[0]=digitado[0];
            dia_filtro[1]=digitado[1];
            mes_filtro[0]=digitado[2];
            mes_filtro[1]=digitado[3];
            ano_filtro[0]=digitado[4];
            ano_filtro[1]=digitado[5];
            ano_filtro[2]=digitado[6];
            ano_filtro[3]=digitado[7];
            pac.diagnostico.dia=atoi(dia_filtro);
            pac.diagnostico.mes=atoi(mes_filtro);
            pac.diagnostico.ano=atoi(ano_filtro);
            //--------------------------------------------------------------------------------------------------------
            printf("\nPaciente possui alguma comorbidade(s/n)? ");              //comordidades;
            if(getche() == 's'){
                printf("\n\nDescreva elas usando uma ',' como separador: \n\n");
                gets(pac.lista_comorbidades);
            }else{
                strcpy(pac.lista_comorbidades, aux);
            }
            //--------------------------------------------------------------------------------------------------------
            arquivo = fopen("cadastro_pacientes_diagnosticados.txt", "at");//t de arquivo em texto;
            fprintf(arquivo, "---------------------------------------------------------------------------------------------------------------------------------");
            fprintf(arquivo, "\nNome: %s\n", pac.nome);
            fprintf(arquivo, "\nCPF: %s", pac.cpf);
            fprintf(arquivo, "\nCelular: %s", pac.tell);
            fprintf(arquivo, "\nData de nascimento: %d/%d/%d", pac.nascimento.dia, pac.nascimento.mes, pac.nascimento.ano);
            fprintf(arquivo, "\nE-mail: %s\n", pac.email);
            fprintf(arquivo, "\nCEP: %s", pac.residencia.cep);
            fprintf(arquivo, "\nRua: %s - nº: %s", pac.residencia.rua, pac.residencia.numero);
            fprintf(arquivo, "\nBairro: %s", pac.residencia.bairro);
            fprintf(arquivo, "\nCidade: %s - %s\n", pac.residencia.cidade, pac.residencia.estado);
            fprintf(arquivo, "\nData de Diagnóstico: %d/%d/%d", pac.diagnostico.dia, pac.diagnostico.mes, pac.diagnostico.ano);
            fprintf(arquivo, "\nComorbidades: ( %s ).", pac.lista_comorbidades);
            fprintf(arquivo, "\n---------------------------------------------------------------------------------------------------------------------------------\n\n");
            printf("\n\nPaciente cadastrado com sucesso!!!\n\n");
                                                        //Filtragem p/ envio...
            struct tm *data_atual;//ponteiro para struct que armazena data e hora atual;
            time_t segundos;//variável do tipo time_t para armazenar o tempo em segundos;
            time(&segundos);//obtendo o tempo em segundos;
            data_atual = localtime(&segundos);//para converter de segundos para o tempo local utilizamos a função localtime;
            int idade_atual;
            diferenca_ano = (data_atual->tm_year+1900) - pac.nascimento.ano;
            diferenca_mes = pac.nascimento.mes - (data_atual->tm_mon+1);//caso já tenha passado do mês, ficará negativo;
            diferenca_dia = pac.nascimento.dia - (data_atual->tm_mday);//caso já tenha passado do dia, ficará negativo;
            if((diferenca_dia<=0&&diferenca_mes<=0&&diferenca_ano>=65)||(diferenca_ano>65)||(diferenca_mes<0&&diferenca_ano>=65)){
                if(strcmp(pac.lista_comorbidades, aux)!=0){//registrando em arquivo para envio;
                    if((diferenca_dia<=0&&diferenca_mes<=0)||(diferenca_mes<0)){//calculo de idade;
                        idade_atual=diferenca_ano;
                    }else{
                        idade_atual=diferenca_ano-1;
                    }
                    arquivo_envio = fopen("Enviar para Secretária de Saúde.txt", "at");//append + text;
                    fprintf(arquivo_envio, "-----------------------------------------------");
                    fprintf(arquivo_envio, "\nIdade: %d", idade_atual);
                    fprintf(arquivo_envio, "\nCEP: %s", pac.residencia.cep);
                    fprintf(arquivo_envio, "\n-----------------------------------------------\n\n");
                    printf("Há novos registros prontos a serem enviados!!!\nApós o envio favor apagar o arquivo para evitar duplicatas.");
                }
            }
            printf("\n\nDeseja cadastrar novo Paciente(s/n)?\n");
		}while(getche() == 's');
        fclose(arquivo_envio);
		fclose(arquivo);
	}
}

(é um projeto para faculdade)...

o código em si é bem grande, então demonstrando como é feito em uma função eu posso fazer para as demais... agradeço a ajuda!!!

arfneto · 18 de novembro de 2021

14 minutos atrás, Matheus Patrick disse:

Entendi a lógica citada, mas sou bem iniciante na linguagem e não sei como essas ações são feitas em C...

Então esqueça o lance de multi-threading --- que é apenas o caso em que seu programa roda várias funções ao mesmo temo, cada uma com seu ambiente de execução --- e se concentre no lance de cancelar durante a leitura da senha ao entrar um escape.

De todo modo seria apenas mais uma maneira de cancelar o programa, já que o sistema trata control-C por si só..

Seu programa está incrivelmente complicado não precisa e não devia usar essas coisas todas.

Escreva em torno dos dados.

E não use void x(void); Isso é um buraco negro e só dificulta seu programa. NUNCA use globais, mesmo porque são proibidas em toda parte e vão te custar notas e empregos

Seu programa gira em torno de um cadastro de pacientes e de funcionários mas não tem uma estrutura para o cadastro. Claro que isso vai te trazer problemas.

Nunca use conio. Isso é dos anos 80 e de nada serve hoje em dia.

23 minutos atrás, Matheus Patrick disse:

            arquivo = fopen("cadastro_pacientes_diagnosticados.txt", "at");//t de arquivo em texto;
            fprintf(arquivo, "---------------------------------------------------------------------------------------------------------------------------------");
            fprintf(arquivo, "\nNome: %s\n", pac.nome);
            fprintf(arquivo, "\nCPF: %s", pac.cpf);
            fprintf(arquivo, "\nCelular: %s", pac.tell);
            fprintf(arquivo, "\nData de nascimento: %d/%d/%d", pac.nascimento.dia, pac.nascimento.mes, pac.nascimento.ano);
            fprintf(arquivo, "\nE-mail: %s\n", pac.email);
            fprintf(arquivo, "\nCEP: %s", pac.residencia.cep);
            fprintf(arquivo, "\nRua: %s - nº: %s", pac.residencia.rua, pac.residencia.numero);
            fprintf(arquivo, "\nBairro: %s", pac.residencia.bairro);
            fprintf(arquivo, "\nCidade: %s - %s\n", pac.residencia.cidade, pac.residencia.estado);
            fprintf(arquivo, "\nData de Diagnóstico: %d/%d/%d", pac.diagnostico.dia, pac.diagnostico.mes, pac.diagnostico.ano);
            fprintf(arquivo, "\nComorbidades: ( %s ).", pac.lista_comorbidades);
            fprintf(arquivo, "\n---------------------------------

Não escreva assim. Um único fprintf() de 13 linhas é dezenas de vezes mais rápido e mais esperto que 13 fpritntf() de uma linha.

E não precisa de um arquivo texto. Isso é só problema. Escreva em torno dos dados e entenda que seu arquivo é de Pacientes e poderia gravar em uma linha só...

Compare com algo assim:

    Paciente* paciente;
    fwrite(paciente, sizeof(Paciente), 1, arquivo);

E acho que entende a diferença.

Matheus Patrick · 18 de novembro de 2021

Caracassss, SUPER ACEITO todas as dicas e já irei fazer estas modificações!!!! Muito obrigado mesmo, não tive um professor, então aprendi apenas a lógica da linguagem e já me jogaram um projeto desses, só usei recursos que eu fui achando na internet e que se encaixava no propósito, vou mudar tudo isso agora! Mas em relação ao arquivo de texto, não posso pois tem como objetivo gerar estes dados para envio legível! Mas sobre todos as outras mudanças, irei abraçar... Novamente agradeço e sinta-se a vontade para criticar, ficaria muito feliz de uma pessoa com seu conhecimento pudesse me dar esses "puxão de orelha";

arfneto · 18 de novembro de 2021

6 minutos atrás, Matheus Patrick disse:

Mas em relação ao arquivo de texto, não posso pois tem como objetivo gerar estes dados para envio legível

É muito mais simples fazer como eu disse. Imagine uma função assim

    int mostra_paciente( size_t id, Cadastro* cad);

E esse troço encontra o paciente com tal id --- ou CPF ou nome --- e mostra na tela. Basta isso: um ponteiro para o cadastro e uma maneira de identificar o cara. Pode ter vários cadastros e não faz diferença. Compare com a estrutura que usou e vai entender que essa é uma das razões de seu programa ter mais de 800 linhas para fazer o que faz.

EXEMPLO

Usando recortar e colar de seu código

Considere Cadastro e Usuarios como sua unidade. Entende o que tento dizer sobre escrever em torno dos dados?

#define MAX_FUN 50 // limite funcionarios
#define MAX_PAC 50 // limite pacientes

typedef struct
{
    int dia;
    int mes;
    int ano;

}   Data;


typedef struct
{
    char rua[30];
    char bairro[20];
    char cidade[20];
    char estado[3];
    char numero[10];
    char cep[10];
  
}   Endereco;


typedef struct
{
    size_t   id;
    char     nome[30];
    char     cpf[16];
    char     tel[15];
    char     email[50];
    char     lista_comorbidades[256];
    Data     nascimento;
    Data     diagnostico;
    Endereco residencia;

}   Pessoa;
typedef Pessoa Paciente;


typedef struct
{ 
    size_t  id;
    char    user[30];
    char    password[15];

}   Funcionario;


typedef struct
{
    size_t   N;    // quantos tem
    size_t   cap;  // capacidade
    Paciente pac[MAX_PAC];

}   Cadastro;


typedef struct
{
    size_t   N;    // quantos tem
    size_t   cap;  // capacidade
    Funcionario func[MAX_FUN];

}   Usuarios;

Matheus Patrick · 18 de novembro de 2021

Entendi perfeitamente, agora faz mas sentido pra mim! Obrigado novamente, assim vemos a diferença de saberes e experiência...Meu código estava uma *****, concordo com a vergonha!!! Mas irei corrigir agora mesmo! Teria mais algo que faria diferente????

Devo no caso trocar todas funções void por int e dar return 0; ???

Quando você fala sobre as globais, o que se refere,???

Eu uso Windows

o Control-C não tem resultado;

arfneto · 18 de novembro de 2021

1 hora atrás, Matheus Patrick disse:

Entendi perfeitamente, agora faz mas sentido pra mim! Obrigado novamente, assim vemos a diferença de saberes e experiência...Meu código estava uma *****, concordo com a vergonha!!! Mas irei corrigir agora mesmo! Teria mais algo que faria diferente????

Devo no caso trocar todas funções void por int e dar return 0; ???

Quando você fala sobre as globais, o que se refere,???

Acho que o melhor é seguir devagar. Não deixar o programa crescer sem testar, sem convicção de nada. Porque vai perder um tempo do 1nf3rn0 para testar e vai ser difícil aproveitar e alterar coisas.

1 hora atrás, Matheus Patrick disse:

Quando você fala sobre as globais, o que se refere,???

Nada do que suas funções acessam deve estar solto fora delas. Ou são declarados e usados dentro dela ou vem como argumentos. E retornam como resultado. Tudo que vier de fora é global, o mesmo em todo o programa e isso é um inferno.

void cadastro_fun()

Onde está o cadastro? O que vai cadastrar? Se vai gravar num arquivo onde está o nome? Se está aberto onde está o ponteiro para ele?

Uma função assim não serve para nada.

Imagino que tenha entendido os dados que te mostrei.

Vou te mostrar um mínimo exemplo de algo que acho que vai entender.

Pergunto de novo: Acha que entendeu o que eu quero dizer quando escrevo "escreva o código em torno dos dados"?

typedef struct
{ 
    size_t  id;
    char    user[30];
    char    password[15];

}   Funcionario;

Esse é um funcionário

Ao fazer o login vai autenticar um desses que está no cadastro. Que cadastro?

typedef struct
{
    size_t   N;    // quantos tem
    size_t   cap;  // capacidade
    Funcionario func[MAX_FUN];

}   Usuarios;

Esse cadastro.

Então do que precisa para um login?

o usuario, a senha, o cadastro para procurar o cara.

E o que retorna disso?

O id ou o nome do usuario autenticado. Ou não?

Então o que essa função faz?

    Funcionario* login(const char* usuario, const char* senha, Usuarios* cad);

Devolve um endereço para um funcionário, se ele está no cadastro com a senha fornecida. Ou retorna NULL se não tem o cara ou a senha está errada. O simples.

A função não depende de mais nada. Nada externo, nada global. Isso é essencial. E de todo modo o uso de globais é proibido em toda parte e vai te custar nota ou emprego se insistir em usar.

Mais ainda, a função não altera nada externo (ok, tem o cad que podeira ser alterado a partir do ponteiro que não foi declarado constante

Imagine se no seu programa de 900 linhas algo zoou o valor de algo que a função usa. Vai reclamar de quem? Se não tiver jeito de mudar nunca vai precisar testar.

    Usuarios setor[30];

A declaração acima cria 30 cadastros de usuários para 30 setores da empresa. Para essa login() não faz diferença. No seu programa só usa uma: void cadastro_fun(). E aí?

De volta ao EXEMPLO

Se login() é assim se pode escrever

    const char* user1 = "admin";
    Funcionario* user = login(user1, "senha", &cad_user);
    if (user == NULL)
    {
        printf("Erro no login\n");
        return -1;
    }
    printf("Aceito login de \"%s\", id = %zd\n", user1, user->id);
    free(user);
    return 0;

Veja essa

Funcionario* login(char* usuario, char* senha, Usuarios* cad)
{ 
    if (cad == NULL) return NULL;
    printf("Tentando login() de \"%s\"\n", usuario);
    return NULL;
}

Entende a diferença? Toda a informação está aí. Não tem nada externo. O programa mostra

Tentando login() de "admin"
Erro no login

Imagine que só para teste queira aceitar 3 usuários por enquanto e sem mexer no lance do arquivo de senhas: é outro cara que vai escrever isso de login que pode ser complicado. Aí você vai lá dentro de login() e escreve

    const char* valido[][2] =
    {   // usuarios para teste
        {"qualquer", "senha"},
        {"admin", "password"}, 
        {"user1", ""}
    };

E aceita esses caras, em minutos está testando outras coisas. E não tem como dar errado porque é local

Funcionario* login(const char* usuario, const char* senha, Usuarios* cad)
{ 
    // clang-format-off
    const char* valido[][2] =
    {   // usuarios para teste
        {"qualquer", "senha"},
        {"admin", "password"}, 
        {"user1", ""}
    };
    // clang-format-on
    if (cad == NULL) return NULL;
    printf("Tentando login() de \"%s\"\n", usuario);
    const int N = sizeof(valido) / sizeof(char*);
    for (int i = 0; i < N; i += 1) {
        if (strcmp(usuario, valido[i][0]) == 0)
        {   // usuario ok
            if (strcmp(senha, valido[i][1]) == 0) {
                // senha ok
                Funcionario* o_cara =
                    (Funcionario*)malloc(sizeof(Funcionario));
                strcpy(o_cara->user, usuario);
                strcpy(o_cara->password, senha);
                o_cara->id = i; // na producao vira o dado do cadastro
                return o_cara;                    
            }
            else
            {   // senha invalida
                printf("Senha invalida para \"%s\"\n", usuario);
                return NULL;
            }
        }
    }
    return NULL;
}

A mudança? Só um loop olha na tabela dos válidos e se acha o cara compara a senha e se está certa cria um registro de funcionario e retorna.

Em main()

    // agora tenta com a senha certa
    user = login(user1, "password", &cad_user);
    if (user == NULL)
        printf("Erro no login\n");
    else
    {
        printf("Aceito login de \"%s\", id = %zd\n", user1, user->id);
        free(user);
    }

Retorna ao rodar

Tentando login() de "admin"
Aceito login de "admin", id = 1

O programa "todo"

// https://www.clubedohardware.com.br/forums/topic/
// 1574144-tecla-reservada-para-finalizar-toda
//-execu%C3%A7%C3%A3o-em-c/#comment-8310077

#include <stdio.h>
#include <stdlib.h>
#include "f3.h"
int main(void)
{
    Usuarios     cad_user;
    cad_user.cap       = MAX_FUN;
    cad_user.N         = 0;

    const char* user1 = "admin";
    Funcionario* user = login(user1, "senha", &cad_user);
    if (user == NULL)
        printf("Erro no login\n");
    else
    {
        printf("Aceito login de \"%s\", id = %zd\n", user1, user->id);
        free(user);
    }

    // agora tenta com a senha certa
    user = login(user1, "password", &cad_user);
    if (user == NULL)
        printf("Erro no login\n");
    else
    {
        printf("Aceito login de \"%s\", id = %zd\n", user1, user->id);
        free(user);
    }
    return 0;
}

Depois alguém cuida de passar o cadastro ou o nome do arquivo de funcionários, mas entenda que já está testando. Em minutos.

Em main user aponta para o usuário autenticado ou NULL. E é o que importa.

Matheus Patrick · 18 de novembro de 2021

Perfeito, adotei todas as mudanças citadas...

3 horas atrás, arfneto disse:

escreva o código em torno dos dados

Em relação a isso, achava que tinha entendido, mas vendo seu contexto confesso que me perdi total, me perdi bastante, tive que pesquisar para entender metade de seus códigos! Mas consegui adotar todas as modificações que me mostrou, inclusive agradeço pela carga de ensinamentos... sou bem N0Ob em programação pelo que vi... tenho muito que aprender

Agora queria que me ensina-se a fazer isso:

5 horas atrás, arfneto disse:

Não basta usar isso durante a leitura? Desabilite o ECO e conforme o cara digita se for um ESC encerra e se não for processa e mostra a letra, como todo mundo.

Realmente quero usar somente na leitura, mas como faço pra desabilitar e o que é esso ECO....

arfneto · 18 de novembro de 2021

2 minutos atrás, Matheus Patrick disse:

mas vendo seu contexto confesso que me perdi total, me perdi bastante, tive que pesquisar para entender metade de seus códigos

Porque não fez uma única pergunta?

Você entendeu a função login()?

Entendeu porque é mais tranquilo poder escrever só

     Funcionario* user = login("usuario", "senha", &cad_user);

E não ter que procurar por possível erro em lugar nenhum fora da função?

2 minutos atrás, Matheus Patrick disse:

Realmente quero usar somente na leitura, mas como faço pra desabilitar e o que é esso ECO....

ECO é o fato de que a máquina mostra na tela na hora as teclas que o cara digita. Eco de ecoar.

Se desligar isso, como é comum nas senhas, o programa recebe as teclas mas não aparecem na tela. o que se espera de uma senha. E se a tecla for ESC você pode cancelar como quer...

Matheus Patrick · 18 de novembro de 2021

5 minutos atrás, arfneto disse:
Você entendeu a função login()?

Entendeu porque é mais tranquilo poder escrever só
     Funcionario* user = login("usuario", "senha", &cad_user);

Toda essa parte entendi perfeitamente, já até coloquei no meu algoritmo, ficando assim:

//declarei as var e recebi via função gets();
Funcionario* user = login(user, pass, &cad_user);
//usei os seus próprios códigos...

Ficou bem mais simples, legível e econômico(quando se fala de memória);

economizei muitas linhas com tudo isso!!

10 minutos atrás, arfneto disse:

Se desligar isso, como é comum nas senhas, o programa recebe as teclas mas não aparecem na tela. o que se espera de uma senha. E se a tecla for ESC você pode cancelar como quer...

e como colocaria isso em meio a função main? como implementar esse código...

arfneto · 18 de novembro de 2021

4 minutos atrás, Matheus Patrick disse:

e como colocaria isso em meio a função main? como implementar esse código...

Você tentou ler a documentação?

Se está usando Windows está aqui https://docs.microsoft.com/pt-br/windows/console/setconsolemode

Não faz sentido?

Toda a documentação está lá. Não dizem isso nas aulas?

Direto de https://docs.microsoft.com/pt-br/windows/console/setconsolemode

8 minutos atrás, Matheus Patrick disse:

Ficou bem mais simples, legível e econômico(quando se fala de memória);

economizei muitas linhas com tudo isso!!

Importa que entenda o mecanismo, porque assim pode escrever e já ir testando as partes com segurança.

No programa pronto deve ter uma fase inicial em que carrega os cadastros para vetores na memória, e no final grava de volta no disco a versão final.