C Cadastro de pacientes com covid em linguagem C

OTaviotneto · 25 de novembro de 2021

Boa tarde!

Estou com dificuldade para finalizar um código pois em um dado momento, eu preciso informar que os pacientes com idade maior que 65 anos fazem parte do grupo de risco ( preciso exibir isso na tela ), porém eu informo a data de nascimento e não a idade.



Alguém pode me dar um norte sobre como fazer isso?

Segue abaixo meu código:



#include <stdio.h>
#include <stdlib.h>
#include <locale.h>
#include <conio.h>
#include <ctype.h>
#include <string.h>
#include <windows.h>
struct campos { // Dados

    char nome[50]; 
    int dia
    char diaC[3];  
    int mes;  
    char mesC[3];  
    int ano;  
    char anoC[5];  
    char email[50];
    long long telefone2;
    char telefone2C[12]; 
    long long telefone; 
    char telefoneC[12]; 
    char rua[20]; 
    char numeroC[10];  
    int numero; 
    char bairro[20];
    char cidade[20];  
    char estado[20];  
    char complemento[50];
    long long cep;  
    char cepC[9];  
};

struct CPF {

    char cpfC[12];

};

struct diagnostico {
    int dia;  
    char diaC[3];  
    int mes;  
    char mesC[3];  
    int ano;  
    char anoC[5]; 
};

struct user{
    char user[20];
    char password[20];
};


void cadastro(void);
void cadLogin(void); 
void menu(void);


char teste();

int continua = 1;

char morbidade [60];


int main(){
    system("color 5f");
    system("cls");

//morbidades
    setlocale(LC_ALL,"Portuguese");
        cadLogin();

}//Fim main

int i; //Iteração for

