UNIP EaD

Projeto Integrado Multidisciplinar

Análise e Desenvolvimento de Sistemas

PIM IV - Sistema em C para cadastrar pacientes diagnosticados com Covid-19

cidade
2021
 UNIP EaD

Projeto Integrado Multidisciplinar

Análise e Desenvolvimento de Sistemas

PIM IV - Sistema em C para cadastrar pacientes diagnosticados com Covid-19

Nome: xxxxxxxxxxxxx
RA: xxxxxxxxxxxxxxx
Curso: Análise e Desenvolvimento de Sistemas
Semestre: Terceiro

cidade

2021
Resumo

O Projeto Integrado Multidisciplinar proposto pela universidade UNIP Interativa, visa aplicar o
conhecimento adquirido no semestre pelas aulas de Engenharia de Software I e Linguagem e
Técnicas de Programação. Este projeto propõe o desenvolvimento de um sistema em linguagem C
para cadastro de pacientes diagnosticados com covid-19. Apresento de forma objetiva todos os
requisitos necessários para o desenvolvimento do sistema, iniciando com um breve estudo teórico
sobre engenharia de software e a linguagem de programação utilizada no sistema. Neste projeto
também será apresentado uma análise de requisitos para o sistema, apontando todas as funcionais e
não-funcionais da aplicação, e suas diferenças. Além das apresentações dos fluxogramas de dados e
as atividades desenvolvidas para a elaboração da aplicação, explicando suas funções e código fonte
do sistema.
Abstract
The Integrated Multidisciplinary Project proposed by the UNIP Interativa university, aims to apply
the knowledge acquired in the semester by the classes of Software Engineering I and Language and
Programming Techniques. This project proposes the development of a C language system for
registering patients diagnosed with covid-19. I present in an objective way all the necessary
requirements for the development of the system, starting with a brief theoretical study about software
engineering and the programming language used in the system. This project will also present an
analysis of requirements for the system, pointing out all the functional and non-functional aspects of the
application, and their differences. In addition to the presentations of the data flowcharts and the
activities developed for the elaboration of the application, explaining its functions and source code of
the system.
Sumário

1 - Introdução ............................................................................................................................................ 6
2 - Necessidade do Cliente ...................................................................................................................... 7
3 – Referencia Teórica ............................................................................................................................. 7
3.1 - Engenharia de software .................................................................................................................... 7
3.2 - Engenharia de software .................................................................................................................... 7
3.3 - Modelos de processos de Software .................................................................................................. 8
4 - Analise do Sistema............................................................................................................................ 10
4.1 - Definição de Requisitos .................................................................................................................. 10
4.1.1 - Requisitos funcionais .................................................................................................................. 10
4.1.2 - Requisitos não-funcionais ........................................................................................................... 10
5 - Codificação ........................................................................................................................................ 11
6 - Código do Sistema ............................................................................................................................ 14
7 - Conclusão .......................................................................................................................................... 16
8 - Referência ......................................................................................................................................... 17
 6

1 Introdução

Este projeto tem como objetivo o desenvolvimento de um sistema para auxiliar os

professores na elaboração de relatórios de notas de suas classes, de forma rápida e com uma
interface de fácil entendimento, eliminando a necessidade de cálculos matemáticos e
preenchimentos de papeis, reduzindo o tempo gasto na atividade e minimizando a probabilidade de
erros.
Para o desenvolvimento do sistema utilizaremos a linguagem C e a ferramenta de
desenvolvimento DEV C++.
Neste relatório apresentaremos todas as funções e módulos disponíveis no sistema, com o
objetivo de proporcionar uma visão abrangente dos recursos disponíveis na aplicação e facilitar o
entendimento aos interessados.
Também iremos apresentar o modelo adotado de ciclo de vida para o desenvolvimento do
sistema, apresentando a justificativa para tal escolha, o cronograma de atividades adotado para a
elaboração e o fluxograma do sistema.
Por fim ainda apresentaremos a estrutura lógica do código com a explicação de cada função
do sistema.
 7

2 Necessidade do Cliente

O cliente será a área de UTI de um Hospital onde necessita de um sistema para