void cadastro (void){

    char apoioNome[500];
    char tracos[]= "------------------------------------------------";
    FILE *ponteiro1;
    FILE *ponteiro2;
    ponteiro1 = fopen("risco.txt", "a");
    ponteiro2 = fopen("cadastro.txt", "a");
    if( ponteiro1 == NULL && ponteiro2 == NULL){
        printf("Erro na abertura do arquivo!");
    return 1;
  }
    long long cpf;
    struct CPF cadCpf;
    struct campos dados ;
    struct diagnostico data;
    int opCadNtelefone;

    system("cls");
    printf("\n******************DADOS PESSOAIS*******************\n");
    printf("\n---------------------------------------------------");
    char login[12];
    FILE *pontCadCpf;
    pontCadCpf = fopen ("cpf.txt","a");
    rCpf:
    printf("\nDigite os 11 números do cpf sem ponto e traço\n");
    printf("\nCPF: ");
    fflush(stdin);
    gets(cadCpf.cpfC);

     if(strlen(cadCpf.cpfC) == 0){
        goto rCpf;
    }

    for(i=0; i<cadCpf.cpfC[i]; i++) {
        if(!(cadCpf.cpfC[i]>='0' && cadCpf.cpfC[i]<='9' && strlen(cadCpf.cpfC)==11)){
            printf("\n***Inválido. \nVerifique se digitou apenas numeros \n e se não excedeu ou não atingiu a quantidade permitida***\n");
                goto rCpf;
            break;
        }
        else{

            cpf = atoll(cadCpf.cpfC);

        }
    }

    FILE *consulta;
        consulta = fopen ("cpf.txt","r");
        while((fscanf(consulta,"%s",&login)) !=EOF){
                if (strcmp(cadCpf.cpfC,login ) == 0){
                    printf("\n\n***Já consta no sistema um cadastro com esse número de cpf***\n");
                    goto rCpf;
                    fclose(consulta);
                    break;
                }
        }
            fprintf(pontCadCpf, "\n%s", cadCpf.cpfC);
            fclose(pontCadCpf);

    rNome:
    printf("\n°NOME: ");
    gets(dados.nome);

     if(strlen(dados.nome) == 0){
        goto rNome;
    }

    //Inicio For
    for(i=0; i<dados.nome[i];i++){
            fflush(stdin);
             if (dados.nome[i] == ' '){
                    dados.nome[i] = '°';
                } if(dados.nome[i] >= 'a' && dados.nome[i] <= 'z' || dados.nome[i] >= 'A' && dados.nome[i] <= 'Z' || dados.nome[i] == '°'){
                    if(dados.nome[i] == '°'){
                            dados.nome[i] = ' ';
                    }
                    }else
                    {
                        printf("\n***caractere inválido. \nInforme apenas letras***");
                        goto rNome;
                        break;
                }
}
//fim for
    printf("---------------------------------------------------");

    printf("\n°DATA DE NASCIMENTO");
    rDiaNascimento:
    printf("\n    =>DIA dd : ");
    fflush(stdin);
    gets(dados.diaC);


     if(strlen(dados.diaC) == 0){
        goto rDiaNascimento;
    }

    for(i=0; i<dados.diaC[i]; i++) {
        if(!(dados.diaC[i]>='0' && dados.diaC[i]<='9' && strlen(dados.diaC)==2)){
            printf("\n***Inválido. \nVerifique se digitou apenas numeros \n e se não excedeu ou não atingiu a quantidade permitida***\n");
                goto rDiaNascimento;
            break;
        }
        else{
            dados.dia = atoi(dados.diaC);
        }
    }
    rMesNascimento:
    printf("          =>MÊS mm : ");
    fflush(stdin);
    gets(dados.mesC);

    if(strlen(dados.mesC) == 0){
        goto rMesNascimento;
    }

    for(i=0; i<dados.mesC[i]; i++) {
        if(!(dados.mesC[i]>='0' && dados.mesC[i]<='9' && strlen(dados.mesC)==2)){
            printf("\n***Inválido. \nVerifique se digitou apenas numeros \n e se não excedeu ou não atingiu a quantidade permitida\n***");
                goto rMesNascimento;
            break;
        }
        else{
            dados.mes = atoi(dados.mesC);
        }
    }
    rAnoNascimento:
    printf("");
    printf("             =>ANO aaaa : ");
    fflush(stdin);
    gets(dados.anoC);

    if(strlen(dados.anoC) == 0){
        goto rAnoNascimento;
    }

    printf("---------------------------------------------------");
    for(i=0; i<dados.anoC[i]; i++) {
        if(!(dados.anoC[i]>='0' && dados.anoC[i]<='9' && strlen(dados.anoC)==4)){
            printf("\n***Inválido. \nVerifique se digitou apenas numeros \n e se não excedeu ou não atingiu a quantidade permitida\n***");
                goto rAnoNascimento;
            break;
        }
        else{
            dados.ano = atoi(dados.anoC);
        }
    }

    rEmail:
    printf("\nEMAIL: ");
    fflush(stdin);
    gets(dados.email);
    printf("---------------------------------------------------");


    if(strlen(dados.email) == 0){
        goto rEmail;
    }

    rTelefone:
    printf("\n\n°NUMERO DE TELEFONE\n\n");
    printf("***Cadastre até dois números de telefone\n");
    printf("Digite os números todos juntos XXXX...\n\n");
    printf("INFORME O N° DE TELEFONE PRINCIPAL: ");
    fflush(stdin);
    gets(dados.telefoneC);
    printf("---------------------------------------------------");

    if(strlen(dados.telefoneC) == 0){
        goto rTelefone;
    }

    for(i=0; i<dados.telefoneC[i]; i++) {
        if(!(dados.telefoneC[i]>='0' && dados.telefoneC[i]<='9')){
            printf("\n***Inválido. \nVerifique se digitou apenas numeros\n***");
                goto rTelefone;
            break;
        }
        else{
            dados.telefone = atoll(dados.telefoneC);
        }
    }

    rTelefone2:
    printf("\n\nINFORME O N° DE TELEFONE 2: ");
    fflush(stdin);
    gets(dados.telefone2C);

    if(strlen(dados.telefone2C) == 0){
        goto rTelefone2;
    }

    for(i=0; i<dados.telefone2C[i]; i++) {
        if(!(dados.telefone2C[i]>='0' && dados.telefone2C[i]<='9')){
            printf("\n***Inválido. \nVerifique se digitou apenas numeros\n***");
                goto rTelefone2;
            break;
        }
        else{
            dados.telefone2 = atoll(dados.telefone2C);
        }
    }
    system("cls");
    printf("---------------------------------------------------");
    printf("\n°DATA DO DIAGNÓSTICO DE COVID 19");
    rDiaMorb:
    printf("\n   =>DIA dd: ");
    fflush(stdin);
    gets(data.diaC);

    if(strlen(data.diaC) == 0){
        goto rDiaMorb;
    }

    for(i=0; i<data.diaC[i]; i++) {
        if(!(data.diaC[i]>='0' && data.diaC[i]<='9' && strlen(data.diaC)==2)){
            printf("\n***Inválido. \nVerifique se digitou apenas numeros \n e se não excedeu ou não atingiu a quantidade permitida\n***");
                goto rDiaMorb;
            break;
        }
        else{
            data.dia = atoi(data.diaC);
        }
    }
    rMesMorb:
    printf("\n        =>MÊS mm: ");
    fflush(stdin);
    gets(data.mesC);


    if(strlen(data.mesC) == 0){
        goto rMesMorb;
    }

        for(i=0; i<data.mesC[i]; i++) {
        if(!(data.mesC[i]>='0' && data.mesC[i]<='9' && strlen(data.mesC)==2)){
            printf("\n***Inválido. \nVerifique se digitou apenas numeros \n e se não excedeu ou não atingiu a quantidade permitida\n***");
                goto rMesMorb;
            break;
        }
        else{
            data.mes = atoi(data.mesC);
        }
    }
    rAnoMorb:
    printf("\n              =>ANO aaaa: ");
    fflush(stdin);
    gets(data.anoC);

    if(strlen(data.anoC) == 0){
        goto rAnoMorb;
    }


    for(i=0; i<data.anoC[i]; i++) {
        if(!(data.anoC[i]>='0' && data.anoC[i]<='9' && strlen(data.anoC)==4)){
            printf("\n***Inválido. \nVerifique se digitou apenas numeros \n e se não excedeu ou não atingiu a quantidade permitida\n***");
                goto rAnoMorb;
            break;
        }
        else{
            data.ano = atoi(data.anoC);
        }
    }
    system("cls");
    printf("---------------------------------------------------");
    printf("\n\n°Dados de Endereço\n\n");

    rCep:
    printf("\CEP: ");
    fflush(stdin);
    gets(dados.cepC);

    if(strlen(dados.cepC) == 0){
        goto rCep;
    }

    for(i=0; i<dados.cepC[i]; i++) {
        if(!(dados.cepC[i]>='0' && dados.cepC[i]<='9'&&strlen(dados.cepC)<9)){
            printf("\n******Inválido. \nVerifique se digitou apenas numeros \n e se não excedeu ou não atingiu a quantidade permitida\nDigite os 8 números do CEP***");
                goto rCep;
            break;
        }
        else{
            dados.cep = atoll(dados.cepC);
        }
    }
    printf("---------------------------------------------------");

    rRua:
    printf("\nRUA: ");
    fflush(stdin);
    gets(dados.rua);

    if(strlen(dados.rua) == 0){
        goto rRua;
    }

    printf("---------------------------------------------------");

    rNumero:
    printf("\nNÚMERO: ");
    gets(dados.numeroC);

    if(strlen(dados.numeroC) == 0){
        goto rNumero;
    }

    printf("---------------------------------------------------");
    for(i=0; i<dados.numeroC[i]; i++) {
        if(!(dados.numeroC[i]>='0' && dados.numeroC[i]<='9'&& strlen(dados.numeroC)<11)){
            printf("\n***Inválido. \nVerifique se digitou apenas numeros \n e se não excedeu ou não atingiu a quantidade permitida\n***");
                goto rNumero;
            break;
        }
        else{
            dados.numero = atoll(dados.numeroC);
        }
    }

    rComplemento:
    printf("\nCOMPLEMENTO: ");
    gets(dados.complemento);

    if(strlen(dados.complemento) == 0){
        goto rComplemento;
    }


    printf("---------------------------------------------------");

    rCidade:
    printf("\nCIDADE: ");
    fflush(stdin);
    gets(dados.cidade);

    if(strlen(dados.cidade) == 0){
        goto rCidade;
    }

    for(i=0; i<dados.cidade[i];i++){
            fflush(stdin);
             if (dados.cidade[i] == ' '){
                    dados.cidade[i] = '°';
                } if(dados.cidade[i] >= 'a' && dados.cidade[i] <= 'z' || dados.cidade[i] >= 'A' && dados.cidade[i] <= 'Z' || dados.cidade[i] == '°'){
                    if(dados.cidade[i] == '°'){
                            dados.cidade[i] = ' ';
                    }
                    }else
                    {
                        printf("\n***caractere inválido. Informe apenas letras***");
                        goto rCidade;
                        break;
                }
}
//fim for

    printf("---------------------------------------------------");

    rBairro:
    printf("\nBAIRRO: ");
    fflush(stdin);
    gets(dados.bairro);

    if(strlen(dados.bairro) == 0){
        goto rBairro;
    }
    printf("---------------------------------------------------");

    rEstado:
    printf("\nESTADO: ");
    fflush(stdin);
    gets(dados.estado);

    if(strlen(dados.estado) == 0){
        goto rEstado;
    }

    printf("---------------------------------------------------");

    for(i=0; i<dados.estado[i];i++){
            fflush(stdin);
             if (dados.estado[i] == ' '){
                    dados.estado[i] = '°';
                } if(dados.estado[i] >= 'a' && dados.estado[i] <= 'z' || dados.estado[i] >= 'A' && dados.estado[i] <= 'Z' || dados.estado[i] == '°'){
                    if(dados.estado[i] == '°'){
                            dados.estado[i] = ' ';
                    }
                    }else
                    {
                        printf("\n***caractere inválido. Informe apenas letras***");
                        goto rEstado;
                        break;
                }
}
//fim for
    int opMorb; //Opção referente caso o paciente tenha algum tipo de morbidade
    char opMorbC[3];  

    retornMorb : //retorna cadastro de morbidade
    system("cls");
    printf("  -------------------------------------------------");
    printf("\n  -O paciente possui algum tipo de morbidade?     -");
    printf("\n  -[1]SIM                                         -");
    printf("\n  -[2]NÃO                                         -\n");
    printf("  -------------------------------------------------");
    printf("\nEscolha a opção dejesada: ");
    fflush(stdin);
    gets(opMorbC); //op morbidade

    for(i=0; i<opMorbC[i];i++){
        if(strlen(opMorbC)==1 && opMorbC[i] =='1' || strlen(opMorbC)==1 && opMorbC[i] =='2' ){
            opMorb = atoi(opMorbC);
            break;
        }
        else{
            printf("Opção inválida");
            break;
        }

    }

    if(opMorb == 1 ) {
        printf("---------------------------------------------------");
        printf("\nMORBIDADE DO PACIENTE: ");
        fflush(stdin);
        gets(morbidade);
    }

    else if( opMorb !=1 && opMorb !=2 ) {
        goto retornMorb;
    }

    printf("\n\nDADOS CADASTRADOS COM SUCESSO!\n\n");

    int idade = 2020 - dados.ano; //ano dignostico - ano idade

    if (idade >= 65) {
            fprintf(ponteiro1, "\nIDADE: %d",idade);
            fprintf(ponteiro1, "\nCEP: %08lld\n\n", dados.cep);
            fprintf(ponteiro1, "\n\n\%s", tracos);
            fclose(ponteiro1);
    }

    fprintf(ponteiro2, "\nNOME: %s\n", dados.nome);
    fprintf(ponteiro2, "\nDATA DE NASCIMENTO: %d/%d/%d", dados.dia,dados.mes,dados.ano);
    fprintf(ponteiro2, "\nIDADE: %d",idade);
    fprintf(ponteiro2, "\nCPF: %011lld",cpf);
    fprintf(ponteiro2, "\nEMAIL: %s", dados.email);
    fprintf(ponteiro2, "\nTELEFONE: %lld", dados.telefone);
    fprintf(ponteiro2, "\nTELEFONE 2: %lld", dados.telefone2);
    if (opMorb == 1){
        fprintf(ponteiro2, "\nMORBIDADE: %s", morbidade);
    } else {
        fprintf(ponteiro2, "\nMORBIDADE: NENHUMA");

    }
    fprintf(ponteiro2, "\nDIAGNÓSTICO REALIZADO EM: %d/%d/%d", data.dia,data.mes,data.ano);
    fprintf(ponteiro2, "\nCEP: %08lld", dados.cep);
    fprintf(ponteiro2, "\nRUA: %s", dados.rua);
    fprintf(ponteiro2, "\nCOMPLEMENTO: %s", dados.complemento);
    fprintf(ponteiro2, "\nCIDADE: %s", dados.cidade);
    fprintf(ponteiro2, "\nBAIRRO: %s", dados.bairro);
    fprintf(ponteiro2, "\nESTADO: %s", dados.estado);
    fprintf(ponteiro2, "\n\n\%s", tracos);

    fclose(ponteiro2);
}//Fim funcao cadastro
FILE *cadastrar; // Cadastrar login
FILE *logar;
char user[20];
char password[20];
char c; //apagar
char str[20]; //ARMAZENA O USUARIO PARA CONSULTA
char str2[20]; //ARMAZENA A SENHA PARA CONSULTA
int rep =1;
void cadLogin(void){
    while(rep == 1){
    int opCadLogin;
    char opCadLoginC[2];
    teste:


    printf("\n                   ---------------------------------------------------");
    printf("\n                   |               [1]LOGAR NO SISTEMA               |");
    printf("\n                   |         [2]CADASTRAR USUÁRIO E SENHA            |");
    printf("\n                   |                  [0]SAIR                        |");
    printf("\n                   ---------------------------------------------------");
    printf("\n\n  Digite o número da opção:    ");
    fflush(stdin);
    gets(opCadLoginC);
    for(i=0; i<opCadLoginC[i];i++){
        if(strlen(opCadLoginC)==1 && opCadLoginC[i] =='1' || strlen(opCadLoginC)==1 && opCadLoginC[i] =='2' || strlen(opCadLoginC)==1 && opCadLoginC[i] =='0' ){
            opCadLogin = atoi(opCadLoginC);
            break;
        }
        else{
            printf("Opção inválida");
            break;
        }

    }

    system("cls");

    switch(opCadLogin){
    case 1:
        logar = fopen("login.txt","r");
        printf("\  xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n");
        printf("\n                      LOGIN                             ");
        printf("\n\n  ---------------------------------------------------\n\n");
        printf("  USUARIO: ");
        fflush(stdin);
        gets(user);
        printf("\n  ---------------------------------------------------\n\n");
        printf("  SENHA: ");

        while((c=getch())!=13){ //13 é o valor de ENTER na tabela ASCII
                if (c != 
                {
                    password[i] = c;
                    printf("*");
                    i++;
                }
                else
                {
                    i--;
                    if (i < 0)
                    {
                        i++;
                    }
                    else
                    {
                        printf("\b \b");
                    }
                }
            }
                  password[i]='\0';
                  i=0;

        printf("\n  ---------------------------------------------------");
        printf("\n\n  xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n");
        if (logar == NULL) {
            printf("\n  Nenhum login e senha foi cadastrado ainda");
            printf("\n  *Cadastre o usuario e senha\n\n");
            printf("\n  Pressione ENTER para retornar a tela inical...");
            scanf("ENTER");
            system("cls");

            return cadLogin();
            break;
        }
        while((fscanf(logar,"%s %s",&str, &str2)) !=EOF) {
                if ( ( strcmp( str, user) == 0) && ( strcmp( str2, password ) == 0 ))
                {

                    Beep(1200,200);
                    printf("\n   Logado com sucesso");
                    menu();
                    break;
        }
        system("cls");
        printf("\n  (Usuário e/ou senha incorreto)\n");
        printf("\n  (Tente novamente!)\n");
        printf("\n  Pressione enter para retornar a tela inical...");
        Beep(565,2000);
        scanf("ENTER");
        system("cls");

        return cadLogin();
        //goto teste;
        break;
}
break;
fclose(logar);
    rCadLogin:
    case 2:
        cadastrar = fopen("login.txt", "a");

        if (cadastrar == NULL){
            printf("Erro na abertura do arquivo!");
        }

        struct user userPass; //STRUCT USUARIO E SENHA
        printf("  \n             CADASTRO DE USUÁRIO E SENHA            ");
        printf("\n\n  ---------------------------------------------------\n");
        rUser:
        printf("\n  USUÁRIO: ");
        fflush(stdin);
        gets(userPass.user);

        if(strlen(userPass.user) == 0){
        goto rUser;
    }


        printf("\n  ---------------------------------------------------\n");
        rPassword:
        printf("\n  SENHA: ");
        fflush(stdin);
        gets(userPass.password);

        if(strlen(userPass.password) == 0){
        goto rPassword;
    }

        printf("\n  ---------------------------------------------------\n");

        fprintf(cadastrar, "\n%s", userPass.user);
        fprintf(cadastrar, "\n%s", userPass.password);

        printf("  USUÁRIO E SENHA CADASTRADO COM SUCESSO\n");
        printf("\n  Pressione enter para retornar a tela inical...");
        scanf("ENTER");
        system("cls");
        fclose(cadastrar);
        return cadLogin();
    case 0 :
            printf("\n\n***************SISTEMA FINALIZADO*******************\n\n");
            printf("\n\DICA: (Se quiser pesquisar um determinado paciente\nutilize o atalho CTRL+F dentro do arquivo e\nfiltre o paciente pelo nome, cpf, idade etc.)\n\n\n");
            rep = 0;
            rep = 0;
            break;

    default :
        printf("\n***Opção Inválida***\n\n");
        return cadLogin();
        break;
    }
    }
}//Fim cadLogin

int opMenu, opCadastro;
char opMenuC[2],opCadastroC[2];
void menu(void) {
    printf("\n  ---------------------------------------------------");
    printf("\n  -[1]CADASTRAR PACIENTES                           -");
    printf("\n  -[2]Voltar ao menu inicial                        -");
    printf("\n  ---------------------------------------------------");
    printf("\n   Digite o número da opção:   ");
    fflush(stdin);
    gets(opMenuC);
    for(i=0; i<opMenuC[i];i++){
        if(strlen(opMenuC)==1 && opMenuC[i] =='1' || strlen(opMenuC)==1 && opMenuC[i] =='2' ){
            opMenu = atoi(opMenuC);
            break;
        }
        else{
            printf("Opção inválida");
            break;
        }

    }
    system("cls");
        switch(opMenu) {
            teste:
            system("color E2");
            system("cls");
            case 1 : cadastro();
            printf("\n  ---------------------------------------------------");
            printf("\n  -Deseja realizar um novo cadastro?                -");
            printf("\n  -[1]SIM                                           -");
            printf("\n  -[2]NÃO                                           -");
            printf("\n  ---------------------------------------------------");
            printf("\n Digite o número da opção:   ");
            fflush(stdin);
            gets(opCadastroC);

    for(i=0; i<opCadastroC[i];i++){
        if(strlen(opCadastroC)==1 && opCadastroC[i] =='1' || strlen(opCadastroC)==1 && opCadastroC[i] =='2' ){
            opCadastro= atoi(opCadastroC);
            break;
        }
        else{
            printf("Opção inválida");
            break;
        }

    }
            system("cls");

            if(opCadastro == 1){
                goto teste;
            }

            if(opCadastro == 2){
                cadLogin();
            }

            case 2 :
            cadLogin();
            break;

            default : printf("\n\nOpcão Inválida");
            return cadLogin();
            break;
    }

}

ricardo_br · 25 de novembro de 2021

@OTaviotneto por favor use o botão código (code) para postar código...

OTaviotneto · 25 de novembro de 2021

@ricardo_br ajustei

devair1010 · 26 de novembro de 2021

@OTaviotneto para calcular a idade subtraia a data atual pela data de nascimento , usando a funcao _strdate(); para obter essa data Atuak .

arfneto · 26 de novembro de 2021

@OTaviotneto Você inclui TODO o texto dentro da caixa de código...

Sobre seu programa

Você chegou a um programa de mais de 900 linhas usando muitas das fragilidades comuns nos programas que se vê aqui neste forum, provavelmente porque é a maneira que estão usando para ensinar isso nas escolas ou livros ou tutoriais...

Do modo como escreveu é muito frágil. Testar é muito difícil como deve estar vendo. E pouco vai levar deste programa para outro porque não é nada modular.

Recomendo reorganizar as coisas. Vai levar muito menos tempo para terminar.

Veja main() por exemplo

int main()
{
    system("color 5f");
    system("cls");

    // morbidades
    setlocale(LC_ALL, "Portuguese");
    cadLogin();

}  // Fim main

As chamadas a system() nem deviam estar aí em um programa que nem está pronto. Nada acrescentam. Acentos e ponto decimal provavelmente não acrescentam muito ao programa.

E toda a lógica está dentro de uma função void que retorna void (nada) e depende totalmente de valores globais que não pode mudar. Não programe assim

Escreva em torno dos dados.

Onde está o tal cadastro? O que é um usuário? Onde estão as senhas? Tem que procurar tudo pelo programa e só pode usar um porque não há passagem de parâmetros.

Parece que mantem todos os dados em arquivo ao invés do normal que é usar alguma estrutura na memória para manter os dados e ler no início e gravar ao final no disco. Isso torna tudo ainda mais difícil.

E você usa vários labels para controlar o fluxo do programa usando goto e isso torna ainda mais complicado testar e manter tudo.

Para comparar

O comum seria ter uma estrutura Cadastro que seria algo com os pacientes dentro. Pode ser um vetor, uma lista, qualquer coisa.

E o cadastro seria carregado no inicio do programa, a partir de uma arquivo, e gravado no final. Algo semelhante para os usuários

Reformatando seus dados em minutos, veja esse programa


// usando os dados ANTES do programa

typedef struct
{
    char dia[3];
    char mes[3];
    char  ano[5];
}   Data;

typedef struct
{
    char cpfC[15];
} CPF;

typedef struct
{
    char      rua[20];
    char      numeroC[10];
    int       numero;
    char      bairro[20];
    char      cidade[20];
    char      estado[20];
    char      complemento[50];
    long long cep;
    char      cepC[9];
} Endereco;

typedef struct
{
    //+ CC(XX) xxxx.xxxx.xx
    char fone[22];
    char tipo;
} Telefone;

typedef struct 
{
    char         nome[50];
    Data data;
    char         email[50];
    Telefone     fone1;
    Telefone     fone2;
    Telefone     fone3;
    Endereco     end;
} Pessoa;

typedef struct
{
    int  id;
    char desc[50];  // descricao da morbidade
} Morbidade;

typedef struct
{
    int  n; // quantas
    Morbidade morb[10]; // quais
} Morbidades;

typedef struct 
{
    Data data;
    Morbidades m;
}   Diagnostico;

typedef struct
{
    char usuario[20];
    char senha[20];
} Usuario;

// lista de usuario/senha para validar login
typedef struct
{
    int  n; // quantos
    Usuario u;
} Usuarios; 

typedef struct
{
    int id;
    Pessoa pac;
    Diagnostico d;
} Paciente;

typedef struct
{
    int      n;
    Paciente pac;
} Cadastro;

// le e grava cadastro do disco
int  le_cadastro(Cadastro* c, const char* arquivo);
int  grava_cadastro(Cadastro* c, const char* arquivo);
// insere o paciente no cadastro
int  insere(Paciente* p, Cadastro* c);
// retorna 0 se usuario e senha ok
int  login(Usuario* u, Usuarios* operadores);
// menu retorna a opcao
int  menu(void);

int main(void)
{
    Cadastro cad;
    Usuarios users;
    return 0;
}

int grava_cadastro(Cadastro* c, const char* arquivo) { return 0; }
int insere(Paciente* p, Cadastro* c) { return 0; }
int le_cadastro(Cadastro* c, const char* arquivo) { return 0; }
int login(Usuario* u, Usuarios* operadores) { return 0; }
int menu(void);

Que até compila. É muito mais simples escrever assim. E dividir o trabalho.

Ainda sobre o programa

Mais uns palpites

Não use acentos. Em variáveis, em strings ou em comentários, a menos que o enunciado exija. Não vai aprender nada e só vai ter problemas
Não use system() para nada. Não estará fazendo nada. Não há praticamente nada que possa fazer com system() que não possa fazer em C ou C++. system() foi escrita em C e o sistema quase todo também. E em geral é proibido em empresas e escolas afinal: é um risco grande de segurança. E se tem algo que você não possa inicialmente fazer em C ou C++ talvez não deva mesmo fazer
main() deve ser a primeira função de seu programa. Se possível em um arquivo separado. Há muitas razões para isso, mas em especial vai gostar de começar a ler seus programas e os de outros a partir de main() E a partir do início do texto. Ao mesmo tempo.
Ao usar uma estrutura de dados, como uma lista encadeada, entenda que uma estrutura é um container. Até tem esse nome em C++. Em java são chamadas coleções. Se programar uma estrutura dessas como se fosse um elemento com um ponteiro dentro só vai trabalhar mais e à toa. Em geral uma estrutura tem nós e cada nó tem uma referência a um dado. Por exemplo uma lista não é um nó, um nó não é uma lista. E os nós em geral tem uma referência a UM registro d dados. E nesse registro um campo é a chave, que se usa para comparar dois registros e dar uma noção de ordenação.
evite retornar void de funções: em geral é um desperdício. Muitas vezes um erro. Use argumentos nas funções, e retorne algo delas
Não há razão para incluir conio.h. Essa é uma biblioteca dos anos 80 e nada acrescenta a um programa moderno. Mesmo nos anos '80 ela era usada em geral apenas para ler letrinhas do teclado sem mostrar na tela, limpar a tela e escrever letrinhas com cores --- getch(), kdhit(), clrscr() e textcolor(). A mesma coisa que estava disponível em C no Windows e no Unix (depois Linux/MacOS/Android) em poucas linhas.
não use gets(). Nunca. Não há nenhuma razão. fgets() é muito mais prática e segura e você não precisa se preocupar em seu programa cancelar porque o cara digitou além do que cabia no campo. E em geral o uso de gets() é proibido mesmo, pela empresa ou pela escola.
Use alguma ordem em suas funções, como a ordem alfabética por exemplo. Vai gostar disso quando seu programa tiver 50 funções ao invés de umas poucas. Muitos IDE mostram uma lista das funções, em geral na ordem em que foram declaradas, de modo que você pode clicar no nome e o editor vai direto para o código. E se estiverem em ordem é claro que você só ganha.
Nunca use variáveis globais. Isso é um pesadelo e sempre vai cair na sua cabeça. Em geral é proibido em empresas e escolas. Não declare NADA fora de main().
Não declare mais que uma variável por linha. Não acrescenta nada e só dificulta a leitura. Inicialize todas as variáveis.
Nunca leia valores do teclado para alimentar seu programa antes dele estar rodando. Só vai te atrasar e não acrescenta absolutamente nada. Use constantes, use funções que retornam a estrutura preenchida. Ao terminar os testes aí sim incorpore a leitura. Um programa interativo é chato para testar. Durante o desenvolvimento ninguém quer interagir com o programa.
Alinhe seu código com algum critério. Evite longas linhas com mais de 60 colunas.
o menu() deve mostrar as opções e ler e retornar a opção. Um void menu() é um desperdício.
Ao usar scanf() ou alguma função da família, como fscanf() entenda que ela retorna um valor. E teste. É ingênuo deixar o programa seguir sem testar. TESTE sempre. Para 5 especificadores --- aquelas coisas com % na frente e que não tem um asterisco nem outro %, como "%d %d %f %f %d" scanf() pode ler de 0 a 5 itens ou dar erro e retornar -1. Então teste o retorno que vai estar entre -1 e 5...
não use fflush(): isso só está definido para fluxos de saída. Em alguns compiladores pode até funcionar, mas é um sinal de fez algo errado
Não existe "lixo de teclado": necessidades como de flush() na entrada indicam apenas que não entendeu bem o que está lendo e o que é a entrada via teclado, free form: o usuário pode digitar qualquer coisa e é o seu programa que tem que se virar O teclado tem ao menos 105 teclas de liberdade e o usuário pode digitar qualquer coisa em qualquer ordem.
evite ler do teclado a menos que seja o objetivo do problema. Ler de arquivos é muito mais simples, seguro e fácil de reproduzir. Não há razão para ficar parado em frente a tela minutos inventando nomes de campos e coisas assim: o efeito é que vai acabar não testando direito porque é difícil controlar e repetir testes.
Não misture entrada de dados ou formatação com a apresentação dos dados ou a lógica do programa, Isso é um desastre para manutenção e desenvolvimento
Um printf() de 6 linhas é muito, mas muito melhor que 6 printf() de 1 linha. E se só vai mostrar o texto puts() é ainda melhor e dezenas de vezes mais rápido que uma série de printf().