cadastro e gerenciamento e controle de doenças principalmente Covid 19.
O sistema deve ser capaz de registrar os pacientes cadastrados na UTI e poderá
controlar os dados de tratamento de cada paciente tempo de internação, tipo de tratamento
aplicado.

3 Referencial Teórico

3.1 Linguagem de programação C

Criada em 1972, por Dennis Ritchie, C é uma das linguagens de programação mais populares
e tem influenciado muitas outras linguagens de programação, no final da década de 70, a linguagem
C começou a substituir a linguagem BASIC como a linguagem de programação mais utilizada.
C é uma linguagem imperativa e procedural com pontos primários em fornecer um
desenvolvimento com acesso de baixo nível à memória e baixos requerimentos de hardware,
desenvolvido também para ser utilizado como linguagem de alto nível com maior reaproveitando de
código.
É uma linguagem extremamente simples, com diversos recursos que dão maior flexibilidade
a programação, como a utilização de ponteiros e estrutura de variáveis (structs), que permitem que
dados relacionados sejam combinados e manipulados como um todo, por ser reconhecida como
linguagem estruturada permite muitas possibilidades de programação, suportando construções de
diversos loops (laços), e a criação de funções, que são blocos de construção onde pode possuir
diversos parâmetros e atividades que serão executadas no programa.

3.2 Engenharia de software

A Engenharia de Software se concentra nos aspectos práticos da produção de um sistema

de software. Os fundamentos científicos para a engenharia de software envolvem o uso de
modelos abstratos e precisos que permitem ao engenheiro especificar, projetar, implementar e
manter sistemas de software, avaliando e garantindo suas qualidades. Além disso, a engenharia de
software deve oferecer mecanismos para se planejar e gerenciar o processo de desenvolvimento de
um sistema computacional. O termo engenharia de software começou a ser utilizado oficialmente em
1968 na NATO Science Committee.
 8

3.3 Modelos de processos de Software

A engenharia de software tem produzido inúmeros modelos de ciclo de vida, incluindo os

modelos de cascata, espiral e desenvolvimento rápido de aplicações. Antes do modelo de cascata
ser proposto em 1970, não havia concordância em termos dos métodos a levar a cabo no
desenvolvimento de software. Desde então ao longo dos anos muitos modelos têm sido propostos
refletindo assim a grande variedade de interpretações e caminhos que podem ser tomados no
desenvolvimento de software.

Modelos de processos de software:

• Desenvolvimento iterativo e incremental - desenvolvimento é iniciado com um

subconjunto simples de Requisitos de Software e iterativamente alcança evoluções subsequentes
das versões até o sistema todo estar implementado;

• Evolucional ou Prototipação - especificação, projeto e desenvolvimento de protótipos.

• V-Model - Parecido com o modelo cascata, mas com uma organização melhor, que
permite que se compare com outros modelos mais modernos. Principal ponto é que para cada etapa
de um lado tem uma verificação do outro, criando um gráfico no formato da letra V com 2 cascatas.
• Espiral - O modelo espiral incorpora-os de uma forma iterativa permitindo que as ideias e
o progresso sejam verificados e avaliados constantemente. Cada iteração à volta da espiral pode ser
baseada num modelo diferente e pode ter diferentes atividades. No modelo espiral para engenharia
de requisitos mostra-se que as diferentes atividades são repetidas até uma decisão ser tomada e
o documento de especificação de requisitos a ser aceito.

• Sequencial ou Cascata - com fases distintas de especificação, projeto e

desenvolvimento. Este modelo foi o primeiro modelo a ser conhecido em engenharia de software e
está na base de muitos ciclos de vida utilizados nos dias de hoje. Este consiste basicamente num
modelo linear em que cada passo deve ser completado antes que o próximo passo possa ser
iniciado.
 9

Modelo cascata

Fonte: https://pt.wikipedia.org/wiki/Ficheiro:Waterfall_diagram.jpg

O projeto é baseado neste modelo, que é um modelo bem definido, no qual os processos são
executados de forma sequencial. Os principais estágios do modelo cascata retratam as atividades
de desenvolvimento fundamentais, conforme é esquematizado na figura a cima.
 10

4 ANALISE DO SISTEMA

4.1 Definição de Requisitos

A definição de requisitos de software envolve as atividades de determinar qual o objetivo do

software e suas restrições. O objetivo da definição dos requisitos é especificar o que o sistema

deverá fazer e determinar os critérios de validação que serão utilizados para que se possa avaliar se

o sistema cumpre o que foi definido.

Tradicionalmente, os requisitos de um software são separados em requisitos funcionais e
não-funcionais, na Engenharia de Software é propagada a definição de que os requisitos funcionais
definem o que o sistema fará e os requisitos não-funcionais definem como o sistema fará.

4.1.1 Requisitos não-funcionais

Os requisitos prioritários, não-funcionais, considerados para o projeto de desenvolvimento

do sistema foram, a usabilidade, disponibilidade, organização e legibilidade.

• RNF01 – Usabilidade: Para garantir a usabilidade a interface do sistema possui telas de fácil
entendimento e aprendizagem, maximizando a produtividade e minimizando a taxa de erros.
• RNF02 – Disponibilidade: Para garantir a disponibilidade o sistema possui todo seu modulo
baseado em aplicações off-line, podendo ser utilizado onde e quando for necessário.
• RNF03 – Organização e Legibilidade: Para garantir a organização e legibilidade do sistema, o
código é organizado e comentado de forma a qualquer desenvolvedor com conhecimento da
linguagem de programação possa entender o código-fonte.

4.1.2 Requisitos funcionais

Os requisitos funcionais para o desenvolvimento do sistema são: cadastro de alunos,
cadastro de notas, cálculo de média, e impressão em tela de relatórios.
RF01 – Cadastro de Paciente: O sistema devera possuir um módulo para cadastro dos paciente,
contendo o nome do paciente e seu número de atendimento.
RF02 – Cadastro Enfermidade: Armazenar tipos de doenças.
RF03 – Dias: O sistema informar os dias de internação
RF04 – Impressão em tela de relatórios: Exibir em tela um relatório com a situação de
todos os pacientes e suas condições em geral da classe.
 11

5 CODIFICAÇÃO

Para o desenvolvimento do software envolvido neste trabalho utilizamos o DEV C++ como IDE
(Integrated Development Environment) ou Ambiente de Desenvolvimento Integrado. Este compilador
utiliza os compiladores do projeto GNU para conseguir compilar programas baseados no sistema
operacional Microsoft Windows. Possível escrever programas utilizando-se das linguagens C e C++,
possuindo ainda suporte a toda biblioteca ANSI. A IDE foi desenvolvida utilizando-se a linguagem que
não será objetivo deste trabalho. No caso especifico de nosso projeto utilizamos a linguagem C para
toda a codificação desenvolvida no projeto. Seguem abaixo algumas características importantes da
linguagem C:

1. Um programa em C é composto por um conjunto de Funções.

2. A função pela qual o programa começa a ser executado chama-semain.3. Após cada comando em
C deve-se colocar um; (ponto-e-vírgula).4. Um programa em C deve ser isentado para que possa ser
lido com mais facilidade.

Além disso é importante discutirmos que tipos de componentes estruturas da linguagem foram
utilizados em nosso desenvolvimento para correto entendimento dos trechos de código produzidos
em nosso trabalho. Começar discutindo os identificadores, que nada mais são do que os nomes que
daremos as nossas funções ou variáveis. Identificadores como dissemos acima são os nomes que
daremos as nossas funções ou variáveis. Para que isso seja feito de forma correta é necessário
seguir algumas regras universais que foram convencionadas para que os códigos sejam compilados
com sucesso.

• Um identificador deve iniciar por uma letra ou por um "_"(underscore);

• A partir do segundo caractere pode conter letras, números eunderscore;

• Deve-se usar nomes significativos dentro do contexto do programa;

• C é uma linguagem case-sensitivo, ou seja, faz diferença entre nomes com letras maiúsculas e
nomes com letras minúsculas. Peso e peso são diferentes;

• Costuma-se usar maiúsculas e minúsculas para separar palavras;

• Deve ser diferente dos comandos da linguagem;
• Deve ter no máximo 31 caracteres;
• Pode conter números a partir do segundo caractere. Variáveis são formas que temos de dar nomes
a posições em memória para armazenamos valores que precisaremos para utilizar em nossa lógica
de programação.

É possível atribuir novos valores através de comandos de atribuição, onde altera o valor
armazenado naquela posição de memória para um novo valor durante a execução de nosso software.
Cada variável na linguagem C, assim como em outras linguagens, possuem tipos diferentes que
 12

podem ser atribuídos a cada uma delas. Especificamente em C, temos alguns tipos de variáveis e
seus respectivos exemplos abaixo:

• Char: letras e símbolos: 'a', 'b', 'H', '^', '*','1','0';

• Int: de -32767 até 32767 (apenas números inteiros)
• Float: de -3.4 x 1038 até +3.4 x 10+38com até 6 dígitos de precisão
• Double: de -1.7 x 10308 até +1.7 x 10+308com até 10 dígitos de precisão

É importante notar que cada variável possui apenas, e somente um tipo. Além disso todas as
variáveis de seu programa devem ser declaradas corretamente antes de serem iniciadas com
quaisquer valores.

No caso das variáveis vimos que elas podem ter seu valor alterado ao longo do programa, caso
tenha casos onde precisar lidar com valores que não se alteram, temos um tipo especifico de
estrutura chamada CONSTANTES para este fim. Usualmente em C utiliza-se o comando #define para
se declarar constantes no início do código-fonte do seu programa. Existem ainda as variáveis do tipo
String que são utilizadas para armazenamento de um conjunto de caracteres que são declarados
sempre entre aspas duplas, ao se declarar estas variáveis é mandatório determinar a quantidade de
caracteres que esta variável será capaz de armazenar. Este comando de atribuição de um valor a
uma variável do tipo String se dá pelo comando strcpy. A função printf exibe dados na tela. Esta
função deve receber pelo menos dois parâmetros, separados por vírgula:

• String de formato que define, através de caracteres especiais, os tipos os dados a serem impressos
e suas posições na linha de impressão;

• Dado a ser impresso. Este dado pode ser qualquer um dos dados visto anteriormente.

Segue um exemplo do uso da função printf abaixo: rintf ("%s","código-Fonte"); "%s”: é a string
de formato "Código-fonte”: é o dado a ser impresso. A string de formato define quais os tipos dos
dados a serem impressos, enquanto o símbolo %s será substituído pelo dado que vem após a
vírgula. Os dados definem quais os valores a serem impressos. Em alguns casos é necessário que
uma string de formato pode ter a necessidade de definir que mais de um dado será impresso. Para
que isso seja possível, ao se utilizar a string de formato deve haver mais de um %, quantas vezes
tivermos dados a serem impressos. Neste caso, os dados devem vir após a string de formato
separados por vírgulas. É possível ainda imprimir números inteiros utilizando-se da função printf ao
se utilizar o sinalizador %d. Caso estejamos trabalhando com números reais deve-se utilizar o
sinalizador %f, no caso dos números reais é possível ainda determinar via código, de que forma o
número será exibido na tela, para isso usamos em conjunto com o %f uma determinação de quantas
casas decimais o número deve ter. Determina-se também o número total de caracteres do número a
ser impresso. por exemplo: %4.2f especifica que se quer imprimir um float com 2 casas decimais e
com um tamanho total de 4 caracteres no total. Seguem-se regras para impressão de um número
real:
 13

• O número de casas decimais é sempre respeitado. Se for preciso, zeros serão acrescentados à
direita do número;

• O tamanho total significa o número de caracteres do número incluindo o ponto decimal e um

eventual sinal de menos (-), se foro caso;

• Se a soma do número de caracteres da parte inteira, mais o ponto decimal, mais a parte fracionária,
mais um eventual sinal de menos ainda for menor do que o tamanho total especificado no formato,
então, espaços em branco serão acrescentados à esquerda da parte real do número;
• Se a soma do número de caracteres da parte inteira, mais o ponto decimal, mais a parte fracionária,
mais um eventual sinal de menos for maior do que o tamanho total especificado no formato, então,
apenas o número de casas decimais é respeitado. Ainda se tratando de números, podemos lidar com
os operadores aritméticos:
• -: sinal de menos (unário) - Maior precedência (avaliado antes);

• *,/ - multiplicação e divisão

• % - módulo (reto da divisão)
• +,- - soma e subtração - Menor precedência (avaliado depois)

No caso de nosso programa ainda lidamos com uma parte importante da linguagem C: as
bibliotecas. O nome e as características de cada função que fazem parte de determinada biblioteca
estão em um arquivo chamado cabeçalho, mas a implementação das funções está em um arquivo
separado. A nomenclatura e o objetivo dos cabeçalhos são comuns a diferentes implementações,
mas a organização das bibliotecas pode ser feita de forma diferente, isto significa que cada
compilador C possui sua implementação da biblioteca padrão C especifica ao seu contexto. Como os
compiladores C geralmente oferecem funcionalidades adicionais que não são especificadas pelo
ANSI C, a implementação da biblioteca padrão de um compilador tende a não funcionar com os
demais. Em nosso programa utilizamos especificamente utilizamos as bibliotecas stdio.h stdlib.h. A
biblioteca stdio.h é uma das principais e mais usadas bibliotecas em C pois é quem nos permite
interagir com a entrada e saída de dados para os programas sendo desenvolvidos, o seu nome vem
do significado de standard input and output, ou seja, padrão de entrada e saída. Ela inclui as
operações mais comuns como tratamento de entrada/saída e conjunto de caracteres. Ao contrário de
outras linguagens como COBOL, Fortran e, C não inclui palavras-chave nativas para essas tarefas, o
que significa que praticamente todos os programas desenvolvidos em C farão uso dela.

A biblioteca stdio.h por exemplo contém funções importantes como printf e scanf, ambas
amplamente usados em programas desenvolvidos em C. Já a biblioteca stdlib.h funciona como um
emulador do terminal dois temas operacionais em que você está trabalhando, caso seja Windows ele
emula todos os comandos do terminal do DOS, e caso você estiver trabalhando no Linux, quem será
emulado é o Terminal.

É através desta biblioteca que conseguimos com apenas algumas linhas de código acessar
pastas, mover diretórios e executar programas por exemplo.
 14

6 Código do Sistema
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <time.h>

/* Constantes */
#define T_ESTADO 10
#define T_CIDADE 30
#define T_RUA 25
#define T_CEP 10
#define T_NOME 40
#define T_TELEFONE 15
#define T_DIAGNOSTICO 500
#define T_PROBLEMA 500

#define STR_MAX 250

/* Definições */
struct info_data
{
unsigned char dia, mes;
unsigned short ano;
};

struct info_endereco
{
char estado[T_ESTADO];
char cidade[T_CIDADE];
char rua[T_RUA];
char cep[T_CEP];
unsigned short casa;
unsigned short quadra;
};

struct dados_paciente
{
char nome[T_NOME];
unsigned char idade;
struct info_data data;
struct info_endereco endereco;
char telefone[T_TELEFONE];
char diagnostico[T_DIAGNOSTICO];
char problema[T_PROBLEMA];
};
void
pressEnter(void);

void
erroMsg(char *m);

void
mostraInfoPaciente(struct dados_paciente *p);

int
pegaInfoPaciente(struct dados_paciente *p);

int main(void)
{
struct dados_paciente paciente;
if (pegaInfoPaciente(&paciente)) {
printf("\nCadastro incompleto!\n");
printf("tchau!");
pressEnter();
return(0);
} else {
printf("\nOs dados do paciente.\n");
mostraInfoPaciente(&paciente);
}
pressEnter();
return(0);
}

void
pressEnter(void)
{
printf("\nPressione enter para continuar...");
getchar();
}

void
erroMsg(char *m)
{
printf("\n%s",m);
pressEnter();
}

void
mostraInfoPaciente(struct dados_paciente *p)
{
printf("\nFicha do paciente\n");
printf("Nome:\t%s", p->nome);
printf("Idade:\t%hhu\n", p->idade);
printf("Data de nascimento:\t%hhu\\%hhu\\%hu\n", p->data.dia, p->data.mes, p->data.ano);
}

int
pegaInfoPaciente(struct dados_paciente *p)
 15

{
char str[STR_MAX], op;
do {
printf("\n\tPreencha a ficha do paciente.");
/* Pega o nome do paciente */
do {
printf("\nDigite o nome completo do paciente.\n");
fgets(str, STR_MAX, stdin);
if (strlen(str) > T_NOME) {
printf("O nome do paciente deve ser menor do que %i caracteres.",T_NOME);
pressEnter();
} else {
printf("\nO nome está correto S\\N.\nDigite 0 para voltar para o menu anterior.\n:");
scanf("%c%*c",&op);
if (op == '0')
return(1);
}
} while (strlen(str) > T_NOME || toupper(op) == 'N');
strcpy(p->nome, str);

/* Pega a idade do paciente */

do {
printf("\nDigite a idade do paciente.\n");
fgets(str, STR_MAX, stdin);
p->idade = atoi(str);
if (strlen(str) > 3 || p->idade == 0) {
erroMsg("Idade invalida.");
} else {
printf("\nA idade esta correta S\\N\nDigite 0 para voltar para o menu anterior.\n:");
scanf("%c%*c",&op);
if (op == '0')
return(1);
}
} while (strlen(str) > 3 || p->idade == 0);

do {
/* Pega a data de nascimente do paciente */
printf("\nDigite a data de nascimento do paciente.\n");
/* Dia */
do {
printf("\nDigite dia.\n");
fgets(str, STR_MAX, stdin);
p->data.dia = atoi(str);
if (strlen(str) > 3 || p->data.dia == 0 || p->data.dia > 31) {
erroMsg("dia invalido.");
} else {
printf("\no dia esta correta S\\N\nDigite 0 para voltar para o menu anterior.\n:");
scanf("%c%*c",&op);
if (op == '0')
return(1);
}
} while (strlen(str) > 3 || p->data.dia == 0 || p->data.dia > 31);
/* Mês */
do {
printf("\nDigite mes.\n");
fgets(str, STR_MAX, stdin);
p->data.mes = atoi(str);
if (strlen(str) > 3 || p->data.mes == 0 || p->data.mes > 12) {
erroMsg("mes invalido.");
} else {
printf("\no mes esta correta S\\N\nDigite 0 para voltar para o menu anterior.\n:");
scanf("%c%*c",&op);
if (op == '0')
return(1);
}
} while (strlen(str) > 3 || p->data.mes == 0 || p->data.mes > 12);
/* Ano */
do {
printf("\nDigite ano.\n");
fgets(str, STR_MAX, stdin);
p->data.ano = atoi(str);
if (strlen(str) > 5 || p->data.ano < 1920 || p->data.ano > 2100) {
erroMsg("ano invalido.");
} else {
printf("\no ano esta correta S\\N\nDigite 0 para voltar para o menu anterior.\n:");
scanf("%c%*c",&op);
if (op == '0')
return(1);
}
} while (strlen(str) > 5 || p->data.ano < 1920 || p->data.ano > 2100);
printf("\n%hhu\\%hhu\\%hu", p->data.dia, p->data.mes, p->data.ano);
printf("\nA data de nascimento esta correta\nS\\N:");
scanf("%c%*c",&op);
} while (toupper(op) == 'N');

mostraInfoPaciente(p);
printf("\nA ficha do paciente esta correta?\nS\\N:");
scanf("%c%*c", &op);
} while (toupper(op) != 'S');
return(0);
}
 16

7 Conclusão
Durante o desenvolvimento do projeto, adquirimos inúmeros conhecimentos sobre
engenharia de software e linguagem de programação, explorando diversos modelos de processos de
software e seus requisitos, além dos conhecimentos de transição teórico-prática, com a criação do
software desenvolvido, que satisfaz as necessidades do cliente para que ele utilize o sistema de
forma fácil e pratica evitando assim preenchimentos de papeis, reduzindo o tempo de mão de obra e
minimizando a probabilidade de erros no exercício de suas atividades.
 17

8 Referências

ALVES, William Pereira. C++ Builder 6: desenvolva aplicações para Windows. 2. ed.
São Paulo: Érica, 2007
MIZRAHI, Viviane Victorine. Treinamento em Linguagem C++. 2. ed. São Paulo:
Pearson Education, 2005.
MANZANO, José Augusto N. G.. Programação de Computadores com C++: guia
rápido de orientação e desenvolvimento. São Paulo: Érica, 2010
PRESSMAN, Roger S.. Engenharia de Software: uma abordagem profissional. 7 ed.
AMGH, 2011.