ALGORITMOS E PROGRAMAÇÃO APLICADA

Prévia do material em texto

<p>ALGORITMOS E</p><p>PROGRAMAÇÃO APLICADA</p><p>PROF. FÁBIO ATAIDE DE LIMA</p><p>PROFA MA. CLAUDIA HEIDEMANN DE SANTANA</p><p>REITORIA:</p><p>Dr. Roberto Cezar de Oliveira</p><p>PRÓ-REITORIA:</p><p>Profa. Ma. Gisele Colombari Gomes</p><p>DIRETORIA DE ENSINO:</p><p>Profa. Dra. Gisele Caroline Novakowski</p><p>EQUIPE DE PRODUÇÃO DE MATERIAIS:</p><p>Diagramação</p><p>Revisão textual</p><p>Produção audiovisual</p><p>Gestão</p><p>WWW.UNINGA.BR</p><p>33WWW.UNINGA.BR</p><p>U N I D A D E</p><p>INTRODUTÓRIA</p><p>U N I D A D E</p><p>SUMÁRIO DA UNIDADE</p><p>INTRODUÇÃO ................................................................................................................................................................4</p><p>1 ORGANIZAÇÃO BÁSICA DE UM SISTEMA COMPUTACIONAL ..............................................................................5</p><p>1.1 EVOLUÇÃO DOS SISTEMAS COMPUTACIONAIS .................................................................................................5</p><p>1.2 COMPONENTES DE UM SISTEMA COMPUTACIONAL ....................................................................................... 7</p><p>1.2.1 HARDWARE .......................................................................................................................................................... 7</p><p>1.2.2 SOFTWARE ...........................................................................................................................................................9</p><p>1.3 SISTEMAS DE NUMERAÇÃO UTILIZADOS NOS SISTEMAS COMPUTACIONAIS ............................................ 11</p><p>1.3.1 SISTEMA DECIMAL ............................................................................................................................................. 12</p><p>1.3.2 SISTEMA BINÁRIO ............................................................................................................................................. 13</p><p>1.3.3 SISTEMAS OCTAL E HEXADECIMAL ................................................................................................................ 13</p><p>CONSIDERAÇÕES FINAIS ........................................................................................................................................... 15</p><p>ORGANIZAÇÃO BÁSICA DE UM</p><p>SISTEMA COMPUTACIONAL</p><p>PROFA MA. CLAUDIA HEIDEMANN DE SANTANA</p><p>ENSINO A DISTÂNCIA</p><p>DISCIPLINA:</p><p>ALGORITMOS E PROGRAMAÇÃO APLICADA</p><p>4WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>IN</p><p>TR</p><p>OD</p><p>UT</p><p>ÓR</p><p>IA</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>INTRODUÇÃO</p><p>Você está pronto(a) para iniciar seus estudos introdutórios sobre Algoritmos e</p><p>Programação Aplicada? Especificamente nesta unidade introdutória, vamos trabalhar sobre a</p><p>organização básica de um sistema computacional. Pronto(a) para o início da aprendizagem?</p><p>Caro(a) aluno(a), esta unidade procura explicar algumas definições, conceitos e</p><p>curiosidades sobre os Sistemas Computacionais e seus principais componentes. Você também</p><p>aprenderá a categorizar as principais partes de um computador e as diferenças entre elas.</p><p>Ao final desta unidade, você deve apresentar os seguintes aprendizados:</p><p>• Reconhecer processamento de dados e sistemas de computação;</p><p>• Identificar a evolução dos computadores;</p><p>• Descrever a diferença entre hardware e software;</p><p>• Conhecer sobre os Sistemas de Numeração utilizados nos sistemas digitais.</p><p>Em um mundo cada vez mais digital, é necessário conhecer os termos básicos relacionados</p><p>à informática. Seja qual for a sua área, a tecnologia e os sistemas digitais estão cada vez mais</p><p>presentes no nosso dia a dia, no celular, na TV, no carro, no ar-condicionado e até mesmo no seu</p><p>grill.</p><p>5WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>IN</p><p>TR</p><p>OD</p><p>UT</p><p>ÓR</p><p>IA</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>1 ORGANIZAÇÃO BÁSICA DE UM SISTEMA COMPUTACIONAL</p><p>“O software tornou-se o elemento-chave da evolução e produtos baseados em</p><p>computador” (PRESSMAN, 1995).</p><p>Um Sistema Computacional é um tipo especializado de sistema, que tem como finalidade</p><p>processar e armazenar informações. O que torna os sistemas computacionais tão essenciais hoje?</p><p>O que você está fazendo agora? Utilizando o computador, não é verdade? Mas o que está por trás</p><p>deste monitor? O que torna possível você acessar este curso?</p><p>No computador, existem componentes envolvidos no processo, vale dizer, o sistema</p><p>computacional. Esse sistema possui dois componentes principais: o Software e o Hardware.</p><p>Um sistema computacional refere-se ao conjunto de dispositivos eletrônicos (hardware)</p><p>que processam informações através de um programa (software). Ele é uma combinação de</p><p>hardware, software e inteligência humana.</p><p>Vou explicar melhor os componentes de um Sistema Computacional:</p><p>Hardware: é o equipamento físico, computadores e periféricos. Juntos, processam dados</p><p>e informações e permitem sua visualização.</p><p>Software: consiste nas instruções, conjunto de programas que permitem que o hardware</p><p>processe os dados. São divididos em duas principais categorias: Sistema Operacional - controla</p><p>e coordena o uso do hardware entre os vários programas de aplicação de vários usuários; e</p><p>Programas de Aplicação - definem como os recursos do sistema serão utilizados pelos usuários</p><p>(gerenciadores de bancos de dados, antivírus, editores de texto, planilhas eletrônicas etc.).</p><p>Veremos mais adiante, com mais detalhes, sobre software e seus diferentes tipos.</p><p>Para completar este sistema, temos ainda os usuários, que são os indivíduos que trabalham</p><p>com o sistema ou utilizam a sua saída. São usuários e operadores de hardware e software.</p><p>Assim, já temos os elementos para um sistema computacional, mas, no caso da pergunta</p><p>inicial, que envolvia como você está tendo acesso a este curso, temos ainda:</p><p>- Tecnologia de redes: sistema de ligação, que permite o compartilhamento de recursos</p><p>entre computadores.</p><p>- Tecnologia de dados: softwares e hardwares que comandam a organização dos dados</p><p>em meios físicos de armazenagem.</p><p>1.1 Evolução dos Sistemas Computacionais</p><p>Os sistemas computacionais evoluíram com o passar do tempo (assim como a tecnologia),</p><p>passando da operacionalização das tarefas rotineiras à integração entre os diferentes sistemas,</p><p>com recursos e usos diferenciados.</p><p>Dos primeiros computadores à Internet: nesse vídeo, você verá</p><p>sobre a evolução dos computadores, sua utilização, primeiros</p><p>games, interfaces, surgimento da Internet no mundo e primeiras</p><p>experiências no Brasil.</p><p>Acesse-o em https://www.youtube.com/watch?v=B3flG27KgVQ.</p><p>https://www.youtube.com/watch?v=B3flG27KgVQ</p><p>6WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>IN</p><p>TR</p><p>OD</p><p>UT</p><p>ÓR</p><p>IA</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>Cronologicamente, a evolução dos sistemas computacionais se deu em cinco gerações,</p><p>que são: computadores à válvula, computadores a transistor, circuitos integrados, circuitos VLSI</p><p>e tecnologia ULSI (Ultra Large Scale Integration). O primeiro computador, segundo pesquisas, foi</p><p>desenvolvido pelo engenheiro mecânico Charles Babbage, que inventou o primeiro equipamento</p><p>considerado um computador mecânico, ainda no século XIX. Já na década de 1940, os</p><p>computadores de uso geral, que usavam algoritmos simples para perfurar cartões, substituíram</p><p>os computadores mecânicos, sendo o ENIAC (Electronic Numerical Integrator and Computer) o</p><p>primeiro computador digital eletrônico programável e principal representante dessa primeira</p><p>geração.</p><p>Da segunda geração, marcada pelos transistores (e com eles a possibilidade de</p><p>comercialização do computador), podemos destacar o UNIVAC ERA 1101, que foi o primeiro</p><p>programa de computador armazenado nos EUA. Os transistores eram também mais rápidos que</p><p>as válvulas e, portanto, eles também contribuíram para aumentar a velocidade computacional.</p><p>Figura 1 - UNIVAC/ERA 1101: primeiro computador da história que rodava um programa da memória.</p><p>Fonte: Dibble (2021).</p><p>Portanto, os computadores da era dos transistores (ou da segunda geração) eram não só</p><p>mais pequenos, mas também mais rápidos que os das válvulas eletrônicas.</p><p>Com a terceira geração (no início da década de 1960, surgimento</p><p>o</p><p>compilador deve convertê-las em um mesmo tipo para poder resolver a expressão com os valores</p><p>normalizados; isto se chama promoção de tipo e é feito operação por operação em uma expressão</p><p>seguindo esta ordem do menor para o maior tipo: char → int → long → float → double → long</p><p>double (SCHILDT, 1996).</p><p>A Figura 5 a seguir ilustra alguns exemplos de conversões implícitas, aquelas que o</p><p>compilador realiza automaticamente resolvendo a expressão de acordo com o maior operando</p><p>em uma operação.</p><p>Figura 5 – Exemplo de conversões implícitas. Fonte: Schildt (1996).</p><p>É possível também realizar conversões explícitas, conhecidas como casts, onde passamos</p><p>o tipo final desejado entre parênteses à esquerda do operando, seja uma constante ou uma</p><p>expressão. Sua sintaxe geral é: (tipo) operando (SCHILDT, 1996).</p><p>Por exemplo, para garantir que a expressão x / 2 resulte em um valor com decimais,</p><p>podemos usar: (float)x / 2. Mesmo que x seja um inteiro, será convertido em ponto flutuante e</p><p>terá predominância sobre o segundo operando 2, que é um inteiro. Casts são muito utilizados na</p><p>manipulação avançada de ponteiros e estruturas definidas pelo usuário.</p><p>42WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>1</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>6 ENTRADA E SAÍDA DE DADOS</p><p>A maior parte dos programas é estruturada para receber dados de entrada do usuário,</p><p>que serão processados de alguma forma e depois serão apresentados os resultados na forma</p><p>de informações. Esse ciclo, ilustrado na Figura 6 a seguir, pode-se repetir quantas vezes forem</p><p>necessárias dentro de um programa para solucionar um determinado problema.</p><p>Figura 6 – Estrutura do fluxo padrão de um programa. Fonte: O autor.</p><p>Conforme ilustrado no Quadro 5 desta unidade, a entrada e a saída de dados estão entre</p><p>as operações primitivas que o computador realiza. Toda linguagem de programação deve prover</p><p>recursos para que o usuário possa:</p><p>• informar dados usando um dispositivo de entrada – teclado, mouse, scanner etc.</p><p>• visualizar os resultados depois de processados em um dispositivo de saída –monitor,</p><p>impressora, projetor etc.</p><p>As principais funções fornecidas pela linguagem C com esta finalidade são: scanf(), para</p><p>entrada de dados; e printf(), para saída de dados. Abordamos essas funções com detalhes nas</p><p>seções seguintes.</p><p>43WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>1</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>6.1 Entrada de Dados</p><p>A função scanf() lê dados fornecidos pelo usuário e os armazena em variáveis. Segundo</p><p>Deitel (2011), sua sintaxe é a seguinte:</p><p>scanf( string-de-controle-de-formato, outros-argumentos );</p><p>Onde string-de-controle-de-formato descreve os formatos da entrada, e outros-</p><p>argumentos são ponteiros para as variáveis em que a entrada será armazenada. Cada especificador</p><p>de formato inserido na string deve vir acompanhado de um ponteiro para a variável onde o valor</p><p>será armazenado, e na devida ordem em que foram especificados.</p><p>44WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>1</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>O Quadro 22 a seguir apresenta os especificadores de formato disponíveis. Eles devem ser</p><p>precedidos na string com o caracter “%”.</p><p>Tipo de dado Especificador</p><p>de conversão Descrição Argumento</p><p>correspondente</p><p>Inteiro</p><p>d Lê um inteiro decimal com sinal</p><p>opcional Ponteiro para um int</p><p>i Lê um inteiro decimal, octal ou</p><p>hexadecimal com sinal opcional Ponteiro para um int</p><p>o Lê um inteiro octal Ponteiro para um</p><p>unsigned int</p><p>u Lê um inteiro decimal sem sinal Ponteiro para um</p><p>unsigned int</p><p>x ou X Lê um inteiro hexadecimal sem sinal Ponteiro para um</p><p>unsigned int</p><p>h ou l</p><p>Colocados antes de qualquer um dos</p><p>especificadores de conversão de inteiros</p><p>para indicar que um inteiro short ou</p><p>um inteiro long deve ser inserido.</p><p>N/A</p><p>Ponto</p><p>flutuante</p><p>e, E, f, g ou G Lê um valor de ponto flutuante Ponteiro para um float</p><p>l ou L</p><p>Colocados antes de qualquer um dos</p><p>especificadores de conversão de ponto</p><p>flutuante para indicar que um valor</p><p>double ou um long double deve ser</p><p>inserido</p><p>Ponteiro para uma</p><p>variável double ou uma</p><p>variável long double</p><p>Caracteres e</p><p>strings</p><p>c Lê um caractere Ponteiro para um char</p><p>s Lê uma string</p><p>Ponteiro para um</p><p>vetor do tipo char com</p><p>tamanho suficiente</p><p>para guardar a string</p><p>e um caractere nulo</p><p>(‘\0’) de término,</p><p>automaticamente</p><p>acrescentado</p><p>[caracteres de</p><p>varredura]</p><p>Varre uma string em busca de um</p><p>conjunto de caracteres que estão</p><p>armazenados em um vetor</p><p>N/A</p><p>Diversos</p><p>p Lê um endereço de memória</p><p>Ponteiro para a variável</p><p>de ponteiro que</p><p>armazenará o endereço</p><p>n</p><p>Armazena o número de caracteres</p><p>inseridos até esse ponto da chamada a</p><p>scanf()</p><p>Ponteiro para um int</p><p>% Salta o sinal de porcentagem (%) na</p><p>entrada N/A</p><p>Quadro 22 – Especificadores de conversão. Fonte: Deitel (2011).</p><p>45WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>1</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>Para usar a função scanf() em um programa, devemos incluir o arquivo de cabeçalho</p><p>padrão stdio.h, conforme explicado na seção 2.4 desta unidade. O Quadro 23 a seguir apresenta</p><p>um programa completo que ilustra diversos exemplos de entrada de dados usando scanf().</p><p>#include</p><p>int main(void) {</p><p>char nome[30], nota;</p><p>float altura;</p><p>int dia, mes, ano;</p><p>printf(“Digite o seu nome: “);</p><p>scanf(“%s”, nome);</p><p>printf(“Digite a altura: “);</p><p>scanf(“%f”, &altura);</p><p>printf(“Nascimento (DD/MM/AAAA): “);</p><p>scanf(“%d/%d/%d”, &dia, &mes, &ano);</p><p>printf(“Digite a nota (A-E): “);</p><p>fflush(stdin); // Para prevenir o bug de não editar</p><p>scanf(“%c”, &nota);</p><p>return 0;</p><p>}</p><p>Quadro 23 – Exemplos de entrada de dados. Fonte: O autor.</p><p>O endereço de memória de cada variável deve ser passado como parâmetro para a função</p><p>scanf(), para que o valor digitado possa ser armazenado nela. Para isso, utilizamos o operador &;</p><p>a única exceção no exemplo do Quadro 23 é a variável nome, que é um vetor de 30 elementos do</p><p>tipo char – abordamos strings com detalhes na Unidade III. No caso da data de nascimento, temos</p><p>três especificadores %d para a entrada respectiva do dia, mês e ano; por isso temos os endereços</p><p>destas variáveis sendo passados na mesma ordem em que aparecem na string de entrada. Para</p><p>concluir, a instrução fflush(stdin); será colocada antes de cada entrada caractere ou string, para</p><p>prevenir um possível bug no buffer de entrada desses tipos de dados, dependendo do compilador</p><p>C usado.</p><p>46WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>1</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>6.2 Saída de Dados</p><p>A função printf() é a responsável pela impressão de dados em um dispositivo de saída –</p><p>por padrão da tela do monitor. Segundo Deitel (2011), sua sintaxe é idêntica à da função scanf():</p><p>printf( string-de-controle-de-formato, outros-argumentos );</p><p>Os especificadores de formato apresentados na seção anterior também são válidos para</p><p>uso na função printf(), seguindo a mesma lógica de que cada um é acompanhado de uma variável</p><p>como parâmetro na ordem em que foram especificados na string.</p><p>Além dos especificadores de formato, é possível também utilizar caracteres especiais de</p><p>controle, como tabulação e quebra de linha. Chamados de sequência de escape, são representados</p><p>pelo caractere de barra invertida “\” seguidos do referido caractere de escape (DEITEL, 2011). O</p><p>Quadro 24 a seguir apresenta as sequências de escape disponíveis.</p><p>Sequência de escape Descrição</p><p>\' Exibe o caractere de aspas simples (')</p><p>\" Exibe o caractere de aspas duplas (")</p><p>\? Exibe o caractere de ponto de interrogação (?)</p><p>\\ Exibe o caractere de barra invertida (\)</p><p>\a Causa alerta audível (campainha) ou visual</p><p>\b Move o cursor uma posição para trás na linha atual</p><p>\f Move o cursor para o início da página seguinte</p><p>\n Move o cursor para o início da linha seguinte</p><p>\r Move o cursor para o início da linha atual</p><p>\t Move o cursor para a posição de tabulação horizontal seguinte</p><p>\v Move o cursor</p><p>para a posição de tabulação vertical seguinte</p><p>Quadro 24 – Sequências de escape. Fonte: Deitel (2011).</p><p>47WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>1</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>O programa ilustrado no Quadro 25 a seguir complementa o programa do Quadro 23,</p><p>com exemplos de exibição de dados literais e conteúdos de variáveis.</p><p>#include</p><p>int main(void) {</p><p>char nome[30], nota;</p><p>float altura;</p><p>int dia, mes, ano;</p><p>printf(“Digite o seu nome: “);</p><p>scanf(“%s”, nome);</p><p>printf(“Digite a altura: “);</p><p>scanf(“%f”, &altura);</p><p>printf(“Nascimento (DD/MM/AAAA): “);</p><p>scanf(“%d/%d/%d”, &dia, &mes, &ano);</p><p>fflush(stdin); // Para prevenir o bug de não editar</p><p>printf(“Digite a nota (A-E): “);</p><p>scanf(“%c”, &nota);</p><p>// Saída de dados</p><p>printf(“\nSeu nome eh %s”, nome);</p><p>printf(“\nVoce tem %.2f de altura”, altura);</p><p>printf(“\ne nasceu no dia %d do mes %.2d do ano de %d”,</p><p>dia, mes, ano);</p><p>printf(“\nVoce tirou nota %c\n”, nota);</p><p>return 0;</p><p>}</p><p>Quadro 25 – Exemplos de saída de dados. Fonte: O autor.</p><p>48WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>1</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>Repare na possibilidade de formatar os dados numéricos informando a precisão do</p><p>número a ser apresentado na tela. O resultado da execução desse código é ilustrado na Figura 7</p><p>a seguir.</p><p>Figura 7 – Resultado da execução do programa do Quadro 25. Fonte: O autor.</p><p>Vamos agora reescrever em C o algoritmo da soma de dois números, usado como exemplo</p><p>na seção 1 para demonstrar as formas de representação de algoritmos. O Quadro 26 a seguir</p><p>mostra a codificação deste programa.</p><p>#include</p><p>int main(void) {</p><p>int num1, num2;</p><p>printf(“Digite o primeiro numero: “);</p><p>scanf(“%d”, &num1);</p><p>printf(“Digite o segundo numero.: “);</p><p>scanf(“%d”, &num2);</p><p>printf(“Soma dos dois numeros...: %d\n”, num1 + num2);</p><p>return 0;</p><p>}</p><p>Quadro 26 – Programa para somar dois números. Fonte: O autor.</p><p>49WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>1</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>Nesse exemplo, poderíamos como alternativa armazenar a soma em uma terceira variável</p><p>e passá-la como parâmetro para a função printf(). Repare nos exemplos apresentados que as</p><p>variáveis devem ser declaradas logo no início da função, sob pena de erro na hora da compilação.</p><p>Esse livro traz um dos estudos mais completos sobre</p><p>a linguagem C, abordando vários assuntos básicos e</p><p>também de cunho avançado, como manipulação de</p><p>bits e arquivos, pré-processador, dentre outros.</p><p>Seu conteúdo enfatiza a obtenção de clareza nos</p><p>programas por meio de técnicas comprovadas da</p><p>programação estruturada.</p><p>DEITEL, P. J. C: como programar. Tradução: Daniel</p><p>Vieira. 6. ed. São Paulo: Pearson Prentice Hall, 2011.</p><p>Fonte: Deitel (2011).</p><p>50WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>1</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>CONSIDERAÇÕES FINAIS</p><p>Nesta unidade, foi dado o pontapé inicial para o aprendizado de lógica de programação</p><p>através do estudo dos seus elementos básicos. Iniciamos descrevendo o conceito de algoritmo e</p><p>as suas formas de representação para solucionar um determinado problema.</p><p>Em seguida abordamos os programas, que são os algoritmos escritos em uma linguagem</p><p>de programação e traduzidos para linguagem de máquina. Também apresentamos os dois tipos de</p><p>ferramentas existentes para esta finalidade, os compiladores e os interpretadores, e introduzimos</p><p>a linguagem de programação C.</p><p>A partir daí, já no contexto da linguagem, abordamos os tipos de dados existentes, as</p><p>constantes e variáveis, as expressões e os operadores disponíveis para a construção de código de</p><p>processamento.</p><p>Finalizamos a unidade abordando as funções para entrada e saída de dados na tela do</p><p>computador.</p><p>5151WWW.UNINGA.BR</p><p>U N I D A D E</p><p>02</p><p>SUMÁRIO DA UNIDADE</p><p>INTRODUÇÃO ...............................................................................................................................................................53</p><p>1 ESTRUTURAS DE SELEÇÃO .....................................................................................................................................54</p><p>1.1 ESTRUTURA DE SELEÇÃO SIMPLES ....................................................................................................................54</p><p>1.2 ESTRUTURA DE SELEÇÃO COMPOSTA ...............................................................................................................56</p><p>1.3 CONDIÇÃO TERNÁRIA ...........................................................................................................................................58</p><p>1.4 ENCADEAMENTO DE IFS ......................................................................................................................................60</p><p>1.5 ESTRUTURAS DE SELEÇÃO MÚLTIPLA ...............................................................................................................63</p><p>2 ESTRUTURAS DE REPETIÇÃO ................................................................................................................................67</p><p>2.1 ESTRUTURAS DE REPETIÇÃO COM LAÇOS CONTADOS ...................................................................................68</p><p>2.2 ESTRUTURAS DE REPETIÇÃO ASSOCIADAS A UMA CONDIÇÃO..................................................................... 71</p><p>2.2.1 ESTRUTURAS DE REPETIÇÃO COM CONDIÇÃO NO INÍCIO .......................................................................... 71</p><p>ESTRUTURAS DE SELEÇÃO E REPETIÇÃO</p><p>PROF. FÁBIO ATAIDE DE LIMA</p><p>ENSINO A DISTÂNCIA</p><p>DISCIPLINA:</p><p>ALGORITMOS E PROGRAMAÇÃO APLICADA</p><p>52WWW.UNINGA.BR</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>2.2.2 ESTRUTURAS DE REPETIÇÃO COM CONDIÇÃO NO FINAL ........................................................................... 72</p><p>2.3 INTERVENÇÃO NO FLUXO DOS LAÇOS DE REPETIÇÃO .................................................................................... 73</p><p>2.3.1 COMANDO BREAK .............................................................................................................................................. 73</p><p>2.3.2 COMANDO CONTINUE ......................................................................................................................................74</p><p>CONSIDERAÇÕES FINAIS ...........................................................................................................................................76</p><p>53WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>2</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>INTRODUÇÃO</p><p>Até o momento, vimos exemplos de programas sendo executados de maneira sequencial,</p><p>ou seja, um comando sendo executado após o outro até o término de seu processamento. Contudo,</p><p>existem muitos algoritmos que requerem que uma condição seja analisada e tomar um de dois ou</p><p>mais caminhos possíveis, ou seja, um desvio de fluxo. Além disso, alguns algoritmos requerem</p><p>que um determinado conjunto de instruções seja executado novamente um determinado número</p><p>de vezes ou de acordo com uma condição.</p><p>Para essas finalidades, existem as estruturas de seleção e de repetição, as quais serão</p><p>abordadas com detalhes nesta unidade. Daremos início abordando a estrutura de seleção simples</p><p>e composta, que seria um SE simples e um SE com SENÃO, respectivamente. Em C, essa estrutura</p><p>é representada pelo comando if.</p><p>Em seguida, explicaremos o funcionamento do operador C de condição ternária, usado</p><p>para simplificar comandos if em expressões que podem ser usadas em outros comandos.</p><p>Em seguida, abordaremos as estruturas de seleção múltipla, que permitem a escolha</p><p>dentre mais de dois caminhos disponíveis, de acordo com uma condição a ser avaliada. Em</p><p>C, esse objetivo é alcançado de duas formas: encadeando vários ifs seguidamente ou usando o</p><p>comando switch.</p><p>Por fim, serão abordadas as estruturas responsáveis por permitir que um trecho de código</p><p>possa ser repetido</p><p>quantas vezes forem necessárias ou enquanto uma condição for satisfeita. Em</p><p>C, essas estruturas são implementadas pelos comandos for, while e do...while.</p><p>54WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>2</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>1 ESTRUTURAS DE SELEÇÃO</p><p>A lógica de programação é como o nosso cotidiano: em alguns momentos, surge a</p><p>necessidade de tomar decisões. Para se fazer isso em lógica, utilizamos as estruturas de seleção,</p><p>também conhecidas como estruturas de controle condicional ou estruturas de controle alternativo</p><p>(XAVIER, 2011).</p><p>Para se ter uma ideia melhor referente a essas estruturas, Lopes e Garcia (2002) deixam</p><p>um exemplo com três afirmações:</p><p>1. Distribuição gratuita de cestas básicas.</p><p>2. Distribuição gratuita de cestas básicas para famílias com 4 ou mais componentes.</p><p>3. Distribuição gratuita de ingressos para o teatro, sendo dois para pessoas do sexo</p><p>feminino e um para pessoas do sexo masculino (LOPES; GARCIA, 2002, p. 60).</p><p>Observando cada uma delas, conclui-se que a primeira seria implementada por meio</p><p>de um programa sequencial, a segunda seria implementada usando uma estrutura de seleção</p><p>simples e a terceira, por fim, uma estrutura de seleção composta.</p><p>1.1 Estrutura de Seleção Simples</p><p>Na estrutura de seleção simples, se uma condição for avaliada como verdadeira, será</p><p>executado o bloco de instruções compreendido pela estrutura; do contrário, o programa “pula”</p><p>esse bloco de instruções e passa para o comando seguinte à estrutura (XAVIER, 2011).</p><p>Na Figura 1 a seguir, temos a representação da segunda afirmação da seção anterior,</p><p>“distribuição gratuita de cestas básicas para famílias com 4 ou mais componentes”, utilizando</p><p>estrutura de seleção simples no formato de fluxograma.</p><p>Figura 1 – Estrutura de seleção simples em fluxograma. Fonte: O autor.</p><p>55WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>2</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>A estrutura de seleção simples é implementada em C por meio do comando if, cuja sintaxe</p><p>é descrita no Quadro 1 a seguir.</p><p>if (condição)</p><p>instrução;</p><p>if (condição)</p><p>{</p><p>instrução 1;</p><p>instrução 2;</p><p>instrução 3;</p><p>...</p><p>}</p><p>Quadro 1 – Sintaxe do comando if. Fonte: Adaptado de Schildt (1996).</p><p>A condição deve estar obrigatoriamente entre parênteses e representa uma expressão que</p><p>resultará em zero – falso – ou qualquer valor diferente de zero – verdadeiro; pode ser qualquer</p><p>tipo de expressão apresentada na Unidade I: aritmética, relacional ou lógica. Embora o uso das</p><p>chaves seja obrigatório no caso de mais de uma instrução dentro do if, elas são opcionais no caso</p><p>de apenas uma instrução, podendo ser suprimidas.</p><p>Outro ponto importante a considerar no Quadro 1 é o uso da indentação ao estruturar</p><p>os blocos de instruções dentro do comando. A maioria dos IDEs adota 4 espaços por padrão em</p><p>relação à linguagem C, e vamos seguir esse padrão em nossos exemplos.</p><p>No programa de exemplo apresentado no Quadro 2 a seguir, se o número informado for</p><p>maior que 10, então é mostrado o aviso na tela; caso contrário, nada é mostrado.</p><p>#include</p><p>int main(void) {</p><p>int a;</p><p>printf(“Digite um numero: “);</p><p>scanf(“%d”, &a);</p><p>if (a > 10)</p><p>printf(“a eh maior que 10”);</p><p>return 0;</p><p>}</p><p>Quadro 2 – Programa com estrutura de seleção simples. Fonte: O autor.</p><p>Segundo Manzano e Oliveira (2012), indentação é o processo de descolar um</p><p>trecho de código para a direita com o objetivo de indicar que sua execução está</p><p>subordinada a um desvio condicional, a uma estrutura de repetição ou a uma sub-</p><p>rotina – procedimento ou função. Essa atitude na escrita do código deixa-o mais</p><p>claro e legível, e será requisito básico na resolução de atividades, exercícios e</p><p>avaliações da disciplina.</p><p>56WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>2</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>Conforme já explicado na unidade anterior, é possível distribuir os comandos de diversas</p><p>maneiras em uma linha. Para exemplificar isso, ilustramos no Quadro 3 a seguir as várias formas</p><p>possíveis de escrever o if do Quadro 2.</p><p>if (a > 10) printf("A e maior que 10");</p><p>if (a > 10) { printf("A e maior que 10"); }</p><p>if (a > 10)</p><p>{ printf("A e maior que 10"); }</p><p>if (a > 10) {</p><p>printf("A e maior que 10"); }</p><p>if (a > 10)</p><p>{</p><p>printf("A e maior que 10");</p><p>}</p><p>if (a > 10) {</p><p>printf("A e maior que 10");</p><p>}</p><p>Quadro 3 – Formas possíveis de escrita de um if em C. Fonte: O autor.</p><p>O aluno fique à vontade para escolher a forma de sua preferência. Assumiremos em</p><p>nossos exemplos a última forma do Quadro 3 em ifs com duas ou mais instruções e a supressão</p><p>das chaves em ifs com uma só instrução.</p><p>1.2 Estrutura de Seleção Composta</p><p>A estrutura de seleção composta é formada por dois blocos de instruções. Se uma condição</p><p>for avaliada como verdadeira, o primeiro bloco de instruções será executado; se for avaliada</p><p>como falsa, o segundo bloco de instruções será executado (MANZANO; OLIVEIRA, 2012).</p><p>Na Figura 2 a seguir, temos a representação da terceira afirmação da seção</p><p>1 desta unidade, “distribuição gratuita de ingressos para o teatro, sendo dois para</p><p>pessoas do sexo feminino e um para pessoas do sexo masculino”, utilizando estrutura de seleção</p><p>composta em formato de fluxograma.</p><p>Figura 2 – Estrutura de seleção composta em fluxograma. Fonte: O autor.</p><p>57WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>2</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>O comando if possui uma instrução opcional que permite a implementação da estrutura</p><p>de seleção composta em C, cuja sintaxe é descrita no Quadro 4 a seguir.</p><p>if (condição)</p><p>instrução;</p><p>else</p><p>instrução;</p><p>if (condição)</p><p>{</p><p>instrução 1;</p><p>instrução 2;</p><p>instrução 3;</p><p>...</p><p>}</p><p>else</p><p>{</p><p>instrução 1;</p><p>instrução 2;</p><p>instrução 3;</p><p>...</p><p>}</p><p>Quadro 4 – Sintaxe do comando if...else. Fonte: Adaptado de Schildt (1996).</p><p>Se a avaliação da condição for verdadeira, a instrução ou o bloco entre o if e o else é</p><p>executada; se a avaliação for falsa, a instrução ou o bloco logo após o else é executada.</p><p>O Quadro 5 a seguir apresenta um programa que verifica se o número digitado pelo</p><p>usuário é par ou ímpar.</p><p>#include</p><p>int main(void) {</p><p>int n;</p><p>printf(“Digite um numero: “);</p><p>scanf(“%d”, &n);</p><p>if (n % 2 == 0)</p><p>printf(“O numero e par”);</p><p>else</p><p>printf(“O numero e impar”);</p><p>return 0;</p><p>}</p><p>Quadro 5 – Programa com estrutura de seleção composta. Fonte: O autor.</p><p>Nesse exemplo, usamos o operador de resto de divisão (%): se o resultado da divisão do</p><p>número digitado por 2 tiver resto 0, então ele é par; se tiver resto 1, então ele é impar. Portanto, se</p><p>o usuário entrar com o número 6, o programa imprimirá na tela “O número é par”; se ele entrar</p><p>com o número 5, o programa imprimirá na tela “O número é ímpar”.</p><p>58WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>2</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>A regra para o uso das chaves também se aplica ao bloco de instruções seguinte ao else,</p><p>de forma independente ao bloco de instruções seguinte ao if. Isso significa que as chaves podem</p><p>ser omitidas no caso de apenas uma instrução no if, no else ou em ambos. O Quadro 6 a seguir</p><p>ilustra algumas formas alternativas para o if...else usado no Quadro 5.</p><p>if (n % 2 == 0) printf("O numero e par");</p><p>else printf("O numero e impar");</p><p>if (n % 2 == 0) {</p><p>printf("Numero par"); }</p><p>else printf("Numero impar");</p><p>if (n % 2 == 0)</p><p>{</p><p>printf("Numero par");</p><p>}</p><p>else</p><p>{</p><p>printf("Numero impar");</p><p>}</p><p>if (n % 2 == 0)</p><p>printf("Numero par");</p><p>else {</p><p>printf("Numero impar"); }</p><p>if (n % 2 == 0) {</p><p>printf("Numero par");</p><p>}</p><p>else {</p><p>printf("Numero impar");</p><p>}</p><p>if (n % 2 == 0) {</p><p>printf("Numero par");</p><p>} else {</p><p>printf("Numero impar");</p><p>}</p><p>Quadro 6 – Formas possíveis de escrita de um if...else em C. Fonte: O autor.</p><p>1.3 Condição Ternária</p><p>A linguagem C oferece o operador de condição ternária ?:, que tem funcionamento</p><p>idêntico a um if...else. Sua</p><p>sintaxe é a seguinte:</p><p>condição ? expressão_se_1 : expressão_se_0</p><p>Se condição for avaliada como verdadeira, é retornada ou executada expressão_se_1;</p><p>se for avaliada como falsa, é retornada ou executada expressão_se_0. Este operador serve para</p><p>simplificar blocos if...else em apenas uma linha de instrução, conforme ilustrado no Quadro 7 a</p><p>seguir com o if exemplificado na seção anterior.</p><p>printf("Numero %s", n % 2 == 0 ? "par" : "impar");</p><p>printf(n % 2 == 0 ? "Numero par" : "Numero impar");</p><p>n % 2 == 0 ? printf("Numero par") : printf("Numero impar");</p><p>Quadro 7 – Exemplos de uso do operador de condição ternária. Fonte: O autor.</p><p>59WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>2</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>É possível que haja mais de um comando nas expressões de retorno do operador de</p><p>condição ternária, bastando para isso colocá-los entre parênteses e separá-los por vírgulas.</p><p>Entretanto, o código perde em legibilidade e, neste caso, é preferível usar um bloco de if...else,</p><p>pois deixa o código mais claro e compreensível de se ler. Veja a diferença no exemplo do Quadro</p><p>8 a seguir.</p><p>nota >= 6 ? (result = 'A', printf("Aprovado")) :</p><p>(result = 'R', printf("Reprovado"));</p><p>if (nota >= 6) {</p><p>result = ‘A’;</p><p>printf(“Aprovado”);</p><p>} else {</p><p>result = ‘R’;</p><p>printf(“Reprovado”);</p><p>}</p><p>Quadro 8 – Condição ternária e if...else com mais de uma instrução. Fonte: O autor.</p><p>60WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>2</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>1.4 Encadeamento de ifs</p><p>É possível utilizar quantos comandos ifs forem necessários em um programa, além de</p><p>poder encadeá-los da forma como melhor aprouver. Isso auxilia em problemas que requeiram</p><p>vários testes e comparações (XAVIER, 2011).</p><p>Para exemplificar isso, vamos implementar um programa que leia três números do usuário</p><p>e apresente o valor do maior digitado. Esse programa terá dois processamentos diferentes: um</p><p>utilizando dois ifs em sequência e outro utilizando um if encadeado em outro.</p><p>Portanto, a entrada e a saída de dados serão apresentadas apenas uma vez no exemplo</p><p>e a parte onde é feita a descoberta do maior número será dividida de modo que as duas lógicas</p><p>fiquem lado a lado. Isso permite que possamos comparar as diferenças entre os processamentos.</p><p>O Quadro 9 a seguir apresenta a codificação desse programa.</p><p>#include</p><p>int main(void) {</p><p>int num1, num2, num3, maior;</p><p>printf(“Digite o numero 1: “);</p><p>scanf(“%d”, &num1);</p><p>printf(“Digite o numero 2: “);</p><p>scanf(“%d”, &num2);</p><p>printf(“Digite o numero 3: “);</p><p>scanf(“%d”, &num3);</p><p>maior = num1;</p><p>if (maior num2)</p><p>if (num1 > num3)</p><p>maior = num1;</p><p>else</p><p>maior = num3;</p><p>else</p><p>if (num2 > num3)</p><p>maior = num2;</p><p>else</p><p>maior = num3;</p><p>printf(“O maior numero eh: %d”, maior);</p><p>return 0;</p><p>}</p><p>Quadro 9 – Programa implementado com duas lógicas semelhantes. Fonte: O autor.</p><p>Repare que ambas cumprem o mesmo objetivo de descobrir o maior número, porém</p><p>os ifs em sequência geram um código menor do que os ifs encadeados. Por outro lado, os ifs</p><p>encadeados efetuam um menor número de instruções, já que apenas uma operação de atribuição</p><p>é realizada, ao passo que nos ifs em sequência podem ser feitas de 1 a 3 atribuições. A escolha da</p><p>melhor lógica a ser aplicada dependerá muito dos fatores do programa e do programador que o</p><p>escreve.</p><p>61WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>2</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>É possível fazer uma estrutura de ifs encadeados para tratar mais de dois desvios no fluxo</p><p>do programa, fazendo com que cada else abra opção para um novo desvio. Entretanto, com a</p><p>endentação, esse código ficará muito “deslocado” para a direita, como demonstrado no exemplo</p><p>do Quadro 10 a seguir para obter o dia da semana por extenso.</p><p>#include</p><p>int main(void) {</p><p>int dia;</p><p>printf(“Informe o dia da semana (1-7): “);</p><p>scanf(“%d”, &dia);</p><p>if (dia == 1)</p><p>printf(“Domingo”);</p><p>else</p><p>if (dia == 2)</p><p>printf(“Segunda-feira”);</p><p>else</p><p>if (dia == 3)</p><p>printf(“Terca-feira”);</p><p>else</p><p>if (dia == 4)</p><p>printf(“Quarta-feira”);</p><p>else</p><p>if (dia == 5)</p><p>printf(“Quinta-feira”);</p><p>else</p><p>if (dia == 6)</p><p>printf(“Sexta-feira”);</p><p>else</p><p>if (dia == 7)</p><p>printf(“Sabado”);</p><p>else</p><p>printf(“Dia invalido”);</p><p>return 0;</p><p>}</p><p>Quadro 10 – Programa com vários ifs encadeados. Fonte: O autor.</p><p>62WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>2</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>Uma alternativa para evitar esse deslocamento seria iniciar o if seguinte na mesma linha</p><p>do else, conforme ilustrado no Quadro 11 a seguir.</p><p>#include</p><p>int main(void) {</p><p>int dia;</p><p>printf(“Informe o dia da semana (1-7): “);</p><p>scanf(“%d”, &dia);</p><p>if (dia == 1)</p><p>printf(“Domingo”);</p><p>else if (dia == 2)</p><p>printf(“Segunda-feira”);</p><p>else if (dia == 3)</p><p>printf(“Terca-feira”);</p><p>else if (dia == 4)</p><p>printf(“Quarta-feira”);</p><p>else if (dia == 5)</p><p>printf(“Quinta-feira”);</p><p>else if (dia == 6)</p><p>printf(“Sexta-feira”);</p><p>else if (dia == 7)</p><p>printf(“Sabado”);</p><p>else</p><p>printf(“Dia invalido”);</p><p>return 0;</p><p>}</p><p>Quadro 11 – Programa com vários ifs encadeados evitando indentações. Fonte: O autor.</p><p>Apesar de nesse exemplo do Quadro 10 termos evitado o deslocamento ocorrido no</p><p>Quadro 9, o custo de processamento permanece o mesmo em relação às comparações que devem</p><p>ser feitas, dependendo do valor digitado. Para otimizar isso, temos as estruturas de seleção</p><p>múltipla, abordadas na seção seguinte.</p><p>63WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>2</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>1.5 Estruturas de Seleção Múltipla</p><p>As estruturas de seleção múltipla também são conhecidas como tomada de decisão por</p><p>seleção, segundo Manzano e Oliveira (2012):</p><p>A tomada de decisão por seleção é uma alternativa mais rápida ao uso de tomadas</p><p>de decisão sequenciais ou encadeadas. Essa estrutura lógica de condição é útil e</p><p>pode ser usada em situações em que se possui um grande número de verificações</p><p>lógicas a serem realizadas (MANZANO; OLIVEIRA, 2012, p. 73).</p><p>Nesse tipo de estrutura, as condições são avaliadas na sequência em que foram definidas.</p><p>Caso a avaliação seja falsa, o programa avalia a condição seguinte; caso seja verdadeira, o programa</p><p>executará o bloco de instruções referente àquela condição e depois desvia o fluxo para a primeira</p><p>instrução após o final da estrutura (MANZANO; OLIVEIRA, 2012).</p><p>Na Figura 3 a seguir, temos a representação da estrutura de seleção múltipla no formato</p><p>de fluxograma.</p><p>Figura 3 – Estrutura de seleção múltipla em fluxograma. Fonte: O autor.</p><p>64WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>2</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>A estrutura de seleção múltipla é implementada em C por meio do comando switch, cuja</p><p>sintaxe é descrita no Quadro 12 a seguir.</p><p>switch (expressão)</p><p>{</p><p>case constante1:</p><p>instruções;</p><p>break;</p><p>case constante2:</p><p>instruções;</p><p>break;</p><p>case constante3:</p><p>instruções;</p><p>break;</p><p>default:</p><p>instruções;</p><p>}</p><p>Quadro 12 – Sintaxe do comando switch. Fonte: Adaptado de Schildt (1996).</p><p>A expressão deve obrigatoriamente estar entre parênteses e resultar em um valor do tipo</p><p>char ou int – pode ser uma variável, um retorno de função ou um cálculo aritmético. A partir daí,</p><p>ele verifica o valor de cada case, na ordem</p><p>especificada, para ver se é igual ao valor da expressão</p><p>recebida: em caso negativo, verificará o case seguinte; em caso positivo, executará as instruções</p><p>contidas nele e também dos cases subsequentes até encontrar um comando break, responsável</p><p>por “sair” da estrutura; a instrução default é opcional e executará suas instruções no caso de</p><p>nenhum case ter sido executado (SCHILDT, 1996; DEITEL, 2011).</p><p>65WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>2</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>Esse comportamento torna o comando switch mais rápido do que um conjunto de ifs</p><p>encadeados. O Quadro 13 a seguir ilustra o exemplo do dia da semanda por extenso, usado na</p><p>seção anterior, adaptado para o comando switch.</p><p>#include</p><p>int main(void) {</p><p>int dia;</p><p>printf(“Informe o dia da semana (1-7): “);</p><p>scanf(“%d”, &dia);</p><p>switch (dia) {</p><p>case 1:</p><p>printf(“Domingo”);</p><p>break;</p><p>case 2:</p><p>printf(“Segunda-feira”);</p><p>break;</p><p>case 3:</p><p>printf(“Terca-feira”);</p><p>break;</p><p>case 4:</p><p>printf(“Quarta-feira”);</p><p>break;</p><p>case 5:</p><p>printf(“Quinta-feira”);</p><p>break;</p><p>case 6:</p><p>printf(“Sexta-feira”);</p><p>break;</p><p>case 7:</p><p>printf(“Sabado”);</p><p>break;</p><p>default:</p><p>printf(“Dia invalido”);</p><p>}</p><p>return 0;</p><p>}</p><p>Quadro 13 – Programa com estrutura de seleção múltipla. Fonte: O autor.</p><p>No próximo exemplo, obtemos o número de dias de um mês e ano informado pelo</p><p>usuário usando um comando switch e o operador ternário em uma de suas opções. O programa</p><p>é ilustrado no Quadro 14 a seguir.</p><p>66WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>2</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>#include</p><p>int main(void) {</p><p>int mes, ano, dias = 0;</p><p>printf(“Informe o mes e o ano (MM/AAAA): “);</p><p>scanf(“%d/%d”, &mes, &ano);</p><p>switch (mes) {</p><p>case 2:</p><p>dias = ano % 4 ? 28 : 29;</p><p>break;</p><p>case 4:</p><p>case 6:</p><p>case 9:</p><p>case 11:</p><p>dias = 30;</p><p>break;</p><p>case 1:</p><p>case 3:</p><p>case 5:</p><p>case 7:</p><p>case 8:</p><p>case 10:</p><p>case 12:</p><p>dias = 31;</p><p>}</p><p>if (dias)</p><p>printf(“O mes informado tem %d dias\n”, dias);</p><p>else</p><p>printf(“O mes informado eh invalido\n”);</p><p>return 0;</p><p>}</p><p>Quadro 14 – Programa para obter o número de dias do mês. Fonte: O autor.</p><p>Se o usuário digitar, por exemplo:</p><p>• “02/2019”: 2 será armazenado em mes e 2019 será armazenado em ano. Portanto, o</p><p>programa entrará no primeiro case, pois a comparação de mes com 2 resultará em</p><p>verdadeiro. De acordo com a condição ternária, será armazenado o valor 28 em dias</p><p>porque ano % 4 resultará em 1, pois o resto da divisão de 2019 por 4 é 3 – lembre-se de</p><p>que qualquer valor diferente de 0 é verdadeiro em C.</p><p>• “02/2020”: será armazenado o valor 29 na variável dias, pois ano % 4 resultará em 0 –</p><p>2020 dividido por 4 tem resto zero – e será avaliado como falso pelo operador de condição</p><p>ternária.</p><p>• “04/2020”: o programa passará o primeiro case e entrará no segundo, com a comparação</p><p>por 4. Como não há instrução nenhuma senão cases subsequentes, o fluxo segue até a</p><p>primeira instrução não-case, que é a atribuição de 30 na variável dias. Depois disto vem</p><p>um break e então o fluxo é desviado para depois do bloco.</p><p>• “12/2020”: o programa passará por todos os cases até chegar no último, onde será</p><p>avaliado em verdadeiro. Nele, é armazenado o valor 31 na variável dias.</p><p>67WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>2</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>• Mês fora da faixa entre 1 e 12: o programa não executará nenhuma instrução do switch</p><p>devido à ausência da instrução default no bloco e imprimirá que o mês informado é</p><p>inválido, devido à variável dias estar valendo 0.</p><p>2 ESTRUTURAS DE REPETIÇÃO</p><p>As estruturas de repetição também são conhecidas como laços ou malhas de repetição,</p><p>além de seus termos em inglês loop e looping. De acordo com Manzano e Oliveira (2012, p. 101),</p><p>são “uma técnica de programação que possibilita repetir um trecho de programa, sem que seja</p><p>necessário escrevê-lo exatamente o número de vezes que se deseja de fato executar”. Na Figura 4</p><p>a seguir, temos a representação da estrutura de repetição no formato de fluxograma.</p><p>Figura 4 – Estrutura de repetição em fluxograma. Fonte: Manzano e Oliveira (2012).</p><p>Algumas linguagens de programação oferecem uma variação do</p><p>comando for para percorrer estruturas de dados, como vetores,</p><p>matrizes, registros e itens de coleções. Em C#, por exemplo,</p><p>esse tipo de estrutura é implementado pelo comando foreach;</p><p>mais informações sobre ele podem ser encontradas no link do</p><p>Microsoft Docs, disponível em:</p><p>https://docs.microsoft.com/pt-br/dotnet/csharp/language-</p><p>reference/keywords/foreach-in</p><p>https://docs.microsoft.com/pt-br/dotnet/csharp/language-reference/keywords/foreach-in</p><p>https://docs.microsoft.com/pt-br/dotnet/csharp/language-reference/keywords/foreach-in</p><p>68WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>2</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>Podem existir quantas estruturas de repetição forem necessárias para repetir trechos de</p><p>um programa, ou mesmo o programa inteiro, sendo que o número de repetições pode ser fixo ou</p><p>associado a uma condição (ASCENCIO; CAMPOS, 2010). Em C, as estruturas de repetição que</p><p>repetem um número determinado de vezes são implementadas pelo comando for e as estruturas</p><p>associadas a uma condição, pelos comandos while e do...while.</p><p>2.1 Estruturas de Repetição com Laços Contados</p><p>O comando for é uma estrutura em C do tipo laço contado e é utilizado quando sabemos</p><p>previamente o número de vezes que o trecho de código precisa ser repetido. Sua sintaxe é descrita</p><p>no Quadro 15 a seguir.</p><p>for (variável = valor_inicial; condição; incremento/decremento)</p><p>{</p><p>instruções;</p><p>}</p><p>Quadro 15 – Sintaxe do comando for. Fonte: Adaptado de Schildt (1996).</p><p>Entre os parênteses após o for, temos três expressões:</p><p>• Na primeira expressão, variável será inicializada com valor_inicial e usada para controlar</p><p>o número de repetições;</p><p>• Na segunda expressão, condição é uma expressão relacional que, ao assumir valor falso,</p><p>determinará o fim da repetição;</p><p>• Na terceira expressão, incremento/decremento atualiza o valor da variável de controle da</p><p>repetição, ao final de cada iteração.</p><p>As instruções são os comandos a serem repetidos no laço e é recomendado que estejam</p><p>indentadas, para facilitar a leitura do código. Assim como na estrutura if, as chaves podem ser</p><p>suprimidas no caso de uma instrução apenas.</p><p>69WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>2</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>O Quadro 16 a seguir apresenta como exemplo um programa que pede um número e</p><p>imprime a sua tabuada, usando um laço contado para multiplicá-lo por 1 a 10.</p><p>#include</p><p>int main(void) {</p><p>int num, i;</p><p>printf(“Digite um numero: “);</p><p>scanf(“%d”, &num);</p><p>for (i = 1; i</p><p>16.</p><p>Figura 5 – Resultado do programa de tabuada. Fonte: O autor.</p><p>70WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>2</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>É possível controlar mais de uma variável em uma estrutura for. Para isso, basta separar</p><p>por vírgulas a inicialização e o incremento ou decremento das variáveis na primeira e na terceira</p><p>expressão, respectivamente. O Quadro 17 a seguir exemplifica essa situação.</p><p>#include</p><p>int main(void) {</p><p>int num, i, d;</p><p>printf(“Digite um numero: “);</p><p>scanf(“%d”, &num);</p><p>for (i = 1, d = num; i</p><p>int main(void) {</p><p>int numero;</p><p>printf(“Digite um numero: “);</p><p>scanf(“%d”, &numero);</p><p>while (numero != 10) {</p><p>printf(“Digite um numero: “);</p><p>scanf(“%d”, &numero);</p><p>}</p><p>return 0;</p><p>}</p><p>Quadro 19 – Programa com estrutura de repetição com condição no início. Fonte: O autor.</p><p>2.2.2 Estruturas de repetição com condição no final</p><p>O comando do...while avalia uma condição no final do laço de repetição, o que significa</p><p>que o bloco de instruções do laço será executado pelo menos uma vez (DEITEL, 2011). Sua</p><p>sintaxe é descrita no Quadro 20 a seguir.</p><p>do</p><p>instrução</p><p>while (condição);</p><p>do</p><p>{</p><p>instrução 1;</p><p>instrução 2;</p><p>instrução 3;</p><p>...</p><p>}</p><p>while (condição);</p><p>Quadro 20 – Sintaxe do comando do...while. Fonte: Adaptado de Deitel (2011).</p><p>Apesar de os parênteses poderem ser omitidos em blocos com apenas uma instrução,</p><p>no caso do comando do...while é mais comum e seguro usar a segunda forma do Quadro 20,</p><p>com chaves, para prevenir possível ambiguidade entre estruturas while e do…while: na primeira</p><p>forma, sem chaves, “a última linha – while (condição); – pode ser mal interpretada como uma</p><p>estrutura while com uma instrução vazia” (DEITEL, 2011, p. 93).</p><p>73WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>2</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>O Quadro 21 a seguir apresenta uma adaptação do programa do Quadro 19, para usar</p><p>uma estrutura do...while como laço de repetição.</p><p>#include</p><p>int main(void) {</p><p>int numero;</p><p>do {</p><p>printf(“Digite um numero: “);</p><p>scanf(“%d”, &numero);</p><p>} while (numero != 10);</p><p>return 0;</p><p>}</p><p>Quadro 21 – Programa com estrutura de repetição com condição no final. Fonte: O autor.</p><p>Nesse exemplo, a leitura do número pelo programa será feita ao menos uma vez antes da</p><p>condição ser testada. Comparando com o exemplo anterior do Quadro 19, repare que as duas</p><p>linhas repetidas fora do laço para pedir o número pela primeira vez puderam ser removidas. E o</p><p>resultado em tela é o mesmo para ambos, conforme ilustrado na Figura 7 a seguir.</p><p>Figura 7 – Resultado da execução dos programas dos Quadros 19 e 21. Fonte: O autor.</p><p>2.3 Intervenção no Fluxo dos Laços de Repetição</p><p>Conforme abordado nas seções anteriores, as estruturas de repetição estão atreladas a</p><p>uma condição ou a uma variável de controle para que mantenham ou encerrem a repetição do</p><p>bloco de instruções sujeito a elas.</p><p>Contudo, existem dois comandos que podem forçar o desvio do fluxo para o início ou</p><p>para fora do laço, independentemente da condição ou da contagem de acordo com o tipo de laço.</p><p>Abordamos esses comandos nas seções seguintes.</p><p>2.3.1 Comando break</p><p>Vimos na seção 1.5 desta unidade que o comando break é utilizado para sair de um bloco</p><p>de instruções switch e desviar o fluxo para a linha seguinte do bloco. Na verdade, ele também</p><p>serve para interromper a execução de qualquer laço de repetição e continuar a execução do</p><p>programa a partir da linha seguinte ao laço interrompido (BACKES, 2016).</p><p>74WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>2</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>O Quadro 22 a seguir apresenta uma nova versão do programa que repete a leitura de um</p><p>número até que seja digitado 10, utilizando o comando break.</p><p>#include</p><p>int main(void) {</p><p>int numero;</p><p>while (1) {</p><p>printf(“Digite um numero: “);</p><p>scanf(“%d”, &numero);</p><p>if (numero == 10)</p><p>break;</p><p>}</p><p>return 0;</p><p>}</p><p>Quadro 22 – Programa com desvio para o final do laço de repetição. Fonte: O autor.</p><p>Nesse exemplo, o programa sairá do laço quando o número digitado for 10, do contrário,</p><p>continuará infinitamente dentro do laço, uma vez que mudamos a condição do while para 1 –</p><p>sempre verdadeiro. Esta é uma expressão muito comum em programas quando queremos que</p><p>haja um trecho de código sempre repetindo até que a verificação de uma condição no meio do</p><p>bloco faça a saída dele.</p><p>2.3.2 Comando continue</p><p>O comando continue, por sua vez, desvia o fluxo para a o início do laço de repetição,</p><p>mais precisamente para a próxima iteração. Se esse laço é uma estrutura</p><p>for, então é realizado o</p><p>incremento ou decremento da variável de controle; se esse laço é uma estrutura while, então a</p><p>condição é novamente avaliada. Em ambos os casos, o laço pode ser encerrado se a condição de</p><p>avaliação for falsa (BACKES, 2016).</p><p>O Quadro 23 a seguir apresenta como exemplo um programa que pede um número de</p><p>opção do usuário e deixa prosseguir somente se a opção estiver entre 1 e 5.</p><p>#include</p><p>int main(void) {</p><p>int opcao = 0;</p><p>while (opcao != 5) {</p><p>printf(“Digite uma opcao (1-5): “);</p><p>scanf(“%d”, &opcao);</p><p>if (opcao 5)</p><p>continue;</p><p>printf(“Opcao escolhida: %d\n”, opcao);</p><p>}</p><p>return 0;</p><p>}</p><p>Quadro 23 – Programa com desvio para o início do laço de repetição. Fonte: Backes (2016).</p><p>75WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>2</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>Cuidado ao usar estruturas de repetição, pois se não houver nenhuma condição de</p><p>seleção para desviar o código para fora da estrutura e a condição de verificação for</p><p>sempre verdadeira, o programa entrará no que chamamos de loop infinito, ou seja,</p><p>nunca terminará o processamento, causando o efeito de travamento da máquina</p><p>em algumas situações (LOPES; GARCIA, 2002). Em C, isso pode facilmente</p><p>acontecer em blocos de instruções encabeçados por for (;;) ou while (1).</p><p>76WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>2</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>CONSIDERAÇÕES FINAIS</p><p>Nesta unidade, foram abordadas as estruturas de seleção e de repetição, necessárias para</p><p>programas que dependem da avaliação de uma condição para poderem executar determinados</p><p>comandos e repetir a execução de outros.</p><p>Iniciamos a unidade abordando as estruturas de seleção simples e composta, implementadas</p><p>na linguagem C pelo comando if. Em seguida, vimos o funcionamento do operador de condição</p><p>ternária ?:, usado para simplificar blocos de instruções if em apenas uma linha.</p><p>Depois abordamos as possibilidades de uso de ifs seguidos ou encadeados, de acordo com</p><p>a necessidade do programa em questão. Introduzimos as estruturas de seleção múltipla, ideal</p><p>para a avaliação de várias condições relacionadas, implementadas na linguagem C pelo comando</p><p>switch.</p><p>Prosseguimos abordando as estruturas de repetição, que podem ser subdivididas em</p><p>estruturas de laços contados, implementadas pelo comando for, e estruturas de laços atrelada a</p><p>uma condição, implementadas pelo comando while, que avalia a condição do início do laço, e</p><p>pelo comando do...while, que avalia a condição no final do laço.</p><p>Finalizamos a unidade abordando os dois comandos que interrompem a execução das</p><p>instruções em um laço de repetição: break, que encerra o laço e desvia o fluxo para a instrução</p><p>seguinte, e continue, que desvia o fluxo para o início do laço.</p><p>Esse livro tem por objetivo apresentar os</p><p>fundamentos da lógica para a programação de</p><p>computadores, capacitando o leitor a construir</p><p>algoritmos estruturados, e traz assuntos e</p><p>exercícios baseados em experiências reais do</p><p>autor vivenciadas em sala de aula. A leitura não</p><p>exige maior conhecimento do assunto por parte do</p><p>leitor, mas apenas familiaridade com a operação</p><p>do microcomputador.</p><p>VILARIM, G. O. Algoritmos: Programação para</p><p>Iniciantes. 3. ed. Rio de Janeiro: Ciência Moderna,</p><p>2017.</p><p>Fonte: Vilarim (2017)</p><p>7777WWW.UNINGA.BR</p><p>U N I D A D E</p><p>03</p><p>SUMÁRIO DA UNIDADE</p><p>INTRODUÇÃO ...............................................................................................................................................................79</p><p>1 ESTRUTURAS DE DADOS HOMOGÊNEAS ..............................................................................................................80</p><p>1.1 VETORES .................................................................................................................................................................80</p><p>1.1.1 PESQUISA EM VETORES ....................................................................................................................................83</p><p>1.1.2 ORDENAÇÃO EM VETORES ................................................................................................................................85</p><p>1.2 CADEIAS DE CARACTERES – STRINGS ...............................................................................................................86</p><p>1.3 MATRIZES...............................................................................................................................................................89</p><p>1.3.1 MATRIZES COM MAIS DE DUAS DIMENSÕES ................................................................................................ 91</p><p>1.3.2 VETORES DE STRINGS .......................................................................................................................................92</p><p>2 ESTRUTURAS DE DADOS HETEROGÊNEAS ..........................................................................................................93</p><p>2.1 VETORES DE ESTRUTURAS ..................................................................................................................................97</p><p>ESTRUTURAS DE</p><p>ARMAZENAMENTO DE DADOS</p><p>PROF. FÁBIO ATAIDE DE LIMA</p><p>ENSINO A DISTÂNCIA</p><p>DISCIPLINA:</p><p>ALGORITMOS E PROGRAMAÇÃO APLICADA</p><p>78WWW.UNINGA.BR</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>2.2 COMANDO TYPEDEF ............................................................................................................................................99</p><p>2.3 UNIÕES ..................................................................................................................................................................99</p><p>CONSIDERAÇÕES FINAIS .......................................................................................................................................... 102</p><p>79WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>3</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>INTRODUÇÃO</p><p>Até o momento, as variáveis foram o único recurso que aprendemos para armazenar</p><p>dados na memória, de maneira que eles pudessem ser recuperados, manipulados e apresentados</p><p>posteriormente ao usuário.</p><p>Contudo, existem programas que requerem a entrada de dados de forma repetitiva</p><p>e organizada; e as variáveis armazenam apenas um valor por vez, obrigando o programador</p><p>a trabalhar com muitas variáveis na necessidade de um volume de dados maior e homogêneo</p><p>(MANZANO; OLIVEIRA, 2012).</p><p>Para suprir essa necessidade, existem as estruturas de armazenamento de dados, que</p><p>permitem o armazenamento de várias informações na memória sob a referência de apenas um</p><p>identificador. Conceitualmente, existem dois tipos de estruturas de armazenamento de dados,</p><p>segundo Manzano e Oliveira (2012):</p><p>• Estruturas homogêneas, também conhecidas como arrays, que permitem o armazenamento</p><p>de dados do mesmo tipo e subdividem-se em unidimensionais e multidimensionais;</p><p>• Estruturas heterogêneas, também conhecidas como registros, que permitem o</p><p>armazenamento de dados de tipos diferentes.</p><p>Todos esses tipos de estruturas são implementados pela linguagem C. Inclusive as cadeias</p><p>de caracteres – strings – são implementadas por meio de vetores e serão abordadas com detalhes</p><p>nesta unidade.</p><p>As estruturas homogêneas unidimensionais são comumente chamadas de vetores, primeiro</p><p>assunto a ser abordado. Em seguida, veremos as estruturas homogêneas multidimensionais,</p><p>também conhecidas como matrizes. E para concluir a unidade, serão abordadas as estruturas de</p><p>dados heterogêneas.</p><p>80WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>3</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>1 ESTRUTURAS DE DADOS HOMOGÊNEAS</p><p>As estruturas de dados homogêneas permitem trabalhar com o agrupamento de várias</p><p>informações dentro de uma mesma variável, obedecendo sempre ao mesmo tipo de dado. No</p><p>mundo da computação, elas recebem diversos nomes, como variáveis indexadas, variáveis</p><p>compostas, arranjos ou arrays em inglês (MANZANO; OLIVEIRA,</p><p>2012) – este último termo é</p><p>o mais comum.</p><p>Essas estruturas também são nomeadas quanto ao número de dimensões que possuem:</p><p>vetores, no caso de estruturas com uma dimensão apenas, e matrizes, no caso de estruturas com</p><p>duas ou mais dimensões.</p><p>1.1 Vetores</p><p>Segundo Lopes e Garcia (2002), vetores são arranjos de elementos armazenados na</p><p>memória principal, um após o outro, todos com o mesmo nome. Essa estrutura segue a ideia de</p><p>matriz linha ou matriz coluna da matemática, isto é, várias colunas em uma linha ou várias linhas</p><p>em uma coluna, respectivamente.</p><p>A Figura 1 a seguir ilustra a representação de um vetor contendo os 8 primeiros números</p><p>primos, nas duas formas.</p><p>Figura 1 – Representação de um vetor. Fonte: O autor.</p><p>Para o computador, não há diferença se um vetor é representado graficamente na horizontal</p><p>ou na vertical – assumiremos aqui a representação vertical, pois facilitará o entendimento quando</p><p>estivermos abordando as matrizes. O que importa é que cada elemento desse arranjo é indicado</p><p>por um índice numérico inteiro e positivo (MANZANO; OLIVEIRA, 2012). Cada linguagem de</p><p>programação implementa esse índice de formas diferentes, sendo que na linguagem C esse índice</p><p>inicia em zero e vai até o tamanho do vetor menos uma unidade (BACKES, 2016).</p><p>81WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>3</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>A sintaxe para a declaração de vetores em C é muito semelhante à criação de variáveis –</p><p>inclusive podem ser declarados junto com elas na mesma linha, contanto que sejam do mesmo</p><p>tipo. O que diferencia um vetor de uma variável é que o vetor deve ter o número de elementos</p><p>especificado entre colchetes:</p><p>tipo_de_dado identificador[numero_elementos];</p><p>Por exemplo, int vetor[10]; criará um vetor de inteiros contendo dez elementos, indexados</p><p>de 0 a 9. A partir daí, é possível atribuir valores aos seus elementos referenciando-os pelo seu</p><p>índice, conforme ilustrado no Quadro 1 a seguir.</p><p>int main(void) {</p><p>int vetor[10], n = 7;</p><p>vetor[0] = 3;</p><p>vetor[1] = 5;</p><p>vetor[4] = vetor[1] + vetor[0];</p><p>vetor[n] = vetor[4] + 2;</p><p>vetor[n+1] = 55;</p><p>return 0;</p><p>}</p><p>Quadro 1 – Criação de vetor e atribuição de valores aos seus elementos. Fonte: O autor.</p><p>Repare que o índice pode ser uma constante ou uma expressão que resulte em um número</p><p>inteiro, como uma variável, um cálculo aritmético ou um retorno de função.</p><p>Assim como em variáveis, também é possível atribuir elementos em um vetor no momento</p><p>em que são declarados, segundo Deitel (2011):</p><p>• Com um tamanho constante: int numeros[5] = {10, 20, 30, 40, 50};</p><p>• Apenas alguns elementos do vetor: int valores[5] = {2, 4, 6};</p><p>Nesse caso, os demais elementos são inicializados automaticamente com zero;</p><p>• Sem especificar a quantidade de elementos: int valores[] = {3, 5, 7};</p><p>o compilador idenficará a quantidade – neste caso, 3.</p><p>82WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>3</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>Segundo Lopes e Garcia (2002), não é possível realizar a leitura ou a apresentação de um</p><p>vetor como um todo; é necessário fazê-lo elemento por elemento, sendo que, para isso, utiliza-</p><p>se geralmente uma estrutura de repetição com laços contados. O Quadro 2 a seguir ilustra um</p><p>exemplo de como seria o preenchimento e a exibição dos dados de um vetor.</p><p>#include</p><p>int main(void) {</p><p>int vetor[10], i;</p><p>for (i = 0; i</p><p>int main(void) {</p><p>int valores[10], i, valor;</p><p>for (i = 0; i</p><p>crescente ou decrescente”. Existem vários algoritmos</p><p>voltados para esta finalidade; apresentaremos aqui o mais simples e conhecido: o método da</p><p>bolha, também conhecido como BubbleSort.</p><p>Em dois laços de repetição encadeados, são feitas comparações entre os elementos atuais</p><p>do laço externo e do laço interno; caso o valor do primeiro seja maior que o segundo, é efetuada</p><p>a troca de valores entre as posições. Esse processo se repete até que os laços de repetição sejam</p><p>concluídos (GUEDES, 2014).</p><p>O Quadro 4 a seguir exemplifica um programa que alimenta um vetor com valores e</p><p>depois efetua o método da bolha para ordenar esse vetor.</p><p>#include</p><p>int main(void) {</p><p>int vetor[10];</p><p>int i, j, troca;</p><p>for (i = 0; i vetor[j]) {</p><p>troca = vetor[i];</p><p>vetor[i] = vetor[j];</p><p>vetor[j] = troca;</p><p>}</p><p>printf(“\nVetor ordenado: { “);</p><p>for (i = 0; i</p><p>int main(void) {</p><p>char texto[50];</p><p>int tamanho;</p><p>while (1) {</p><p>printf(“Digite o texto (branco=encerra): “);</p><p>fflush(stdin); // Para prevenir o bug de não editar</p><p>gets(texto);</p><p>if (texto[0] == ‘\0’) // Não foi digitado nada</p><p>break;</p><p>// Conta quantas letras tem o texto</p><p>for (tamanho = 0; texto[tamanho] != ‘\0’; tamanho++);</p><p>printf(“Tamanho do texto: %d\n”, tamanho);</p><p>}</p><p>return 0;</p><p>}</p><p>Quadro 5 – Programa para leitura de uma cadeia de caracteres. Fonte: O autor.</p><p>O resultado deste programa é ilustrado na Figura 5 a seguir.</p><p>Figura 5 – Resultado da execução do programa do Quadro 5. Fonte: O autor.</p><p>88WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>3</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>O Quadro 6 a seguir traz algumas destas funções disponíveis para a manipulação de strings.</p><p>Lembre-se que é necessário incluir a instrução #include no início do programa.</p><p>Nome Função</p><p>strcpy(s1, s2) Copia s2 em s1</p><p>strcat(s1, s2) Concatena s2 ao final de s1</p><p>strlen(s1) Retorna o tamanho de s1</p><p>strcmp(s1, s2) Retorna 0 se s1 e s2 forem iguais, menor que 0 se s1 s2</p><p>strchr(s1, ch) Retorna um ponteiro para a primeira ocorrência de ch em s1</p><p>strstr(s1, s2) Retorna um ponteiro para a primeira ocorrência de s2 em s1</p><p>strlwr(s1) Retorna o minúsculo de s1</p><p>strupr(s1) Retorna o maiúsculo de s1</p><p>Quadro 6 – Funções comuns para a manipulação de strings. Fonte: Adaptado de Schildt (1996).</p><p>A biblioteca padrão da linguagem C disponibiliza um conjunto de funções espe-</p><p>cialmente desenvolvidas para a manipulação de cadeias de caracteres, encontra-</p><p>das no arquivo de cabeçalho string.h. Por exemplo, a função strlen() retorna o</p><p>tamanho de um texto passado por parâmetro e poderia perfeitamente substituir o</p><p>for usado no programa do Quadro 5 para contar quantas letras tem o texto digita-</p><p>do (SCHILDT, 1996).</p><p>89WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>3</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>1.3 Matrizes</p><p>Segundo Manzano e Oliveira (2012), matrizes são arrays que possuem duas ou mais</p><p>dimensões; geralmente é utilizada em duas dimensões, devido à facilidade de disposição dos</p><p>dados em formato de tabela – linhas e colunas. Na prática, um array de duas dimensões significa</p><p>que cada elemento da primeira dimensão conterá um outro array, cujo número de elementos será</p><p>igual para todos os arrays da segunda dimensão.</p><p>A declaração de uma matriz em C é semelhante à de um vetor, com a diferença de que</p><p>deve haver um par de colchetes para cada dimensão:</p><p>tipo variável[dimensão1][dimensão2]...;</p><p>Onde dimensão1 determina o número de elementos da primeira dimensão do vetor,</p><p>dimensão2 determina o número de elementos da segunda dimensão, e assim por diante. Cada</p><p>dimensão possui seu o próprio índice, numerado de 0 ao seu tamanho menos 1.</p><p>O Quadro 7 a seguir traz um exemplo de declaração de uma matriz de duas dimensões e</p><p>a atribuição de valores a alguns de seus elementos, sendo que na ilustração a primeira dimensão</p><p>está representada pelas linhas e a segunda dimensão, pelas colunas.</p><p>int main(void) {</p><p>int dados[3][4];</p><p>dados[0][2] = 100;</p><p>dados[2][0] = 2;</p><p>dados[1][1] = 7;</p><p>dados[1][3] = 11;</p><p>dados[0][0] = 43;</p><p>}</p><p>Quadro 7 – Declaração de matriz e atribuição de valores a seus elementos. Fonte: O autor.</p><p>Matrizes também podem receber valores literais no momento em que são declaradas,</p><p>segundo Deitel (2011):</p><p>• Com um tamanho constante: int triangulo[3][2] = { {1,1}, {5,1}, {3,4} };</p><p>• Como se fosse um vetor: int valor[3][4] = {1,2,3,4,5,6,7,8,9,10,11,12};</p><p>neste caso, os valores serão distribuídos de acordo com as dimensões especificadas;</p><p>• Sem especificar a quantidade</p><p>de elementos: int matriz[][2] = {1,2,3,4,5,6,7,8,9,10}; o</p><p>compilador atribuirá 5 à primeira dimensão baseado no tamanho da segunda dimensão,</p><p>obrigatório de ser informado neste caso.</p><p>90WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>3</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>Para percorrer os elementos de uma matriz, seja para leitura ou apresentação dos dados,</p><p>deve-se usar uma estrutura de repetição por dimensão (MANZANO; OLIVEIRA, 2012),</p><p>conforme exemplificado no Quadro 8 a seguir.</p><p>#include</p><p>int main(void) {</p><p>int matriz[2][5], i, j;</p><p>for (i = 0; i</p><p>int main(void) {</p><p>char nomes[5][30];</p><p>int i;</p><p>for (i = 0; i</p><p>struct veiculo {</p><p>char marca[16];</p><p>char modelo[16];</p><p>char placa[11];</p><p>char categ;</p><p>char combust[11];</p><p>int anofab;</p><p>int anomod;</p><p>float motor;</p><p>};</p><p>int main(void) {</p><p>struct veiculo v;</p><p>printf(“Marca..........: “);</p><p>fflush(stdin); // Para prevenir o bug de não editar</p><p>gets(v.marca);</p><p>printf(“Modelo.........: “);</p><p>fflush(stdin); // Para prevenir o bug de não editar</p><p>gets(v.modelo);</p><p>printf(“Placa..........: “);</p><p>dos circuitos integrados</p><p>(CHIP)), viu-se a diminuição do tamanho, maior capacidade de processamento e início da</p><p>utilização dos computadores pessoais. Surgiram os softwares integrados, como processadores de</p><p>texto, planilhas eletrônicas e outros.</p><p>Figura 2 - Intel 8008, 1972 - primeiro microprocessador de 8 bits.</p><p>Fonte: Wikiwand (2021).</p><p>7WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>IN</p><p>TR</p><p>OD</p><p>UT</p><p>ÓR</p><p>IA</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>Já a quarta geração, iniciada nos anos 1970, ficou conhecida pela grande massa de</p><p>microcomputadores pessoais, com circuitos integrados VLSI – Very Large Scale Integration – e</p><p>integração em escala muito alta. Em 1977, houve uma explosão no mercado de microcomputadores,</p><p>sendo fabricados em escala comercial, e, a partir daí, a evolução foi sendo cada vez maior, até</p><p>chegar aos micros atuais, os microprocessadores de ULSI (Ultra Large Scale of Integration),</p><p>utilizados a partir de 1980. Nessa geração, começa a utilização das linguagens de altíssimo nível,</p><p>orientadas para um problema.</p><p>A quinta geração é baseada em hardware de processamento paralelo (que é uma forma</p><p>de computação em que vários cálculos são realizados ao mesmo tempo) e na IA (Inteligência</p><p>Artificial) do software. A inteligência artificial é um “novo” ramo da ciência da computação,</p><p>que interpreta meios e métodos de fazer computadores pensar como seres humanos. Todas</p><p>as linguagens de alto nível, robótica, desenvolvimento de sistemas especialistas e a era online,</p><p>comunicação através da Internet, fazem parte desta geração.</p><p>Figura 3 - Exemplo de um computador de quinta geração. Fonte: Gerações de Computadores (2021).</p><p>Assim, vimos como os computadores vêm evoluindo e acompanhando os avanços nos</p><p>campos da matemática, engenharia e eletrônica. Os computadores passaram por muitas mudanças</p><p>e foram continuamente aprimorados ao longo do tempo. Continuam seguindo a tendência de</p><p>miniaturização de seus componentes, tornando-se cada vez mais práticos para as tarefas diárias.</p><p>1.2 Componentes de um Sistema Computacional</p><p>Um sistema de computação é composto por três (3) componentes principais: hardware,</p><p>software e peopleware.</p><p>O peopleware são todos os usuários, as pessoas que, de alguma forma, trabalham e/ou</p><p>interagem com o computador, como digitadores, programadores, analistas ou simplesmente</p><p>usuários finais. Veremos agora, mais detalhadamente, os componentes de hardware e software.</p><p>1.2.1 Hardware</p><p>A parte física de um sistema computacional é o que chamamos de hardware. São todos</p><p>os componentes de entrada e saída, componentes eletrônicos, circuitos integrados e placas.</p><p>O “hardware” não se refere apenas aos computadores pessoais, mas também aos equipamentos</p><p>embarcados em produtos que precisam de processamento computacional, como os dispositivos</p><p>encontrados em equipamentos como micro-ondas, automóveis, máquinas, aparelho celular e outros.</p><p>8WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>IN</p><p>TR</p><p>OD</p><p>UT</p><p>ÓR</p><p>IA</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>Para esta disciplina, é interessante entender que os componentes de hardware são divididos</p><p>em sistema central (composto pela CPU - Unidade Central de Processamento (ou processador)</p><p>-, Memória Principal e as suas interconexões) e os periféricos (que podem ser de Entrada, Saída</p><p>e/ou Armazenamento e as suas interconexões).</p><p>De acordo com a arquitetura de von Neumann, a CPU (do inglês Central Processing</p><p>Unit), que é Unidade Central de Processamento, armazena informações, controla as operações</p><p>aritméticas e lógicas e efetua o processamento de entradas e saídas.</p><p>Figura 4 - Tráfego das informações na CPU. Fonte: Adaptado de Manzano e Manzano (2009).</p><p>A memória principal (ou memória primária) tem por finalidade o armazenamento de</p><p>instruções e dados de programas que serão e/ou estão sendo executados pela CPU. É considerada</p><p>como uma memória de trabalho, sendo organizada em células com tamanho fixo e igual, cada</p><p>uma identificada por um número denominado endereço.</p><p>A memória principal pode ser acessada por meio de duas operações: leitura (ler da</p><p>memória significa requisitar à memória principal o conteúdo de uma determinada célula) e</p><p>escrita (escrever na memória significa escrever uma informação em uma célula da MP).</p><p>É classificada em dois grupos:</p><p>- RAM (do inglês Random Access Memory – Memória de Acesso Aleatório) dinâmica</p><p>ou estática - esta memória volátil retém as instruções e dados de programas que estão sendo</p><p>executados, tornando o tempo de leitura e escrita bastante rápido.</p><p>- ROM (do inglês Read Only Memory – Memória Somente de Leitura) - as informações são</p><p>gravadas no momento da fabricação e não mais são alteradas. Contém basicamente informações</p><p>necessárias para o funcionamento do computador, como rotinas que verificam se os meios físicos</p><p>(hardware) estão aptos para o funcionamento. Outras versões de ROMs são PROM, EPROM,</p><p>EEPROM ou EAPROM e memória flash.</p><p>A memória cache é uma memória (RAM estática) volátil de alta velocidade, localizada</p><p>entre a CPU e a memória principal, usada com a finalidade de acelerar o processamento,</p><p>funcionando como um buffer da memória.</p><p>As memórias secundárias são um tipo de memória não volátil de grande capacidade de</p><p>armazenamento, usadas para guardar informações (instruções e dados de programas) que não</p><p>são perdidas quando o computador for desligado. Como exemplos, podemos citar: disco rígido</p><p>(HD) e mídias removíveis, como o CD-ROM, o DVD e o pendrive.</p><p>9WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>IN</p><p>TR</p><p>OD</p><p>UT</p><p>ÓR</p><p>IA</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>- Dispositivos de Entrada e Saída de Dados:</p><p>No sistema computacional, todos os dispositivos que realizam as funções de receber e/</p><p>ou enviar as informações do usuário são considerados dispositivos de entrada e saída de dados.</p><p>Esses dispositivos externos são conectados em um computador e podem ser classificados</p><p>em três categorias:</p><p>1. Os que transmitem/recebem informações inteligíveis para o ser humano - são</p><p>adequados para estabelecimento de comunicação com o usuário. É o caso das</p><p>impressoras, monitores de vídeo, plotters, multimídia etc.</p><p>2. Os que transmitem/recebem informações inteligíveis apenas para a máquina - são</p><p>adequados para comunicação máquina a máquina ou internamente a uma máquina.</p><p>É o caso dos teclados, mouses, scanners, discos magnéticos, fitas magnéticas, discos</p><p>óticos, sensores e atuadores em aplicação robótica.</p><p>3. Os que transmitem/recebem de/para outros dispositivos remotamente instalados,</p><p>tais como os modems e regeneradores digitais.</p><p>1.2.2 Software</p><p>Já sabemos que vamos agora entender brevemente como os softwares são feitos.</p><p>As etapas para a execução de uma tarefa, elaboradas e executadas passo a passo, constituem</p><p>o que se chama programa, ou também chamadas de software. Cada um dos passos mencionados</p><p>é uma diferente instrução, ou ordem de comando, dada ao hardware com o objetivo de realização</p><p>de uma determinada tarefa e/ou ação (por exemplo: uma operação aritmética, uma transferência</p><p>de informação). O programa (software) é o conjunto dessas instruções.</p><p>Córdova et al. (2018) nos dizem que o computador é uma máquina que resolve problemas</p><p>por meio da execução de instruções que são passadas a ele. Essas instruções são chamadas de</p><p>programas de computador. O programa é um conjunto de instruções lógicas e finitas (também</p><p>chamado de algoritmo), que executam uma tarefa específica.</p><p>Um programa de computador é a formalização de um algoritmo, em linguagem inteligível</p><p>pelo computador.</p><p>Figura 5 - Fases do processamento de um software. Fonte: A autora.</p><p>Assim, o computador precisa entender cada instrução de modo a executar corretamente</p><p>a operação que se pretende. O usuário entende Português, sua linguagem de comunicação com</p><p>outras pessoas. Os computadores têm uma linguagem própria, a linguagem binária. Nela, os</p><p>caracteres inteligíveis são apenas zero (0) e um (1), presença ou ausência de corrente elétrica. Todo</p><p>dado coletado</p><p>fflush(stdin); // Para prevenir o bug de não editar</p><p>gets(v.placa);</p><p>do {</p><p>printf(“Categoria (A-E): “);</p><p>fflush(stdin); // Para prevenir o bug de não editar</p><p>scanf(“%c”, &v.categ);</p><p>} while (!(v.categ >= ‘A’ && v.categ = ‘a’ && v.categ ).</p><p>Na leitura dos membros tipo string não foi necessário usar o operador de endereço &,</p><p>como já explicado em seção anterior. Usamos demais tipos de dados lidos com scanf() para</p><p>passar o endereço de memória de cada membro sendo editado. Na leitura da categoria, fizemos</p><p>um laço de repetição com do...while para permitir prosseguir somente se a categoria estiver entre</p><p>“A” e “E”, seja maiúscula ou minúscula.</p><p>A Figura 11 a seguir ilustra o resultado da execução do programa do Quadro 12.</p><p>Figura 11 – Resultado da execução do programa do Quadro 12. Fonte: O autor.</p><p>As estruturas normalmente são usadas para declarar registros a serem</p><p>armazenados em arquivos. Usadas em conjuntos com ponteiros, facilitam a</p><p>formação de estruturas de dados mais complexas, como por exemplo, listas</p><p>interligadas, filas, pilhas e árvores (DEITEL, 2011).</p><p>97WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>3</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>2.1 Vetores de Estruturas</p><p>Vimos na seção anterior, a leitura e escrita de apenas um registro de estrutura. Como as</p><p>variáveis criadas são tipadas com a estrutura em questão, é possível definir um vetor contendo</p><p>elementos do mesmo tipo de estrutura. Com isso, podemos criar programas que controlam</p><p>cadastros completos de objetos, onde é possível incluir, alterar, excluir e visualizar seus dados.</p><p>O Quadro 12 a seguir é uma adaptação do programa do Quadro 11, onde no lugar de uma</p><p>variável temos um vetor de estruturas do tipo struct veiculo, com 5 elementos. Primeiro fazemos</p><p>a entrada e, em seguida, listamos os veículos digitados.</p><p>#include</p><p>struct veiculo {</p><p>char marca[16];</p><p>char modelo[16];</p><p>char placa[11];</p><p>char categ;</p><p>char combust[11];</p><p>int anofab;</p><p>int anomod;</p><p>float motor;</p><p>};</p><p>int main(void) {</p><p>struct veiculo v[5];</p><p>int i;</p><p>for (i = 0; i = ‘A’ && v[i].categ = ‘a’ && v[i].categ</p><p>tipo campo_2;</p><p>...</p><p>tipo campo_n;</p><p>} lista_variáveis;</p><p>Quadro 14 – Sintaxe para declaração de uma união em C. Fonte: Adaptado de Schildt (1996).</p><p>100WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>3</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>As mesmas regras abordadas nas seções anteriores para a declaração de estruturas também</p><p>se aplicam para uniões, estando a única diferença no nome do comando: union. O acesso a seus</p><p>membros também é feito pelo operador ponto (.).</p><p>O Quadro 15 a seguir exemplifica o uso de uma união para armazenar o CPF ou o CNPJ,</p><p>de acordo com o tipo de pessoa especificado.</p><p>#include</p><p>union PFouPJ {</p><p>char cpf[15];</p><p>char cnpj[19];</p><p>};</p><p>int main(void) {</p><p>char nome[30], tipo;</p><p>union PFouPJ pessoa;</p><p>printf(“Nome........: “);</p><p>fflush(stdin); // Para prevenir o bug de não editar</p><p>gets(nome);</p><p>do {</p><p>printf(“Pessoa (F/J): “);</p><p>fflush(stdin); // Para prevenir o bug de não editar</p><p>scanf(“%c”, &tipo);</p><p>} while (tipo != ‘F’ && tipo != ‘f’ &&</p><p>tipo != ‘J’ && tipo != ‘j’);</p><p>if (tipo == ‘F’ || tipo == ‘f’) {</p><p>printf(“CPF.........: “);</p><p>fflush(stdin); // Para prevenir o bug de não editar</p><p>scanf(“%s”, pessoa.cpf);</p><p>} else {</p><p>printf(“CNPJ........: “);</p><p>fflush(stdin); // Para prevenir o bug de não editar</p><p>scanf(“%s”, pessoa.cnpj);</p><p>}</p><p>printf(“\nNome..: %s\nPessoa: “, nome);</p><p>if (tipo == ‘F’ || tipo == ‘f’)</p><p>printf(“FISICA\nCPF...: %s\n”, pessoa.cpf);</p><p>else</p><p>printf(“JURIDICA\nCNPJ..: %s\n”, pessoa.cnpj);</p><p>return 0;</p><p>}</p><p>Quadro 15 – Exemplo de uso de uniões. Fonte: O autor.</p><p>101WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>3</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>As uniões possuem grande utilidade em programas que precisam de conversão</p><p>de tipo ou portabilidade. No primeiro caso, podemos referenciar os dados</p><p>contidos um uma união de maneiras diferentes; no segundo, o compilador não</p><p>perde o tamanho das variáveis que compõem uma união, possibilitando assim</p><p>independência de máquina (SCHILDT, 1996).</p><p>O conceito de registros e estruturas nos leva</p><p>a um pequeno pedaço de outro paradigma de</p><p>programação que vem dominando o mundo</p><p>da informática nos dias atuais: a Programação</p><p>Orientada a Objetos – POO. Este livro ensina os</p><p>conceitos básicos que envolvem este paradigma,</p><p>como classes, objetos, encapsulamento, herança</p><p>etc. Ideal para quem deseja um contato inicial</p><p>com este novo mundo.</p><p>SINTES, A. Aprenda Programação Orientada</p><p>a Objetos em 21 dias. São Paulo: Pearson</p><p>Education do Brasil, 2002.</p><p>Fonte: Sintes (2002)</p><p>102WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>3</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>CONSIDERAÇÕES FINAIS</p><p>Nesta unidade, foram abordadas as estruturas voltadas para o armazenamento de dados.</p><p>Iniciamos abordando as estruturas de dados homogêneas, que permitem o agrupamento de</p><p>dados do mesmo tipo sob a referência de um único identificador.</p><p>Descrevemos os vetores, estruturas de dados de uma dimensão, e como manipular seus</p><p>elementos por meio da leitura, escrita, busca e ordenação. Em seguida, abordamos as strings, que</p><p>em C são vetores de chars; descrevendo como são manipuladas e apresentamos algumas funções</p><p>da biblioteca padrão para tal.</p><p>Em seguida, abordamos as matrizes, estruturas de dados de duas ou mais dimensões, e</p><p>descrevemos como vetores de strings são implementados na linguagem.</p><p>Finalizamos a unidade abordando as estruturas de dados heterogêneas, mais conhecidas</p><p>como registros, que em C são implementadas por meio de estruturas. Abordamos como declarar</p><p>estruturas e manipular seus membros, bem como criar novos tipos de dados usando o comando</p><p>typedef e explicar a diferença entre estruturas e uniões.</p><p>103103WWW.UNINGA.BR</p><p>U N I D A D E</p><p>04</p><p>SUMÁRIO DA UNIDADE</p><p>INTRODUÇÃO ...............................................................................................................................................................105</p><p>1 SUB-ROTINAS ...........................................................................................................................................................106</p><p>1.1 PROTOTIPAGEM ..................................................................................................................................................... 112</p><p>1.2 RETORNO DE VALORES EM FUNÇÕES ...............................................................................................................116</p><p>2 ESCOPO DE VARIÁVEIS ........................................................................................................................................... 117</p><p>2.1 VARIÁVEIS LOCAIS ................................................................................................................................................ 117</p><p>2.2 VARIÁVEIS GLOBAIS .............................................................................................................................................118</p><p>2.3 VARIÁVEIS EXTERNAS .........................................................................................................................................119</p><p>2.4 VARIÁVEIS ESTÁTICAS .........................................................................................................................................120</p><p>2.5 VARIÁVEIS DE REGISTRO .................................................................................................................................... 121</p><p>3 PONTEIROS ..............................................................................................................................................................122</p><p>MODULARIZAÇÃO DE PROGRAMAS</p><p>PROF. FÁBIO ATAIDE DE LIMA</p><p>ENSINO A DISTÂNCIA</p><p>DISCIPLINA:</p><p>ALGORITMOS E PROGRAMAÇÃO APLICADA</p><p>104WWW.UNINGA.BR</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>3.1 OPERADOR SIZEOF ...............................................................................................................................................124</p><p>3.2 PONTEIROS DE ESTRUTURAS E UNIÕES ..........................................................................................................125</p><p>4 PASSAGEM DE PARÂMETROS ................................................................................................................................126</p><p>4.1 PASSAGEM DE PARÂMETROS POR VALOR ........................................................................................................130</p><p>4.2 PASSAGEM DE PARÂMETROS POR REFERÊNCIA ............................................................................................ 131</p><p>5 RECURSIVIDADE ......................................................................................................................................................132</p><p>CONSIDERAÇÕES FINAIS ...........................................................................................................................................134</p><p>105WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>4</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>INTRODUÇÃO</p><p>Existem certos problemas que possuem uma escala de grandeza e complexidade tal que</p><p>algoritmos muito simples não são capazes de resolver. Segundo Forbellone e Eberspächer (2005, p.</p><p>127), “[...] um problema complexo pode ser simplificado quando dividido em vários problemas”.</p><p>Seguindo esta abordagem, vários paradigmas de programação foram criados, dentre</p><p>eles, a programação estruturada, cuja característica “é a utilização de técnicas que decompõem a</p><p>solução de um problema em ‘blocos’ que interagem com um bloco principal” (XAVIER, 2011, p.</p><p>221).</p><p>Nesse processo de divisão ou modularização dos problemas, utilizamos as sub-rotinas.</p><p>Também chamadas de subprogramas, são trechos menores de código que realizam tarefas</p><p>específicas, destinados a resolver uma parte do problema como um todo (ASCENCIO; CAMPOS,</p><p>2010).</p><p>Daremos início a esta unidade abordando os dois tipos de sub-rotinas existentes:</p><p>procedimentos e funções, estas últimas implementadas em C. Relacionados a este assunto estão</p><p>os escopos de variáveis, onde explicaremos com mais detalhes a diferença entre variáveis locais e</p><p>globais, além de outras classes de variáveis em C.</p><p>Em seguida, descreveremos ponteiros com mais detalhes do que foi introduzido na</p><p>Unidade I, explicando como utilizar seus operadores e destacando a sua importância no contexto</p><p>do assunto seguinte: o mecanismo de passagem de parâmetros.</p><p>Abordaremos o conceito da passagem de parâmetros e como ele auxilia na construção</p><p>de sub-rotinas mais genéricas e reaproveitáveis. Dentro desse assunto, estaremos explicando a</p><p>diferença entre passagem de parâmetros por valor e por referência.</p><p>Para finalizar a unidade, será abordado o conceito de recursividade, outro recurso</p><p>importante na programação estruturada, e suas aplicações na lógica de programação.</p><p>106WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>4</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>1 SUB-ROTINAS</p><p>Sub-rotinas são blocos de instruções com um início e um fim, identificados por um nome</p><p>que pode ser usado para chamá-los de qualquer parte do programa. Podem ser classificados em</p><p>procedimentos e funções, sendo que a principal diferença é que as funções sempre retornam</p><p>um dado de determinado tipo para o programa ou rotina que a chamou, ao passo que os</p><p>procedimentos não retornam nada (MANZANO; OLIVEIRA, 2012).</p><p>Lopes e Garcia (2002) destacam que dentre as várias vantagens do seu uso estão:</p><p>• Dividir e estruturar um programa em partes logicamente coerentes e testar estes trechos</p><p>isoladamente;</p><p>• Evitar duplicação de código, uma vez que funções e procedimentos podem ser chamados</p><p>quantas vezes forem necessárias;</p><p>• Possibilidade de o programador criar sua própria biblioteca de funções e procedimentos,</p><p>generalizando e padronizando algumas tarefas e comportamentos.</p><p>A Figura 1 a seguir ilustra o algoritmo de ida ao trabalho, apresentado na Unidade I,</p><p>contendo duas instruções detalhadas em blocos separados, simulando o funcionamento de uma</p><p>sub-rotina.</p><p>Figura 1 – Exemplo de algoritmo com instruções detalhadas em sub-rotinas. Fonte: O autor.</p><p>107WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>4</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>Em C, apenas funções são implementadas – veremos que a criação de um procedimento</p><p>na linguagem é uma função do tipo void, ou seja, não retorna valor. O Quadro 1 a seguir apresenta</p><p>a sintaxe geral para a criação de uma função.</p><p>tipo identificador(parâmetros)</p><p>{</p><p>...</p><p>instruções;</p><p>...</p><p>return valor;</p><p>}</p><p>Quadro 1 – Sintaxe para a criação de funções em C. Fonte: Adaptado de Schildt (1996).</p><p>Onde:</p><p>• tipo: tipo de dado a ser retornado pela função. Pode ser um tipo de dado primitivo ou</p><p>definido pelo usuário com typedef;</p><p>• identificador: nome da função. Deve seguir as regras de nomenclatura de identificadores</p><p>apresentadas na seção 4 da Unidade I;</p><p>• parâmetros: variáveis de entrada. Embora sejam opcionais, é bom costume colocar void</p><p>entre os parênteses quando não houver parâmetros, para evitar mensagens de advertência</p><p>em alguns compiladores;</p><p>• instruções: comandos a serem executados dentro da função, começando pela declaração</p><p>de todas as variáveis a serem usadas;</p><p>• valor: dado a ser retornado para a função chamadora, cujo tipo deve ser igual ao tipo</p><p>declarado para a função.</p><p>O comando return pode ser executado quantas vezes necessárias dentro de uma função,</p><p>geralmente dentro de ifs e no final, e pode ser usado isoladamente, bem como ser omitido,</p><p>somente nas funções declaradas como void em seu tipo – funções que não retornam valor.</p><p>108WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>4</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>O Quadro 2 a seguir exemplifica o uso de uma função void que é chamada duas vezes</p><p>seguidas pela função main().</p><p>#include</p><p>void soma(void) {</p><p>float num1, num2;</p><p>printf(“Digite o primeiro numero: “);</p><p>scanf(“%f”, &num1);</p><p>printf(“Digite o segundo numero.: “);</p><p>scanf(“%f”, &num2);</p><p>printf(“A soma eh %.2f\n\n”, num1 + num2);</p><p>}</p><p>int main(void) {</p><p>soma();</p><p>soma();</p><p>return 0;</p><p>}</p><p>Quadro 2 – Exemplo do uso de funções. Fonte: Adaptado de Schildt (1996).</p><p>Lembre-se que a execução de qualquer programa em C inicia sempre na função main().</p><p>Nesse exemplo, ao chamar a função soma() pela primeira vez, o fluxo desviará para o bloco de</p><p>instruções da função; ao terminar, o fluxo volta para a linha seguinte na função main(), que</p><p>chamará a função novamente e executará suas instruções (BACKES, 2016). O resultado da</p><p>execução deste programa é ilustrado na Figura 2 a seguir.</p><p>Figura 2 – Resultado da execução do programa do Quadro 2. Fonte: O autor.</p><p>Uma forma alternativa de se implementar o programa do Quadro 2 sem o uso de uma</p><p>segunda função seria colocar o bloco de instruções contido na função soma() em um laço que se</p><p>repetiria duas vezes na função main(). Isso comprova a tese de que vários caminhos podem ser</p><p>usados na solução de um problema em forma de algoritmo.</p><p>109WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>4</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>Com uma proposta inovadora, esta obra conecta</p><p>várias disciplinas da computação a aspectos</p><p>históricos do pensamento humano, da lógica dos</p><p>filósofos gregos e da organização da sociedade</p><p>no decorrer do tempo. Ao longo de sete capítulos,</p><p>você compreenderá o uso de muitos dos conceitos</p><p>de computação que são empregados hoje e terá</p><p>a possibilidade de aprender sobre temas como</p><p>programação computacional, banco de dados e</p><p>Linguagem de Consulta Estruturada (SQL).</p><p>SOUZA, M. F. F. Computadores e sociedade: da</p><p>filosofia às linguagens de programação. Curitiba:</p><p>InterSaberes, 2016. Fonte: Souza (2016).</p><p>110WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>4</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>O próximo exemplo, ilustrado no Quadro 3 a seguir, simula uma calculadora onde o</p><p>usuário escolhe a operação em um menu e o programa chama a função referente.</p><p>#include</p><p>void soma(void) {</p><p>float num1, num2;</p><p>printf(“\nFuncao SOMA\n”);</p><p>printf(“Primeiro numero: “);</p><p>scanf(“%f”, &num1);</p><p>printf(“Segundo numero.: “);</p><p>scanf(“%f”, &num2);</p><p>printf(“Resultado da soma: %.2f\n\n”, num1 + num2);</p><p>}</p><p>void subtracao(void) {</p><p>float num1, num2;</p><p>printf(“\nFuncao SUBTRACAO\n”);</p><p>printf(“Primeiro numero: “);</p><p>scanf(“%f”, &num1);</p><p>printf(“Segundo numero.: “);</p><p>scanf(“%f”, &num2);</p><p>printf(“Resultado da subtracao: %.2f\n\n”, num1 - num2);</p><p>}</p><p>void multiplicacao(void) {</p><p>float num1, num2;</p><p>printf(“\nFuncao MULTIPLICACAO\n”);</p><p>printf(“Primeiro numero: “);</p><p>scanf(“%f”, &num1);</p><p>printf(“Segundo numero.: “);</p><p>scanf(“%f”, &num2);</p><p>printf(“Resultado da multiplicacao: %.2f\n\n”, num1 * num2);</p><p>}</p><p>void divisao(void) {</p><p>float num1, num2;</p><p>printf(“\nFuncao DIVISAO\n”);</p><p>printf(“Primeiro numero..: “);</p><p>scanf(“%f”, &num1);</p><p>printf(“Segundo numero...: “);</p><p>do {</p><p>scanf(“%f”, &num2);</p><p>} while (num2 == 0);</p><p>printf(“Resultado da divisao: %.2f\n\n”, num1 / num2);</p><p>}</p><p>111WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>4</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>int main(void) {</p><p>int opcao;</p><p>while (opcao != 5) {</p><p>printf(“1 - Adicao\n”);</p><p>printf(“2 - Subtracao\n”);</p><p>printf(“3 - Multiplicacao\n”);</p><p>printf(“4 - Divisao\n”);</p><p>printf(“5 - Sair\n”);</p><p>printf(“Opcao: “);</p><p>scanf(“%d”, &opcao);</p><p>switch (opcao) {</p><p>case 1: soma(); break;</p><p>case 2: subtracao(); break;</p><p>case 3: multiplicacao(); break;</p><p>case 4: divisao(); break;</p><p>}</p><p>}</p><p>return 0;</p><p>}</p><p>Quadro 3 – Exemplo de um programa de calculadora. Fonte: Adaptado de Schildt (1996).</p><p>Nesse exemplo, quando uma opção é selecionada, o programa desvia o fluxo para a função</p><p>referente e depois volta para o</p><p>menu, onde o usuário poderá selecionar outra opção, a mesma que</p><p>a anterior ou escolher sair do programa. É muito comum o uso de menus em grandes aplicações,</p><p>onde suas rotinas são modularizadas.</p><p>De acordo com Schildt (1996, p. 139), “[...] em C, todas as funções estão no mesmo</p><p>nível de escopo. Isto é, não é possível definir uma função internamente a uma</p><p>função. Esta é a razão de C não ser tecnicamente uma linguagem estruturada em</p><p>blocos”.</p><p>112WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>4</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>1.1 Prototipagem</p><p>Repare nos exemplos apresentados até o momento que as funções auxiliares em um</p><p>programa foram escritas antes da função main(). Segundo Backes (2016), esta é uma regra do uso</p><p>de funções na linguagem C: toda função chamada por outra deve ser escrita antes no programa,</p><p>sob pena de erro na hora da compilação. Dessa forma, a função main() sempre será a última a ser</p><p>escrita – isto acaba gerando uma certa dificuldade de navegação pelo código.</p><p>Para resolver isso, ou seja, escrever as funções na ordem em que são executadas, utilizamos</p><p>um recurso chamado prototipagem de funções. Quando criamos um protótipo de função,</p><p>estamos, na verdade, declarando uma função, ou seja, indicamos para main() que tal função</p><p>existe, mas o código dela está em algum outro lugar no programa. Dessa forma, o programa</p><p>fica mais fácil de ler, podendo main() ser a primeira função a ser escrita e as demais funções em</p><p>seguida (SCHILDT, 1996).</p><p>A sintaxe geral para prototipagem de uma função é:</p><p>tipo função(parâmetros);</p><p>113WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>4</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>Essa declaração é colocada no início do programa, geralmente logo após a inclusão dos</p><p>arquivos de cabeçalho-padrão, conforme ilustrado no Quadro 4 a seguir, que traz uma adaptação</p><p>do programa do Quadro 3 com o uso de protótipos.</p><p>#include</p><p>// Prototipagem das funções</p><p>void soma(void);</p><p>void subtracao(void);</p><p>void multiplicacao(void);</p><p>void divisao(void);</p><p>int main(void) {</p><p>int opcao;</p><p>while (opcao != 5) {</p><p>printf(“1 - Adicao\n”);</p><p>printf(“2 - Subtracao\n”);</p><p>printf(“3 - Multiplicacao\n”);</p><p>printf(“4 - Divisao\n”);</p><p>printf(“5 - Sair\n”);</p><p>printf(“Opcao: “);</p><p>scanf(“%d”, &opcao);</p><p>switch (opcao) {</p><p>case 1: soma(); break;</p><p>case 2: subtracao(); break;</p><p>case 3: multiplicacao(); break;</p><p>case 4: divisao(); break;</p><p>}</p><p>}</p><p>return 0;</p><p>}</p><p>void soma(void) {</p><p>float num1, num2;</p><p>printf(“\nFuncao SOMA\n”);</p><p>printf(“Primeiro numero: “);</p><p>scanf(“%f”, &num1);</p><p>printf(“Segundo numero.: “);</p><p>scanf(“%f”, &num2);</p><p>printf(“Resultado da soma: %.2f\n\n”, num1 + num2);</p><p>}</p><p>114WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>4</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>void subtracao(void) {</p><p>float num1, num2;</p><p>printf(“\nFuncao SUBTRACAO\n”);</p><p>printf(“Primeiro numero: “);</p><p>scanf(“%f”, &num1);</p><p>printf(“Segundo numero.: “);</p><p>scanf(“%f”, &num2);</p><p>printf(“Resultado da subtracao: %.2f\n\n”, num1 - num2);</p><p>}</p><p>void multiplicacao(void) {</p><p>float num1, num2;</p><p>printf(“\nFuncao MULTIPLICACAO\n”);</p><p>printf(“Primeiro numero: “);</p><p>scanf(“%f”, &num1);</p><p>printf(“Segundo numero.: “);</p><p>scanf(“%f”, &num2);</p><p>printf(“Resultado da multiplicacao: %.2f\n\n”, num1 * num2);</p><p>}</p><p>void divisao(void) {</p><p>float num1, num2;</p><p>printf(“\nFuncao DIVISAO\n”);</p><p>printf(“Primeiro numero..: “);</p><p>scanf(“%f”, &num1);</p><p>printf(“Segundo numero...: “);</p><p>do {</p><p>scanf(“%f”, &num2);</p><p>} while (num2 == 0);</p><p>printf(“Resultado da divisao: %.2f\n\n”, num1 / num2);</p><p>}</p><p>Quadro 4 – Programa de calculadora com prototipagem. Fonte: Adaptado de Schildt (1996).</p><p>115WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>4</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>A prototipagem de funções é interessante de se usar em programas extensos, que contém</p><p>um número razoável de funções, como no caso da calculadora do Quadro 4. Em programas mais</p><p>simples e curtos, com apenas uma ou duas funções auxiliares, talvez seja mais conveniente omitir</p><p>a prototipagem. Assumiremos assim deste ponto.</p><p>Os protótipos de funções são usados pelo compilador para validar as chamadas</p><p>de função, pois informam o tipo de dado retornado pela função, o número, o tipo e</p><p>a ordem dos parâmetros que a função espera receber. Portanto, servem como uma</p><p>espécie de “assinatura” das funções para serem validadas tanto na compilação</p><p>– em resolver chamadas a funções – quanto na execução do programa – em</p><p>armazenar estas funções na memória e gerenciá-las na pilha de execução. Se não</p><p>houver protótipo para uma função, o compilador assume o cabeçalho da definição</p><p>da função para determinar sua “assinatura” (DEITEL, 2011).</p><p>116WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>4</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>1.2 Retorno de Valores em Funções</p><p>Funções do tipo void devem ser chamadas isoladamente em uma linha de instrução,</p><p>conforme os exemplos ilustrados até o momento. Funções que retornam valores, por sua vez,</p><p>podem ser consideradas como expressões e também fazer parte de outras operações de saída ou</p><p>de processamento lógico ou matemático, desde que o tipo de dado retornado seja compatível</p><p>(MANZANO; OLIVEIRA, 2010).</p><p>O Quadro 5 a seguir exemplifica uma função genérica de confirmação que é usada para perguntar</p><p>se o usuário deseja repetir a operação principal do programa.</p><p>#include</p><p>int confirma(void) {</p><p>char conf;</p><p>do {</p><p>printf(“\nConfirma (S/N): “);</p><p>fflush(stdin); // Para prevenir o bug de não editar</p><p>scanf(“%c”, &conf);</p><p>} while (conf != ‘S’ && conf != ‘s’ &&</p><p>conf != ‘N’ && conf != ‘n’);</p><p>return conf == ‘S’ || conf == ‘s’;</p><p>}</p><p>int main(void) {</p><p>int numero;</p><p>do {</p><p>printf(“Digite um numero: “);</p><p>scanf(“%d”, &numero);</p><p>printf(“%d ao quadrado = %d”, numero, numero * numero);</p><p>printf(“\nDeseja repetir a operacao?”);</p><p>} while (confirma());</p><p>return 0;</p><p>}</p><p>Quadro 5 – Exemplo de função que retorna valor. Fonte: O autor.</p><p>Como funções e procedimentos possuem a finalidade de estruturar determinadas tarefas</p><p>em programas menores, haverá variáveis que terão a necessidade de existirem apenas dentro</p><p>delas; outras terão que existir durante toda a execução do programa, mas visíveis apenas em</p><p>algumas partes. É por esta razão que podemos declarar variáveis com um determinado escopo,</p><p>assunto abordado na seção seguinte.</p><p>117WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>4</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>2 ESCOPO DE VARIÁVEIS</p><p>Segundo Manzano e Oliveira (2012), o escopo de uma variável está vinculado a duas</p><p>coisas: à forma de sua visibilidade e ao seu tempo de vida no programa em relação às sub-rotinas</p><p>que ele possui. Conceitualmente falando, as variáveis podem ter escopo global ou local, sendo</p><p>que em C é possível declarar variáveis locais, globais, externas, estáticas ou de registro.</p><p>2.1 Variáveis Locais</p><p>As variáveis locais são visíveis apenas dentro da função onde foram declaradas e são</p><p>removidas da memória assim que a mesma encerra sua execução; além disto, não são visíveis em</p><p>outras funções chamadas por ela (SCHILDT, 1996).</p><p>O Quadro 6 a seguir exemplifica isso, com uma ilustração da abrangência destas variáveis</p><p>dentro do programa.</p><p>void rotina1_1(void) {</p><p>int valorW = 47;</p><p>}</p><p>void rotina1_2(void) {</p><p>int valorY = 25;</p><p>}</p><p>void rotina2_1(void) {</p><p>int valorX = 120;</p><p>}</p><p>void rotina1(void) {</p><p>int valorA = 12, valorX = 23;</p><p>rotina1_1();</p><p>rotina1_2();</p><p>}</p><p>void rotina2(void) {</p><p>int valorM = 12;</p><p>rotina2_1();</p><p>}</p><p>int main(void) {</p><p>int valorA = 5, valorB = 10;</p><p>rotina1();</p><p>rotina2();</p><p>return 0;</p><p>}</p><p>Quadro 6 – Exemplos de variáveis locais. Fonte: Adaptado de Manzano e Oliveira (2012).</p><p>Todas as variáveis existentes</p><p>no Quadro 6 são visíveis apenas em suas respectivas funções,</p><p>ilustradas pelos retângulos de tonalidades diferentes; portanto não há problema em declarar</p><p>uma variável local com nome já usado em outra função, pois elas estarão armazenadas em locais</p><p>diferentes na memória do computador.</p><p>118WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>4</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>Em todos os exemplos apresentados até aqui, note que todas as variáveis foram declaradas</p><p>dentro do escopo de suas funções, seja main() ou qualquer outra. Isso significa que todas estas</p><p>variáveis possuem escopo local.</p><p>2.2 Variáveis Globais</p><p>As variáveis globais são visíveis em qualquer parte do programa e são removidas da</p><p>memória apenas quando o programa encerra sua execução. São declaradas fora do escopo de</p><p>qualquer função, geralmente no início do programa após a inclusão dos cabeçalhos-padrão e dos</p><p>protótipos de funções (MANZANO; OLIVEIRA, 2012).</p><p>O Quadro 7 a seguir traz uma adaptação do programa do Quadro 2, para ilustrar o uso</p><p>de variáveis globais.</p><p>#include</p><p>float num1, num2;</p><p>void soma(void) {</p><p>printf(“Digite o primeiro numero: “);</p><p>scanf(“%f”, &num1);</p><p>printf(“Digite o segundo numero.: “);</p><p>scanf(“%f”, &num2);</p><p>printf(“A soma eh %.2f\n\n”, num1 + num2);</p><p>}</p><p>int main(void) {</p><p>soma();</p><p>soma();</p><p>printf(“num1=%f, num2=%f”, num1, num2);</p><p>return 0;</p><p>}</p><p>Quadro 7 – Exemplos de variáveis globais. Fonte: O autor.</p><p>Colocamos um printf() adicional na função main() para mostrar que as variáveis num1</p><p>e num2 também são visíveis nela e os valores a serem exibidos serão os que foram armazenados</p><p>na última chamada à função soma().</p><p>119WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>4</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>2.3 Variáveis Externas</p><p>Em projetos de grandes aplicações, é comum o uso de vários arquivos de programas que</p><p>são compilados e depois linkados em conjunto com as bibliotecas necessárias para a geração de</p><p>um arquivo executável final. As variáveis globais declaradas em um arquivo podem ser acessadas</p><p>e manipuladas em outros arquivos de programa por meio do comando extern (SCHILDT, 1996).</p><p>O Quadro 8 a seguir ilustra dois arquivos de programas, onde variáveis globais são</p><p>declaradas em um e referenciadas como externas em outro.</p><p>Arquivo1.c Arquivo2.c</p><p>int x, y;</p><p>char ch;</p><p>int main(void) {</p><p>...</p><p>}</p><p>void func1(void) {</p><p>x = 123;</p><p>}</p><p>extern int x, y;</p><p>extern char ch;</p><p>void func22(void) {</p><p>x = y / 10;</p><p>}</p><p>void func23(void) {</p><p>y = 10;</p><p>}</p><p>Quadro 8 – Exemplos de variáveis externas. Fonte: Schildt (1996).</p><p>É recomendável declarar todas as variáveis globais necessárias em apenas um</p><p>arquivo de programa – de preferência onde encontra-se a função main() – e nos</p><p>demais programas referenciá-las como extern. A redeclaração dessas variáveis</p><p>em cada arquivo sem o comando extern passará no processo de compilação, mas</p><p>resultará em erro de duplicidade no processo de linkagem por não se saber qual</p><p>variável usar (SCHIDLT, 1996).</p><p>120WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>4</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>2.4 Variáveis Estáticas</p><p>Variáveis estáticas possuem escopo restrito à função ou ao arquivo em que foi declarada;</p><p>porém, ao contrário das variáveis locais, são mantidas na memória após a execução da função,</p><p>preservando assim o seu conteúdo. Dessa forma, uma chamada posterior a esta função recuperará</p><p>o último valor atribuído a esta variável. Em C, elas são declaradas com o comando static</p><p>(SCHILDT, 1996).</p><p>O Quadro 9 a seguir ilustra um exemplo de uso de variável estática, para contar o número</p><p>de vezes que a função foi chamada.</p><p>#include</p><p>void funcao1(void) {</p><p>static int vezes;</p><p>printf(“%d\n”, ++vezes);</p><p>}</p><p>int main(void) {</p><p>int i;</p><p>for (i = 1; i</p><p>void funcao1(void) {</p><p>static int vezes;</p><p>printf(“%d\n”, ++vezes);</p><p>}</p><p>int main(void) {</p><p>register int i;</p><p>for (i = 1; i</p><p>a seguir ilustra alguns exemplos de declaração de ponteiros</p><p>char *pLetra; // Ponteiro para um caractere</p><p>int *pInteiro; // Ponteiro para um inteiro</p><p>float *pFlutu; // Ponteiro para um ponto flutuante</p><p>double *pDouble; // Ponteiro para um ponto flutuante dupla precisão</p><p>void *pVoid; // Ponteiro genérico (pode aplicar cast depois)</p><p>Quadro 11 – Exemplos de declaração de variáveis de ponteiro. Fonte: O autor.</p><p>123WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>4</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>Embora ponteiros genéricos possam ser criados, declarando como void*, é recomendável</p><p>associá-los ao referido tipo de dado, se souber previamente. A razão disto está em que vetores</p><p>são na verdade ponteiros para o seu primeiro elemento, e o tipo correto torna preciso o acesso e</p><p>a manipulação dos seus elementos na memória.</p><p>Variáveis de ponteiro podem ser inicializadas com NULL ou um endereço válido de</p><p>memória. Caso não recebam atribuição em breve após serem declaradas, é recomendável que</p><p>sejam inicializadas com NULL, para evitar o risco de receberem algum “lixo” aleatório da</p><p>memória (DEITEL, 2011).</p><p>O Quadro 12 a seguir ilustra um exemplo de ponteiro para uma variável inteira e uma</p><p>representação fictícia da memória armazenando ambas as variáveis.</p><p>#include</p><p>int main(void) {</p><p>int x, *ptr;</p><p>x = 5;</p><p>ptr = &x;</p><p>printf(“O valor da variavel X eh: %d\n”, *ptr);</p><p>*ptr = 10;</p><p>printf(“Agora, X vale: %d\n”, *ptr);</p><p>return 0;</p><p>}</p><p>Quadro 12 – Ponteiro para uma variável do tipo inteiro. Fonte: O autor.</p><p>Ponteiros são fundamentais na passagem de vetores e strings por parâmetro e na passagem</p><p>de parâmetros por referência, assuntos abordados na seção 4 desta unidade.</p><p>124WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>4</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>3.1 Operador sizeof</p><p>O operador unário sizeof obtém o tamanho de uma variável ou especificador de tipo</p><p>de dado. Seu operando deve estar entre parênteses se for um especificador de tipo, sob pena de</p><p>erro na compilação; por outro lado, os parênteses são opcionais em variáveis (SCHILDT, 1996).</p><p>Dependendo do compilador, especificadores de tipo contendo uma única palavra também podem</p><p>vir sem parênteses (DEITEL, 2011).</p><p>O Quadro 13 a seguir ilustra alguns exemplos do uso de sizeof.</p><p>#include</p><p>struct data {</p><p>int dia;</p><p>int mes;</p><p>int ano;</p><p>};</p><p>union nota {</p><p>char letra;</p><p>float numero;</p><p>};</p><p>int main(void) {</p><p>int numero = 150, vint[5];</p><p>char letra = ‘A’, vchar[5];</p><p>printf(“Tamanho de numero......: %d\n”, sizeof numero);</p><p>printf(“Tamanho de letra.......: %d\n”, sizeof letra);</p><p>printf(“Tamanho de float.......: %d\n”, sizeof(float));</p><p>printf(“Tamanho de double......: %d\n”, sizeof(double));</p><p>printf(“Tamanho de long double.: %d\n”, sizeof(long double));</p><p>printf(“Tamanho de unsigned int: %d\n”, sizeof(unsigned int));</p><p>printf(“Tamanho de vint[5].....: %d\n”, sizeof vint);</p><p>printf(“Tamanho de vchar[5]....: %d\n”, sizeof vchar);</p><p>printf(“Tamanho de data........: %d\n”, sizeof(struct data));</p><p>printf(“Tamanho de nota........: %d\n”, sizeof(union nota));</p><p>return 0;</p><p>}</p><p>Quadro 13 – Obtendo o tamanho de variáveis e tipos de dados. Fonte: O autor.</p><p>125WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>4</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>O resultado da execução desse programa é ilustrado na Figura 5 a seguir.</p><p>Figura 5 – Resultado da execução do Quadro 13. Fonte: O autor.</p><p>Repare que nos vetores foi retornado o tamanho do tipo de dado multiplicado pelo</p><p>número de elementos, na estrutura foi retornada a soma dos tipos de dados de cada membro, e</p><p>na união foi retornado o tamanho do maior tipo de dado, no caso float.</p><p>O operador sizeof é muito usado em conjunto com ponteiros para um recurso avançado</p><p>da linguagem C chamado alocação dinâmica, em que é possível reservar memória em tempo de</p><p>execução. Além disto, sizeof permite portabilidade entre sistemas diferentes de computador, uma</p><p>vez que o número de bytes usados para armazenar determinado tipo de dado pode variar entre</p><p>certas máquinas e sistemas operacionais (DEITEL, 2011).</p><p>3.2 Ponteiros de Estruturas e Uniões</p><p>Além dos tipos de dados básicos da linguagem, ponteiros também podem ser declarados</p><p>com associação a uma estrutura ou união, conforme o exemplo do Quadro 14 a seguir.</p><p>#include</p><p>struct data {</p><p>int dia;</p><p>int mes;</p><p>int ano;</p><p>};</p><p>int main(void) {</p><p>struct data hoje; // Variável de estrutura data</p><p>struct data *pHoje; // Ponteiro para estrutura data</p><p>hoje.dia = 4;</p><p>hoje.mes = 1;</p><p>hoje.ano = 2020;</p><p>pHoje = &hoje; // Armazena o endereço da estrutura no ponteiro</p><p>printf(“Hoje eh dia: %.2d/%.2d/%d\n”,</p><p>pHoje->dia, pHoje->mes, pHoje->ano);</p><p>return 0;</p><p>}</p><p>Quadro 14 – Exemplo de ponteiros para estruturas. Fonte: O autor.</p><p>126WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>4</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>Nesse exemplo, temos duas formas de referenciar a estrutura instanciada: pela variável</p><p>hoje e pelo ponteiro pHoje, que está apontando para hoje. Repare na diferença do operador de</p><p>acesso aos membros: enquanto uma variável de estrutura utiliza o operador de ponto (.), um</p><p>ponteiro utiliza o operador de seta (->).</p><p>O operador de seta foi criado para simplificar o acesso a membros de estrutura por</p><p>ponteiros, pois o operador de ponto tem precedência sobre o operador de ponteiro; por exemplo,</p><p>pHoje->dia é exatamente o mesmo que (*pHoje).dia. Já a expressão *pHoje.dia, por sua vez,</p><p>seria o acesso ao conteúdo do endereço armazenado no suposto ponteiro dia, membro de pHoje</p><p>– se fosse o caso (DEITEL, 2011).</p><p>4 PASSAGEM DE PARÂMETROS</p><p>De acordo com Manzano e Oliveira (2012):</p><p>O processo de passagem de parâmetro permite estabelecer uma linha de</p><p>comunicação entre os conteúdos dos trechos de sub-rotinas e dos trechos de</p><p>programa que chamam essas sub-rotinas, principalmente quando se usam</p><p>variáveis com escopo local (MANZANO; OLIVEIRA, 2012, p. 221).</p><p>Os parâmetros podem ser classificados como reais e formais. Os parâmetros reais são</p><p>constantes, variáveis ou expressões usadas no momento da chamada de uma sub-rotina para</p><p>que o seu conteúdo seja passado para ela; já os parâmetros formais são variáveis declaradas</p><p>juntamente com a sub-rotina, onde os parâmetros reais são armazenados para serem usados nela</p><p>(MANZANO; OLIVEIRA, 2012).</p><p>A sintaxe geral para a passagem de parâmetros para uma função em C é ilustrada no</p><p>Quadro 15 a seguir.</p><p>tipo funcao(tipo var1, tipo var2, ...)</p><p>{</p><p>declarações;</p><p>instruções;</p><p>...</p><p>}</p><p>Quadro 15 – Sintaxe para a passagem de parâmetros em C. Fonte: Adaptado de Backes (2016).</p><p>Cada variável de parâmetro deve ser declarada com um tipo, seja ele nativo da linguagem</p><p>ou criado pelo usuário. Essas variáveis são chamadas de parâmetros formais e possuem escopo</p><p>local, ou seja, existem apenas dentro da função onde foram declaradas e possuem o mesmo</p><p>comportamento de qualquer outra variável local. Já vimos que elas são opcionais, ou seja, a função</p><p>pode não receber nenhum parâmetro; nesse caso, colocamos void ou simplesmente nada entre os</p><p>parênteses, sendo que a primeira é mais segura do que esta última, pois assegura ao compilador</p><p>que a função não deve receber parâmetro sob pena de erro se isso acontecer (BACKES, 2016).</p><p>A ordem e o tipo dos parâmetros reais passados na chamada da função devem seguir a</p><p>ordem e o tipo dos parâmetros formais declarados, conforme a ilustração da Figura 6 a seguir,</p><p>sob pena de erro na compilação.</p><p>127WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>4</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>Figura 6 – Mecanismo de passagem de parâmetros. Fonte: O autor.</p><p>Esse exemplo da Figura 6 demonstra como o mecanismo de passagem de parâmetros</p><p>permite a criação de funções de uso genérico que podem ser facilmente reaproveitadas. O Quadro</p><p>16 a seguir, por exemplo, ilustra uma função para</p><p>valor 120, afinal: 5! = 5 x 4 x 3 x 2 x 1 = 120. No caso da versão à direita, cada chamada</p><p>da função fatorial() ocorre de forma a empilhar cada uma de suas instâncias em operação para</p><p>depois, no retorno, efetuar a multiplicação sucessiva, calculando assim o fatorial solicitado. Essa</p><p>lógica é ilustrada na Figura 7 a seguir.</p><p>Figura 7 – Esquema lógico da função de fatorial. Fonte: Adaptado de Manzano e Oliveira (2012).</p><p>133WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>4</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>Outro exemplo muito comum de recursividade é a Sequência de Fibonacci, que começa</p><p>com 0,1 e a partir daí cada termo subsequente corresponde à soma dos dois anteriores, compondo</p><p>assim a seguinte sequência: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55 etc. (BACKES, 2016). O Quadro 22 a</p><p>seguir ilustra um programa que pede a posição da sequência e retorna o valor correspondente</p><p>usando a função recursiva fibonacci().</p><p>#include</p><p>int fibonacci(int x) {</p><p>if (x == 0 || x == 1)</p><p>return x;</p><p>else</p><p>return fibonacci(x-2) + fibonacci(x-1);</p><p>}</p><p>int main(void) {</p><p>int num;</p><p>printf(“Digite um numero inteiro: “);</p><p>scanf(“%d”, &num);</p><p>printf(“O fibonacci na posicao %d eh: %d\n”, num, fibonacci(num));</p><p>return 0;</p><p>}</p><p>Quadro 22 – Função recursiva que retorna o número da sequência de Fibonacci. Fonte: Adaptado de Backes (2016).</p><p>Segundo Manzano e Oliveira (2012), a recursividade tem uma vantagem e uma</p><p>desvantagem em programação. A vantagem é que esse processo torna o código mais elegante,</p><p>facilitando a abstração e a modularidade no desenvolvimento de funções que podem ser</p><p>complexas. A desvantagem é o efeito de empilhamento provocado, que pode consumir um espaço</p><p>de memória considerável do computador.</p><p>No exemplo do programa de Fibonacci, quanto mais alta for a posição do número da</p><p>sequência que se deseja saber, maior será o processamento e o consumo de memória para efetuar</p><p>os cálculos recursivos.</p><p>Programação em C/C++ - Aula 54 - Torre de Hanoi (Recursiva)</p><p>Mais um exemplo interessante de recursividade. O vídeo explica</p><p>o desafio do quebra-cabeça e uma solução recursiva utilizando a</p><p>linguagem C++.</p><p>Disponível em: https://www.youtube.com/watch?v=X-I53cLjidg</p><p>134WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>4</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>CONSIDERAÇÕES FINAIS</p><p>Nesta unidade, foram abordados os conceitos da modularização de programas e</p><p>da importância de suas aplicações, como por exemplo o reaproveitamento de código e o</p><p>desenvolvimento de rotinas genéricas.</p><p>Iniciamos a unidade abordando as sub-rotinas, que podem ser classificadas em</p><p>procedimentos e funções. A diferença está em que as funções retornam valor e os procedimentos</p><p>não retornam nada. Em C, as sub-rotinas são implementadas apenas por meio de funções, portanto</p><p>abordamos como funções são declaradas e escritas nos programas. Explicamos como funciona</p><p>a prototipagem de funções e como os valores retornados por elas são usados nas expressões da</p><p>função chamadora.</p><p>Em seguida, abordamos o escopo de variáveis, explicando a diferença entre variáveis locais</p><p>e globais, e destacando a importância de priorizar o uso de variáveis locais no desenvolvimento</p><p>de programas. Também abordamos as classes de variáveis estáticas, externas e de registro,</p><p>particulares da linguagem C.</p><p>Prosseguimos detalhando o recurso de ponteiros da linguagem C e como são importantes</p><p>na passagem de parâmetros, assunto seguinte abordado, onde explicamos a diferença entre a</p><p>passagem por valor e por referência. Concluímos a unidade abordando o conceito de recursividade,</p><p>com alguns exemplos de uso.</p><p>Chegamos, enfim, ao final da disciplina de Algoritmos e Programação Aplicada. Com o</p><p>conteúdo aprendido aqui, espera-se que o discente tenha o conhecimento básico dos principais</p><p>recursos que compõem a lógica de programação e possa partir para o descobrimento de novas</p><p>plataformas, ferramentas e linguagens que venham aprimorar esse conhecimento.</p><p>135WWW.UNINGA.BR</p><p>ENSINO A DISTÂNCIA</p><p>REFERÊNCIAS</p><p>ASCENCIO, A. F. G.; CAMPOS, E. A. V. Fundamentos da programação de computadores:</p><p>Algoritmos, Pascal, C/C++. 3. ed. São Paulo: Prentice Hall, 2012.</p><p>BACKES, A. R. Estrutura de dados descomplicada: em linguagem C. Rio de Janeiro: Elsevier,</p><p>2016.</p><p>DEITEL, P. J. C: como programar. Tradução de Daniel Vieira. 6. ed. São Paulo: Pearson Prentice</p><p>Hall, 2011.</p><p>DIBBLE, J. UNIVAC/ERA 1101: primeiro computador da história que rodava um programa</p><p>da memória. 2021. Disponível em: https://sites.google.com/site/byjessicadibble/home/abacus/</p><p>difference-engine/z1/colossus/abc/edsac/electronic-controls-company/univac-1101-era-1101.</p><p>Acesso em: 9 set. 2021.</p><p>FORBELLONE, A. L. V.; EBERSPACHER, H. F. Lógica de Programação: a construção de</p><p>algoritmos e estruturas de dados. 3. ed. São Paulo: Prentice Hall, 2005.</p><p>GERAÇÕES DE COMPUTADORES. Exemplo de um computador de quinta geração. 2021.</p><p>Disponível em: https://geracoesdecomputadores.files.wordpress.com/2011/08/imac.png. Acesso</p><p>em: 9 set. 2021.</p><p>GUEDES, S. Lógica de programação algorítmica. São Paulo: Pearson Education do Brasil, 2014.</p><p>LOPES, A.; GARCIA, G. Introdução à Programação: 500 Algoritmos Resolvidos. Rio de Janeiro:</p><p>Elsevier, 2002.</p><p>MANZANO, A. L. N. G.; MANZANO, M. I. N. G. Estudo Dirigido de Informática Básica. São</p><p>Paulo: Saraiva, 2009.</p><p>MANZANO, J. A. N. G.; OLIVEIRA, J. F. Algoritmos: Lógica para Desenvolvimento de</p><p>Programação de Computadores. 26. ed. São Paulo: Érica, 2012.</p><p>MICROSOFT DOCS. foreach, in (Referência em C#). 2019. Disponível em: https://docs.</p><p>microsoft.com/pt-br/dotnet/csharp/language-reference/keywords/foreach-in. Acesso em: 29</p><p>dez. 2019.</p><p>PRESSMAN, R. S. Engenharia de Software. 7. ed. São Paulo: Makron, McGraw-Hill, 1995.</p><p>SCHILDT, H. C Completo e Total. Tradução de Roberto Carlos Mayer. 3. ed. São Paulo: Makron</p><p>Books, 1996.</p><p>SEBESTA, R. W. Conceitos de linguagens de programação. Tradução de Eduardo Kessler Piveta.</p><p>9. ed. Porto Alegre: Bookman, 2011.</p><p>SINTES, A. Aprenda Programação Orientada a Objetos em 21 dias. São Paulo: Pearson</p><p>Education do Brasil, 2002.</p><p>https://sites.google.com/site/byjessicadibble/home/abacus/difference-engine/z1/colossus/abc/edsac/electronic-controls-company/univac-1101-era-1101.</p><p>https://sites.google.com/site/byjessicadibble/home/abacus/difference-engine/z1/colossus/abc/edsac/electronic-controls-company/univac-1101-era-1101.</p><p>https://geracoesdecomputadores.files.wordpress.com/2011/08/imac.png.</p><p>136WWW.UNINGA.BR</p><p>ENSINO A DISTÂNCIA</p><p>REFERÊNCIAS</p><p>SOUZA, M. F. F. Computadores e sociedade: da filosofia às linguagens de programação. Curitiba:</p><p>InterSaberes, 2016.</p><p>TANENBAUM, A. S. Organização estruturada de computadores. 6. ed. São Paulo: Pearson</p><p>Prentice Hall, 2013.</p><p>TUCKER, A. B.; NOONAN, R. E. Linguagens de programação: Princípios e Paradigmas.</p><p>Tradução de Mario Moro Fecchio. 2. ed. Porto Alegre: AMGH, 2010.</p><p>VILARIM, G, O. Algoritmos: Programação Para Iniciantes. 3. ed. Rio de Janeiro: Ciência</p><p>Moderna, 2017.</p><p>WIKIWAND. Intel 8008, 1972 - primeiro microprocessador de 8 bits. 2021. Disponível em:</p><p>https://www.wikiwand.com/pt/Microprocessador. Acesso em: 9 set. 2021.</p><p>XAVIER, G. F. C. Lógica de Programação. 12. ed. São Paulo: Senac, 2011.</p><p>https://www.wikiwand.com/pt/Microprocessador.</p><p>pelos computadores, as instruções por eles executadas, bem como os resultados de</p><p>um processamento são sempre constituídos de conjuntos ordenados de zeros e uns.</p><p>10WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>IN</p><p>TR</p><p>OD</p><p>UT</p><p>ÓR</p><p>IA</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>Como o computador não entende nossa linguagem, ela deve ser compilada. Esse processo</p><p>de compilação, em termos gerais, consiste em transformar uma linguagem em outra, neste caso,</p><p>as nossas instruções para a linguagem binária (0 e 1), que é a linguagem que o computador</p><p>compreende. Isso é feito por um tipo de software/sistema chamado Linguagem de Programação.</p><p>Assim, podemos entender que o conceito de software refere-se a todos os elementos de</p><p>programação de um sistema de computação, isto é, a todos os programas, sejam eles de softwares</p><p>de aplicação sejam softwares básicos.</p><p>a) Software básico: são os programas que definem o padrão do equipamento, sendo</p><p>necessários para o seu funcionamento. Os tipos de software básico são: sistema operacional,</p><p>linguagens de programação, tradutores e utilitários.</p><p>b) Software aplicativos: são programas para as mais variadas finalidades e situações, são</p><p>utilizados pelos usuários para realizar trabalhos rotineiros. Exemplos: editores de texto,</p><p>calculadoras, aplicativos para ouvir músicas, aplicativos para contabilidade e de recursos</p><p>humanos.</p><p>Vamos dar destaque a dois tipos de softwares, importantes para o nosso domínio de</p><p>conhecimento na disciplina de Algoritmos e Programação Aplicada. São eles:</p><p>Sistema Operacional: segundo Manzano e Manzano (2009), o sistema operacional (SO)</p><p>é responsável pelo gerenciamento, funcionamento e execução de todos os programas e todos os</p><p>periféricos do sistema computacional. Sem o SO, o computador não tem “vida”, é um software</p><p>que se encontra na categoria dos programas de sistema. Ele é o mais importante entre todos,</p><p>pois representa o papel de tradutor e intérprete entre a máquina e o homem (e vice-versa) e</p><p>gerencia todos os periféricos e softwares, pois trabalha juntamente com a CPU. Entre os sistemas</p><p>operacionais, citem-se: Microsoft Windows; OS/2; Unix; Mac/OS.</p><p>Figura 6 - Posicionamento de um Sistema Operacional num Sistema Computacional. Fonte: A autora.</p><p>Linguagens de Programação: é um conjunto de símbolos (vocabulário) e regras</p><p>(gramática) que especificam como transmitir informações entre usuários e computador. As</p><p>linguagens de programação estão divididas em: linguagem de máquina, linguagem de baixo nível</p><p>e linguagem de alto nível.</p><p>11WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>IN</p><p>TR</p><p>OD</p><p>UT</p><p>ÓR</p><p>IA</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>A linguagem de máquina é baseada em código binário, em 0s e 1s. É utilizada diretamente</p><p>pelo computador. A linguagem de baixo nível é uma simplificação da linguagem de máquina.</p><p>Faz uso de códigos mnemônicos para expressar as instruções. Exemplo: Assembly. A linguagem</p><p>de alto nível utiliza a combinação de um conjunto de símbolos de acordo com certas regras de</p><p>sintaxe para expressar uma sequência de operações de máquina. É uma linguagem que não exige</p><p>conhecimento do código binário. Exemplo: C, JAVA, Python.</p><p>1.3 Sistemas de Numeração Utilizados nos Sistemas Computacionais</p><p>A história da matemática conta sobre a necessidade de contar do ser humano desde</p><p>que ele deixou de ser nômade. A necessidade de contagem foi impulsionada por atividades de</p><p>agricultura e pastoreio, pela representação da quantidade de cabeças em um rebanho, fases da</p><p>Lua e estações do ano para o plantio etc. Dessa forma, a representação numérica foi ganhando</p><p>forma por meio dos algarismos.</p><p>O sistema de numeração é um conjunto de regras para a representação dos números.</p><p>O sistema numérico decimal é o mais utilizado pela humanidade. Acredita-se que o número</p><p>de dedos que o homem tem nas mãos foi um fato decisivo, nos primórdios, para a criação e</p><p>disseminação desse sistema.</p><p>Um sistema de numeração é definido principalmente pela BASE, que indica a quantidade</p><p>de símbolos e o valor de cada símbolo. Exemplos: Sistema Decimal (base 10): 0, 1, 2, 3, 4, 5, 6,</p><p>7, 8, 9; Sistema Binário (base 2): 0, 1; Sistema Octal (base 8): 0, 1, 2, 3, 4, 5, 6, 7, 8; e Sistema</p><p>Hexadecimal (base 16): 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F.</p><p>Com o advento da eletrônica digital e, principalmente, do computador, surgem outras</p><p>necessidades, como a de representar os números utilizando a eletricidade. Como você já sabe,</p><p>um computador funciona movido à energia elétrica. A ausência ou presença de energia (0v ou</p><p>+5v) é representada por 0’s e 1’s, ou seja, o Sistema Binário. O matemático indiano Pingala</p><p>apresentou a primeira descrição conhecida de um sistema numérico binário no século III a.C.,</p><p>representando os números de 1 a 8 com a sequência (usando símbolos modernos) 000, 001, 010,</p><p>011, 100, 101,110 e 111.</p><p>Nesse contexto computacional, o computador opera valores utilizando a lógica binária</p><p>que trabalha com o sistema binário que contém somente dois algarismos: 0 e 1. Para simplificar</p><p>a codificação de instruções em nível de máquina, são utilizadas conversões para outros tipos de</p><p>sistemas de numeração a fim de tornar a definição das instruções mais inteligível ao ser humano.</p><p>Veja uma linha do tempo da história do software e das linguagens de</p><p>programação. Acesse: https://www.computerhistory.org/timeline/</p><p>software-languages/.</p><p>https://www.computerhistory.org/timeline/software-languages/</p><p>https://www.computerhistory.org/timeline/software-languages/</p><p>12WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>IN</p><p>TR</p><p>OD</p><p>UT</p><p>ÓR</p><p>IA</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>Figura 7 - Representação dos dados. Fonte: A autora.</p><p>Por fim, como a representação de números binários de alto valor torna os dígitos quase</p><p>ilegíveis para nós, é comum utilizar o sistema hexadecimal para abreviá-los, pois cada dígito</p><p>hexadecimal guarda 4 dígitos binários.</p><p>A seguir, vamos detalhar alguns sistemas numéricos presentes na nossa vivência com os</p><p>sistemas computacionais.</p><p>1.3.1 Sistema decimal</p><p>É o nosso sistema mais familiar. Sua base numérica é de dez, ou seja, a quantidade de</p><p>símbolos é 10. De zero a nove, utilizam-se dez algarismos diferentes para representar todos os</p><p>números - 0, 1, 2, 3, 4, 5, 6, 7, 8, 9. É um sistema posicional, ou seja, a posição do algarismo no</p><p>número modifica o seu valor. Ou seja, cada número em uma sequência de algarismos tem valor</p><p>diferente, dependendo de sua posição.</p><p>Veja um exemplo: no número decimal 777, cada cinco tem um valor diferente. O primeiro</p><p>vale sete centenas (700); o segundo, sete dezenas (70); e o terceiro, sete unidades (7). O valor</p><p>final é fornecido por 777 = 700 + 70 + 7 = 7 * 102 + 7 * 101 + 7 * 100. Os pesos das posições são</p><p>potências de dez, no caso do sistema decimal.</p><p>Veremos em seguida os sistemas binário, octal e hexadecimal, que também são sistemas</p><p>posicionais, mas, no sistema binário são potências de dois, no octal são potências de oito e no</p><p>sistema hexadecimal são potências de 16.</p><p>Você sabe o que é Código ASCII?</p><p>O Código ASCII - American Standard Code for Information Interchange (Código</p><p>Padrão Americano para o Intercâmbio de Informação) - é baseado no alfabeto</p><p>romano, e sua função é padronizar a forma como os computadores representam</p><p>letras, números, acentos, sinais diversos e alguns códigos de controle. Foi proposto</p><p>por Robert W. Bemer, visando a padronizar os códigos. Assim, foi possível que</p><p>computadores de diferentes fabricantes conseguissem entender os códigos. Ele</p><p>é um padrão de codificação de letras e símbolos bastante antigo e usado até hoje.</p><p>13WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>IN</p><p>TR</p><p>OD</p><p>UT</p><p>ÓR</p><p>IA</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>1.3.2 Sistema binário</p><p>Representação binária ou de base 2, este sistema usa apenas dois símbolos básicos: o 0 e o</p><p>1. É um sistema de numeração posicional em que todas as quantidades se representam com base</p><p>nos algarismos zero e um. Da mesma</p><p>forma que no sistema decimal discutido antes, cada dígito</p><p>pode ser representado pela sua potência ou peso.</p><p>Palavras binárias com certas quantidades de dígitos podem adquirir nomes especiais, por</p><p>exemplo, um dígito binário é chamado de BIT, proveniente das palavras inglesas BInary digiT.</p><p>O bit, do inglês BInary digiT, é um símbolo ou elemento que pode representar dois</p><p>estados possíveis, como uma luz que está ligada (1) ou desligada (0). Em computadores, o valor</p><p>0 é usualmente associado a alguma voltagem baixa, e o valor 1, a uma voltagem mais alta. No</p><p>momento atual, um grande número de tecnologias tem convergido para o uso da representação</p><p>binária, usando diferentes meios para a representação física do bit.</p><p>1.3.3 Sistemas octal e hexadecimal</p><p>Até o momento, foi discutido que os computadores digitais usam o sistema de numeração</p><p>binária (base 2) por sua facilidade em associar seus dois possíveis valores, 0 e 1, a fenômenos</p><p>físicos que ocorrem internamente no computador. Outros sistemas numéricos utilizados na</p><p>computação são os sistemas de numeração octal e hexadecimal, que compactam significativamente</p><p>a representação de números binários, ou seja, a principal utilização para números hexadecimal e</p><p>octal em computação é abreviar longas representações binárias.</p><p>A Tabela 1 representa números binários longos e como eles podem ser expressos</p><p>brevemente em sistemas de numeração com bases mais altas.</p><p>Tabela 1 - Equivalentes decimais, binários, octais e hexadecimais.</p><p>Número Decimal Representação Binária Representação Octal Representação Hexadecimal</p><p>0 0 0 0</p><p>1 1 1 1</p><p>2 10 2 2</p><p>3 11 3 3</p><p>4 100 4 4</p><p>5 101 5 5</p><p>6 110 6 6</p><p>7 111 7 7</p><p>8 1000 10 8</p><p>9 1001 11 9</p><p>10 1010 12 A</p><p>11 1011 13 B</p><p>12 1100 14 C</p><p>13 1101 15 D</p><p>14 1110 16 E</p><p>15 1111 17 F</p><p>16 100000 20 10</p><p>Fonte: A autora.</p><p>14WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>IN</p><p>TR</p><p>OD</p><p>UT</p><p>ÓR</p><p>IA</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>Um relacionamento importante que os sistemas de numeração octal (como o hexadecimal)</p><p>têm com o binário é que as bases octal e hexadecimal são potências da base do sistema de</p><p>numeração binário.</p><p>Considere o número binário de 12 algarismos 100011010001. Para ver como o número</p><p>binário é facilmente convertido em octal, divida o número binário de 12 dígitos em grupos de três</p><p>bits consecutivos cada e escreva esses grupos sobre os dígitos correspondentes do número octal</p><p>como a seguir, de acordo com o seu correspondente na Tabela 1.</p><p>Binário 100 011 010 001</p><p>Otal 4 3 2 1</p><p>O mesmo tipo de relacionamento pode ser observado ao se converter de binário para</p><p>hexadecimal. Divida o número binário de 12 algarismos em grupos de quatro bits consecutivos</p><p>cada e escreva esses grupos sobre os dígitos correspondentes do número hexadecimal como a</p><p>seguir:</p><p>Binário 1000 1101 0001</p><p>Hexa 8 D 1</p><p>O sistema hexadecimal está vinculado aos sistemas computacionais, pois os computadores</p><p>costumam utilizar o byte como unidade básica da memória, 1 byte = 8 bits e, então, um byte pode</p><p>ser representado por 8 algarismos do sistema binário ou por 2 algarismos do sistema hexadecimal.</p><p>Por exemplo: 1110 0110 [binário] = E6 [hexadecimal].</p><p>Para mais informações sobre os sistemas de numeração e suas</p><p>conversões, ler o capítulo 4 do livro:</p><p>CARVALHO, A. C. P. L. F.; LORENA, A. C. Introdução à Computação -</p><p>Hardware, Software e Dados. LTC, 2016.</p><p>O material está disponível em:</p><p>https://integrada.minhabiblioteca.com.br/#/books/9788521633167/.</p><p>https://integrada.minhabiblioteca.com.br/#/books/9788521633167/</p><p>15WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>IN</p><p>TR</p><p>OD</p><p>UT</p><p>ÓR</p><p>IA</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>CONSIDERAÇÕES FINAIS</p><p>Assim, finalizamos nossa unidade introdutória sobre sistemas computacionais, este tema</p><p>tão importante quanto a como são organizados estes sistemas, para que você consiga aprofundar</p><p>seus estudos sobre algoritmos e a programação propriamente dita, produzindo seus códigos e</p><p>comandos (software) para o hardware executar as operações que você necessita automatizar.</p><p>Esta é uma das intenções desta unidade introdutória: chamar a atenção para assuntos que</p><p>vão além do “para que isto me servirá?”, que domina o senso-comum. Esta unidade de estudo</p><p>trouxe a essência e os fundamentos dos sistemas computacionais.</p><p>1616WWW.UNINGA.BR</p><p>U N I D A D E</p><p>01</p><p>SUMÁRIO DA UNIDADE</p><p>INTRODUÇÃO ............................................................................................................................................................... 18</p><p>1 ALGORITMOS ............................................................................................................................................................ 19</p><p>1.1 DESCRIÇÃO NARRATIVA .......................................................................................................................................20</p><p>1.2 FLUXOGRAMA ........................................................................................................................................................ 21</p><p>1.3 PSEUDOCÓDIGO ....................................................................................................................................................22</p><p>2 PROGRAMAS E LINGUAGENS DE PROGRAMAÇÃO..............................................................................................23</p><p>2.1 COMPILADORES ....................................................................................................................................................24</p><p>2.2 INTERPRETADORES .............................................................................................................................................25</p><p>2.3 LINGUAGENS DE PROGRAMAÇÃO ......................................................................................................................25</p><p>2.4 LINGUAGEM C .......................................................................................................................................................26</p><p>3 TIPOS DE DADOS ..................................................................................................................................................... 31</p><p>3.1 TIPOS DE DADOS BÁSICOS .................................................................................................................................. 31</p><p>ALGORITMOS E ELEMENTOS</p><p>BÁSICOS DE PROGRAMAÇÃO</p><p>PROF. FÁBIO ATAIDE DE LIMA</p><p>ENSINO A DISTÂNCIA</p><p>DISCIPLINA:</p><p>ALGORITMOS E PROGRAMAÇÃO APLICADA</p><p>17WWW.UNINGA.BR</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>3.2 ENUMERADORES ..................................................................................................................................................33</p><p>3.3 PONTEIROS ...........................................................................................................................................................33</p><p>4 CONSTANTES E VARIÁVEIS ....................................................................................................................................34</p><p>4.1 CONSTANTES .........................................................................................................................................................34</p><p>4.1.1 CONSTANTES LITERAIS .....................................................................................................................................35</p><p>4.1.2 CONSTANTES MANIFESTAS .............................................................................................................................35</p><p>4.2 VARIÁVEIS .............................................................................................................................................................36</p><p>5 EXPRESSÕES E OPERADORES ...............................................................................................................................37</p><p>5.1 EXPRESSÕES ARITMÉTICAS ...............................................................................................................................37</p><p>5.2 EXPRESSÕES RELACIONAIS ...............................................................................................................................38</p><p>5.3 EXPRESSÕES LÓGICAS ........................................................................................................................................39</p><p>5.4 PRECEDÊNCIA DE OPERADORES .......................................................................................................................40</p><p>5.5 CONVERSÕES DE TIPOS ...................................................................................................................................... 41</p><p>6 ENTRADA E SAÍDA DE DADOS ................................................................................................................................42</p><p>6.1 ENTRADA DE DADOS .............................................................................................................................................43</p><p>6.2 SAÍDA DE DADOS ..................................................................................................................................................46</p><p>CONSIDERAÇÕES FINAIS ...........................................................................................................................................50</p><p>18WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>1</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>INTRODUÇÃO</p><p>Caro(a) aluno(a), seja bem-vindo(a) à disciplina de Algoritmos e Programação Aplicada.</p><p>Nesta disciplina, serão apresentados os princípios básicos de lógica de programação e os principais</p><p>comandos necessários para o desenvolvimento de algoritmos.</p><p>A lógica está relacionada ao processo de raciocínio, à capacidade de ordenar os</p><p>pensamentos e à busca de soluções através de ideias coerentes. Por exemplo, para pegar uma</p><p>caneta que está dentro de uma caixa, deve-se primeiro abrir a caixa para depois pegar a caneta;</p><p>não é possível atravessar a caixa sem abri-la.</p><p>A utilização da lógica é fundamental para a criação de algoritmos, primeiro assunto</p><p>abordado nesta unidade, onde descrevemos a sua definição e as suas formas de representação. Em</p><p>seguida, é abordado o conceito de programa, seus componentes básicos e o fluxo de transformação</p><p>de um código escrito a um programa executável.</p><p>Prosseguimos abordando as linguagens de programação, ferramenta utilizada na</p><p>codificação de programas, e introduzimos o aluno à linguagem C, adotada neste livro para o</p><p>aprendizado da lógica de programação.</p><p>Em seguida, já com base na linguagem C, apresentamos os tipos de dados existentes, a</p><p>definição de constantes e variáveis, esta última um recurso importante para o armazenamento e a</p><p>recuperação de informações da memória RAM. Prosseguimos abordando os tipos de operadores</p><p>e as expressões que podem ser formadas para cálculos e processamentos diversos.</p><p>Concluímos a unidade descrevendo os processos de como o usuário informa dados ao</p><p>programa, e como o programa retorna esses dados em forma de resultados para o usuário.</p><p>19WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>1</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>1 ALGORITMOS</p><p>Segundo Manzano e Oliveira (2012), a palavra algoritmo pode ser empregada na</p><p>matemática e na ciência da computação:</p><p>O termo algoritmo, do ponto de vista computacional, pode ser entendido</p><p>como regras formais, sequenciais e bem definidas a partir do entendimento</p><p>lógico de um problema a ser resolvido por um programador com o objetivo de</p><p>transformá-lo em um programa que seja possível de ser tratado e executado por</p><p>um computador, em que dados de entrada são transformados em dados de saída</p><p>(MANZANO; OLIVEIRA, 2012, p. 28).</p><p>De acordo com o problema a ser resolvido, são vários os caminhos que podem ser</p><p>utilizados para encontrar a sua solução. O algoritmo é um conjunto de passos que define um</p><p>desses caminhos. Cada passo é chamado de instrução; assim, um algoritmo pode também ser</p><p>definido como um conjunto de instruções (LOPES; GARCIA, 2002).</p><p>O Quadro 1 a seguir apresenta dois exemplos de algoritmos para ir ao trabalho, desde o</p><p>momento em que o indivíduo acorda até a chegada ao escritório.</p><p>1. Desligar o despertador</p><p>2. Ir para o banheiro</p><p>3. Lavar o rosto</p><p>4. Escovar os dentes</p><p>5. Tirar o pijama</p><p>6. Colocar uma roupa</p><p>7. Tomar café da manhã</p><p>8. Pegar o carro</p><p>9. Estacionar o carro</p><p>10. Entrar no escritório</p><p>1. Desligar o despertador</p><p>2. Ir para o banheiro</p><p>3. Escovar os dentes</p><p>4. Tomar banho</p><p>5. Colocar uma roupa</p><p>6. Se estiver chovendo, pegar</p><p>guarda-chuva</p><p>7. Pegar ônibus</p><p>8. Descer do ônibus</p><p>9. Entrar no escritório</p><p>Quadro 1 – Algoritmos de ida ao trabalho. Fonte: O autor.</p><p>Os dois algoritmos do Quadro 1 resolvem o problema de “ida ao trabalho” de formas</p><p>diferentes. Cada linha numerada representa uma instrução a ser executada e pode ser detalhada</p><p>se necessário. Por exemplo, a instrução “escovar os dentes” poderia ser subdividida nos seguintes</p><p>passos:</p><p>• Pegar a pasta e a escova de dentes;</p><p>• Aplicar a pasta de dentes na escova;</p><p>• Molhar a escova com um pouco de água;</p><p>• Escovar os dentes;</p><p>• Enxaguar a boca;</p><p>• Guardar a pasta e a escova de dentes.</p><p>Qualquer outra instrução poderia ser igualmente detalhada, estruturando o algoritmo</p><p>de forma lógica e organizada. Como a essência do algoritmo está em resolver um determinado</p><p>problema em passos, podemos dizer que conhecemos diversos algoritmos de forma empírica,</p><p>já que na realidade lidamos com vários tipos de “problemas” cotidianos que demandam uma</p><p>solução.</p><p>20WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>1</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>Apesar de a lógica de programação ser considerada por alguns como um “dom” que</p><p>já nasce com o afortunado, qualquer pessoa pode desenvolver sua própria lógica, por meio de</p><p>muita prática e exercício. É como aprender a dirigir: a pessoa recebe os ensinamentos teóricos</p><p>e práticos, mas somente com a experiência contínua de dirigir nas ruas é que ela irá adquirir</p><p>prática e experiência.</p><p>E nessa jornada de aprendizado, por quanto mais situações complexas e difíceis passamos,</p><p>mais maduros e experientes ficamos. É normal que o aspirante a programador venha a se deparar</p><p>com muitos erros e falhas durante o desenvolvimento de seus algoritmos (programas), mas são</p><p>exatamente esses obstáculos que formarão uma lógica de programação robusta e consistente nele.</p><p>De acordo com Ascencio e Campos (2012), existem três formas de representação de</p><p>algoritmos: descrição narrativa, fluxograma e pseudocódigo. Detalhamos cada um desses tipos</p><p>nas seções seguintes.</p><p>1.1 Descrição Narrativa</p><p>A descrição narrativa consiste em escrever as instruções na linguagem natural, em</p><p>sequência (ASCENCIO; CAMPOS, 2012). O Quadro 2 a seguir ilustra um algoritmo para somar</p><p>dois números em descrição narrativa.</p><p>1. Obter dois números</p><p>2. Somar os dois números</p><p>3. Mostrar o resultado da soma</p><p>Quadro 2 – Algoritmo no formato de descrição narrativa. Fonte: O autor.</p><p>Segundo Ascencio e Campos (2012), a descrição narrativa possui a vantagem de ser de</p><p>fácil aprendizado, uma vez que as instruções são escritas na língua natural. Por outro lado, como</p><p>desvantagem ela é ambígua, ou seja, pode gerar diversas interpretações e isso dificulta a conversão</p><p>do algoritmo em um programa.</p><p>21WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>1</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>1.2 Fluxograma</p><p>O fluxograma consiste em escrever as instruções do algoritmo utilizando os símbolos</p><p>gráficos descritos no Quadro 3 a seguir (ASCENCIO; CAMPOS, 2012).</p><p>Quadro 3 – Conjunto de símbolos utilizados do fluxograma. Fonte: Ascencio e Campos (2012).</p><p>Na Figura 1 a seguir, temos a representação do algoritmo de somar dois números em</p><p>forma de fluxograma.</p><p>Figura 1 – Algoritmo no formato de fluxograma. Fonte: O autor.</p><p>Segundo Ascencio e Campos (2012), a vantagem do fluxograma está nos símbolos gráficos,</p><p>que são universais e podem ser interpretados independente do idioma. Como desvantagem, é</p><p>necessário</p><p>aprender a simbologia apresentada no Quadro 3; além disso, ele não apresenta muitos</p><p>detalhes e, por isso, dificulta a conversão do algoritmo em um programa.</p><p>22WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>1</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>1.3 Pseudocódigo</p><p>O pseudocódigo, também conhecido como Portugol ou português estruturado, consiste</p><p>em escrever as instruções com regras de sintaxe predefinidas, sendo uma linguagem restrita que</p><p>descreve o significado dos termos utilizados (ASCENCIO; CAMPOS, 2012).</p><p>O Quadro 4 a seguir ilustra o algoritmo de somar dois números representado em</p><p>pseudocódigo.</p><p>Algoritmo "soma"</p><p>Var</p><p>n1, n2, s: inteiro</p><p>Inicio</p><p>Leia(n1, n2)</p><p>s</p><p>na Figura 4 a seguir.</p><p>27WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>1</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>Figura 4 – Ambiente típico de desenvolvimento em C. Fonte: Deitel (2011).</p><p>28WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>1</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>Devido ao paradigma procedural da linguagem, todo programa em C é estruturado em</p><p>funções e dentro delas estão contidas as instruções a serem executadas. O Quadro 6 a seguir</p><p>ilustra um esboço desta estrutura.</p><p>tipo nome_da_função(parâmetros)</p><p>{</p><p>variáveis locais</p><p>instruções</p><p>}</p><p>Quadro 6 – Estrutura de um programa em C. Fonte: O autor.</p><p>Cada item é descrito da seguinte forma:</p><p>• tipo: tipo de dado a ser retornado pela função;</p><p>• parâmetros (opcional): lista de argumentos a serem passados para a função, devidamente</p><p>tipados;</p><p>• {}: delimitam o início e o final da função;</p><p>• variáveis locais (opcional): declaração das variáveis locais a serem usadas, devidamente</p><p>tipadas;</p><p>• instruções: comandos a serem executados.</p><p>Todo programa em C, após ser escrito, deve ser gravado no formato de arquivo texto –</p><p>cujo nome deve ter a extensão .c – em um dispositivo de armazenamento secundário, como por</p><p>exemplo um disco rígido ou um pendrive (DEITEL, 2011).</p><p>Existem vários ambientes de desenvolvimento integrado (IDE)</p><p>disponíveis para a linguagem C em vários sistemas operacionais.</p><p>Deixamos o aluno à vontade para usar o de sua preferência. Para</p><p>Windows, temos: Turbo C, DevC++, Code Blocks etc.; este último</p><p>possui disponível um tutorial de como compilar seu primeiro</p><p>programa.</p><p>Linguagem C #02: Primeiro programa em C</p><p>Disponível em: https://www.youtube.com/watch?v=VGC-XEj76xI .</p><p>Acesso em: 9 set. 2020.</p><p>29WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>1</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>Vamos enfim ao nosso primeiro programa em C, o famigerado “Alô Mundo” – sugestão</p><p>de nome de arquivo: AloMundo.c. O Quadro 7 a seguir ilustra como ficaria o código desse</p><p>programa.</p><p>#include // Inclui o cabeçalho de funções de E/S</p><p>/* Trecho do programa principal */</p><p>int main(void)</p><p>{</p><p>printf(“Alo, Mundo!”); // Imprime o texto na tela</p><p>return 0; // Retorna o valor para o SO</p><p>}</p><p>Quadro 7 – Programa “Alô Mundo”. Fonte: O autor.</p><p>Esse programa consiste em 6 linhas, já desconsiderando a linha em branco, mas pode</p><p>ser reduzido ainda mais devido à flexibilidade de estruturar várias instruções em uma só linha.</p><p>Vamos descrever o significado dos comandos linha por linha:</p><p>• #include – todo comando que inicia com # é uma diretiva de pré-processamento</p><p>e é analisado na Fase 2 da Figura 4. #include permite que funções em um determinado</p><p>cabeçalho-padrão sejam chamadas no programa. stdio.h contém o protótipo da função</p><p>printf(), usada umas linhas adiante no programa do Quadro 7;</p><p>• /* Trecho do programa principal */ – essa linha é um comentário e será ignorada pelo</p><p>compilador. C oferece dois comandos para fazer comentários em programas: /* */, que</p><p>permitem comentários em múltiplas linhas; e //, que pode ser usado no final de uma linha</p><p>com instruções, e os comentários estendem-se até o final da linha. É uma boa prática fazer</p><p>comentários nos programas, como forma de documentação e de guia para determinadas</p><p>operações realizadas nele, com o objetivo de auxiliar em uma ocasional manutenção;</p><p>• int main(void) – todo programa em C deve conter uma função denominada main(), toda</p><p>em minúscula, pois é por meio dela que a execução é iniciada. Geralmente ela retorna um</p><p>valor numérico para o sistema operacional, sendo que 0 indica sucesso de execução e</p><p>outro número indica um erro a ser tratado externamente; por isso, definimos int como</p><p>tipo de retorno. A palavra void entre os parênteses é usada para indicar que a função não</p><p>receberá parâmetros.</p><p>• printf(“Alo, Mundo!”); – essa função imprime dados no dispositivo de saída corrente,</p><p>nesse caso, a tela do monitor. Uma lista de parâmetros pode ser passada para a função</p><p>inclusive com a opção de formatar os dados a serem exibidos;</p><p>• return 0; – esse comando retorna o valor especificado para a função chamadora. No caso</p><p>da função main(), sempre retornaremos 0, indicando sucesso na execução.</p><p>30WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>1</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>Com exceção das diretivas de pré-processamento, os demais comandos – incluindo</p><p>as chaves delimitadoras {} – podem ser agrupados em uma linha. O Quadro 8 a seguir ilustra</p><p>algumas formas alternativas para codificar o programa “Alô Mundo”.</p><p>int main(void) {</p><p>printf(“Alo, Mundo!”);</p><p>return 0;</p><p>}</p><p>int main(void)</p><p>{ printf(“Alo, Mundo!”);</p><p>return 0;</p><p>}</p><p>int main(void) { printf("Alo, Mundo!"); return 0; }</p><p>Quadro 8 – Variantes do programa “Alô Mundo”. Fonte: O autor.</p><p>Todos os exemplos do Quadro 8 fazem exatamente a mesma coisa do programa do</p><p>Quadro 7. A única diferença está na forma em que as instruções foram distribuídas.</p><p>C é uma linguagem case-sensitive, isto é, faz distinção entre maiúscula e</p><p>minúscula. Todas as palavras reservadas em C são minúsculas; a função main(),</p><p>como já visto, deve ser declarada em minúscula; a variável valor é diferente de</p><p>Valor ou VALOR, são três variáveis distintas; processa() é diferente de Processa()</p><p>ou PROCESSSA(), são três funções distintas (SCHILDT, 1996).</p><p>Além disso, todos os comandos são concluídos com um ponto-e-vírgula (;),</p><p>também chamado de terminador de instruções. Exceções a esta regra são as</p><p>declarações de funções e as diretivas de pré-processamento (DEITEL, 2011).</p><p>31WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>1</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>3 TIPOS DE DADOS</p><p>Na linguagem C, existem cinco tipos de dados básicos e dois tipos de dados especiais,</p><p>abordados nas seções seguintes.</p><p>3.1 Tipos de Dados Básicos</p><p>Segundo Schildt (1996), os dados podem ser representados por cinco tipos básicos:</p><p>• char: caractere;</p><p>• int: inteiro;</p><p>• float: ponto flutuante;</p><p>• double: ponto flutuante de precisão dupla;</p><p>• void: nulidade ou ausência de valor.</p><p>Com exceção do void, os demais tipos podem ter sua capacidade ou faixa de valores</p><p>alterada com o uso de modificadores. Existem quatro modificadores, segundo Schildt (1996):</p><p>• unsigned: utilizado para declarar os tipos como sem sinal, duplicando assim a gama de</p><p>valores que pode ser representado;</p><p>• signed: declara tipos contendo sinal;</p><p>• short: reduz a capacidade de armazenamento;</p><p>• long: aumenta a capacidade de armazenamento.</p><p>32WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>1</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>Na prática, signed e short são redundantes e pouco usados, pois a declaração padrão de</p><p>tipos já considera, respectivamente, o sinal e a menor faixa de valores.</p><p>O Quadro 9 a seguir apresenta os tipos de dados com e sem modificadores, seu tamanho</p><p>e sua faixa de dados permitida.</p><p>Tipo Faixa de valores Tamanho aproximado</p><p>char -128 a 127 8 bits (1 byte)</p><p>unsigned char 0 a 255 8 bits (1 byte)</p><p>int -32.768 a 32.767 16 bits (2 bytes)</p><p>short int -32.768 a 32.767 16 bits (2 bytes)</p><p>unsigned int 0 a 65.535 16 bits (2 bytes)</p><p>long int -2.147.483.648 a 2.147.489.647 32 bits (4 bytes)</p><p>long -2.147.483.648 a 2.147.489.647 32 bits (4 bytes)</p><p>unsigned long 0 a 4.294.967.295 32 bits (4 bytes)</p><p>float 3.4 x 10-38 a 3.4 x 1038 32 bits (4 bytes)</p><p>double 1.7 x 10-308 a 1.7 x 10308 64 bits (8 bytes)</p><p>long double 3.4 x 10-49328 a 3.4 x 1049328 128 bits (16 bytes)</p><p>Quadro 9 – Todos os tipos dados definidos pelo padrão ANSI. Fonte: adaptado de Schildt (1996).</p><p>Alguns tipos de dados podem variar dependendo do hardware, do compilador e do</p><p>sistema operacional. Por exemplo, o tipo int possui 4 bytes nos computadores mais atuais e,</p><p>consequentente, a mesma faixa de valores de um long.</p><p>Além dos cinco tipos de dados básicos e seus modificadores, a linguagem C possui dois</p><p>tipos especiais de dados: enumeradores e ponteiros.</p><p>Reparamos no Quadro 9 que o tipo char, embora seja para representar caracteres,</p><p>também possui uma faixa de valores. Na verdade, esse tipo armazena o código</p><p>numérico do caractere na tabela ASCII da máquina (DEITEL, 2011). Exemplos:</p><p>• ‘z’ representa o código de z, que é 122;</p><p>• ‘7’ representa o código no número 7, que é 55;</p><p>• ‘\n’ representa o código do caractere de nova linha, que é 10.</p><p>33WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>1</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>3.2 Enumeradores</p><p>De acordo com Deitel (2011, p. 340), “uma enumeração, introduzida pela palavra-chave</p><p>enum, é um conjunto de constantes de enumeração inteiras, representadas por identificadores”.</p><p>Os valores em uma enumeração iniciam em 0 e são incrementados por 1 a cada item</p><p>da lista. Por exemplo: enum semana { DOM, SEG, TER, QUA, QUI, SEX, SAB }; cria uma</p><p>lista com os dias da semana enumerados de 0 a 6. Para iniciar a lista com 1, basta atribui-lo no</p><p>primeiro item, desta forma:</p><p>enum semana { DOM = 1, SEG, TER, QUA, QUI, SEX, SAB };</p><p>Os demais itens serão incrementados com 1 automaticamente, fazendo com que SEG</p><p>valha 2 e SAB valha 7. Depois de declarada, variáveis podem ser criadas usando a enumeração</p><p>como tipo de dado e usando suas constantes como valores.</p><p>3.3 Ponteiros</p><p>Basicamente, um ponteiro é tipo de dado que armazena um endereço de memória.</p><p>Este endereço de memória, por sua vez, pode conter uma variável ou uma função carregada na</p><p>memória (DEITEL, 2011).</p><p>Depois de armazenado um endereço de memória no ponteiro, existe um operador em C</p><p>que permite recuperar:</p><p>• o seu valor, no caso do endereço conter uma variável;</p><p>• o seu código para ser executado, no caso do endereço conter uma função.</p><p>Ponteiros são um dos recursos que tornam a linguagem C mais poderosa em comparação</p><p>a outras linguagens. Por outro lado, é um assunto complexo e que demanda muito entendimento</p><p>e prática para poder ser aplicado com eficiência.</p><p>Abordamos ponteiros neste livro porque são necessários na representação de cadeias de</p><p>caracteres e na passagem de parâmetros por referência a funções. Portanto, esse tipo de dado é</p><p>visto com mais detalhes na Unidade IV.</p><p>34WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>1</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>4 CONSTANTES E VARIÁVEIS</p><p>Os tipos de dados apresentados na seção anterior podem ser representados em um</p><p>programa por meio de constantes ou de variáveis. Segundo Schildt (1996, p. 19), “em C, nomes</p><p>de variáveis, funções, rótulos e vários outros objetos definidos pelo usuário são chamados de</p><p>identificadores”. Eles devem ser formados por letras, números ou o caracter sublinhado “_”, sendo</p><p>que não pode ser iniciado com números e nem coincidir com as palavras reservadas da linguagem.</p><p>O Quadro 10 a seguir mostra alguns exemplos de identificadores válidos e inválidos.</p><p>Válidos Inválidos</p><p>A 2ª (começa com número e possui caracter inválido: “ª”)</p><p>a b@ (possui caracter inválido: “@”)</p><p>Media media idade (possui espaço em branco)</p><p>altura2 x*y (possui caracter inválido: “*”)</p><p>media_idade #media (“#” é para diretivas de pré-processamento)</p><p>x36 1anoComputacao (começa com número)</p><p>NomeAluno break (palavra reservada da linguagem C)</p><p>Quadro 10 – Identificadores válidos e inválidos. Fonte: O autor.</p><p>Vale lembrar que, em C, A não é o mesmo que a: cada um é um identificador distinto. O</p><p>Quadro 11 a seguir lista todas as palavras reservadas – ou palavras-chave – da linguagem, que</p><p>são identificadas pelo compilador para traduzir suas instruções devidamente para a linguagem de</p><p>máquina, e, por isso, não podem ser usadas como identificadores.</p><p>auto do goto signed unsigned</p><p>break double if sizeof void</p><p>case else int static volatile</p><p>char enum long struct while</p><p>const extern register switch</p><p>continue float return typedef</p><p>default for short union</p><p>Quadro 11 – Palavras-chave da linguagem C. Fonte: Deitel (2011).</p><p>4.1 Constantes</p><p>De acordo com Manzano e Oliveira (2012, p. 46), “constante é tudo que é fixo, estável,</p><p>inalterável, imutável, contínuo, incessante, invariável, de valor fixo e que é aplicado em diversos</p><p>pontos de vista”. Xavier (2011, p. 37) complementa que “dentro do algoritmo, constantes são os</p><p>valores que permanecem os mesmos do início ao fim”.</p><p>Existem dois tipos de constantes em C: constantes literais e constantes manifestas. As</p><p>constantes literais são a representação direta de cada dado, enquanto as constantes manifestas são</p><p>esses mesmos dados atribuídos a um identificador por meio do comando const ou da diretiva</p><p>#define (SCHILDT, 1996).</p><p>35WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>1</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>4.1.1 Constantes literais</p><p>O tipo de dado char é representado literalmente de duas formas:</p><p>• Com aspas simples para um caractere, por exemplo: ‘A’, ‘B’, ‘1’, ‘-’, ‘@’ etc.;</p><p>• Com aspas duplas para dois ou mais caracteres, por exemplo: “Uningá”, “B+” etc.</p><p>O tipo de dado int é representado literalmente por números inteiros sem o ponto decimal,</p><p>por exemplo: 25, -481, 2020, 10022018 etc. Os tipos de dados float e double, por sua vez, são</p><p>representados literalmente por números com o ponto decimal, por exemplo: 8.35, +16.789,</p><p>3.1415, -16.44, 0.222222 etc.</p><p>4.1.2 Constantes manifestas</p><p>Segundo Deitel (2011), constantes manifestas criadas com a diretiva de pré-processamento</p><p>#define são automaticamente substituídas pelo seu valor correspondente na fase de pré-</p><p>compilação – vide Fase 2 da Figura 1. A sintaxe para a criação de uma constante com esta diretiva</p><p>é: #define identificador valor.</p><p>Constantes manifestas criadas com o comando const são na verdade variáveis que serão</p><p>instruídas pelo compilador a serem armazenadas no espaço de memória ROM, onde seus valores</p><p>não poderão ser modificados (SCHILDT, 1996).</p><p>O Quadro 12 a seguir ilustra alguns exemplos de definição de constantes com #define e</p><p>const.</p><p>#define PI 3.1415</p><p>#define ANO 2020</p><p>#define IE "Uninga"</p><p>const int TAMANHO = 10;</p><p>const float FATOR = 1.25;</p><p>Quadro 12 – Exemplos de criação de constantes. Fonte: O autor.</p><p>Embora não seja uma regra, é costume nas linguagens de programação declarar constantes</p><p>em maiúsculas, para diferenciar das variáveis que geralmente são criadas em letra minúscula. O</p><p>importante em relação à linguagem C é lembrar que elas devem ser referenciadas exatamente da</p><p>forma como foram criadas.</p><p>Não existe um tipo de dado string em C, como normalmente ocorre em outras linguagens.</p><p>Cadeias de caracteres são na verdade um vetor de elementos do tipo char e possuem</p><p>operadores e funções específicas para serem manipuladas (DEITEL, 2011). Strings são</p><p>abordadas com mais detalhes na Unidade III.</p><p>36WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>1</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>4.2 Variáveis</p><p>Um programa pode receber dados de entrada fornecidos pelo usuário ou efetuar cálculos</p><p>complexos que requerem o armazenamento desses dados na memória para serem recuperados</p><p>posteriormente e até mesmo serem modificados. As variáveis representam uma posição de</p><p>memória com esse propósito. Além do valor armazenado, elas possuem nome e tipo (ASCENCIO;</p><p>CAMPOS, 2012).</p><p>Segundo Schildt (1996, p. 20), “[...] todas as variáveis em C devem ser declaradas antes de</p><p>serem usadas”. A sintaxe para declarar uma variável é:</p><p>tipo lista_de_variáveis;</p><p>Onde o tipo pode ser qualquer um dos tipos de dados abordados, opcionalmente</p><p>acompanhado de modificadores. O Quadro 13 a seguir ilustra alguns exemplos de declaração de</p><p>variáveis.</p><p>int quantidade;</p><p>unsigned int populacao;</p><p>float valor, desconto;</p><p>double total;</p><p>long double cod_barras;</p><p>char sexo;</p><p>char endereco[30];</p><p>Quadro 13 – Declaração de variáveis em C. Fonte: O autor.</p><p>Para armazenar dados em variáveis, utilizamos o operador de atribuição (=). A sintaxe</p><p>para tal finalidade é:</p><p>identificador = expressão;</p><p>Onde identificador é o nome da variável previamente declarada, e expressão, o valor de</p><p>acordo com o tipo da variável. O Quadro 14 a seguir ilustra algumas atribuições</p><p>de valores às</p><p>variáveis declaradas no Quadro 13.</p><p>quantidade = 12;</p><p>populacao = 35000;</p><p>valor = 35.60;</p><p>desconto = 10;</p><p>total = quantidade * valor;</p><p>total = total – (total * desconto / 100);</p><p>cod_barras = 7891237791212;</p><p>sexo = 'F';</p><p>endereço = "Avenida Brasil, 2855";</p><p>Quadro 14 – Exemplos de atribuição. Fonte: O autor.</p><p>Para atribuir o mesmo valor a várias variáveis de uma vez, utilizamos o recurso da atribuição</p><p>múltipla. Por exemplo, x = y = z = 0; atribuirá o valor zero às variáveis x, y e z (SCHILDT, 1996).</p><p>É possível também atribuir um valor no momento da declaração da variável. Por exemplo,</p><p>int opcao = 1; fará com que a variável opcao possua o valor inicial de 1, podendo este ser alterado</p><p>a qualquer momento no programa. Para isso, basta fazer uma nova atribuição e o novo valor</p><p>substituirá o anterior na memória. Variáveis declaradas sem atribuição de valor são inicializadas</p><p>com valores aleatórios, dependendo do compilador C; portanto, é importante sempre atribuir</p><p>valores a elas.</p><p>37WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>1</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>Alguns exemplos do Quadro 14 utilizam cálculos aritméticos e as próprias variáveis</p><p>criadas como parte da expressão a ser calculada. Abordamos os operadores disponíveis em C na</p><p>seção seguinte.</p><p>5 EXPRESSÕES E OPERADORES</p><p>Segundo Sebesta (2011, p. 342), “[...] expressões são os meios fundamentais de especificar</p><p>computações em uma linguagem de programação”. São um conjunto de operadores e operandos</p><p>que geram um resultado a ser utilizado no processamento de um programa.</p><p>Existem três tipos de expressões em C: aritméticas, relacionais e lógicas. Detalhamos cada</p><p>tipo nas seções seguintes, juntamente com os seus operadores.</p><p>5.1 Expressões Aritméticas</p><p>Expressões aritméticas são aquelas em que o resultado consiste em um valor numérico.</p><p>Portanto, podem ser utilizados em expressões desse tipo apenas operadores aritméticos, constantes</p><p>numéricas e variáveis numéricas – do tipo int, float, double e derivados.</p><p>O Quadro 15 a seguir apresenta os operadores aritméticos fornecidos pela linguagem C.</p><p>Operação Operador Exemplo</p><p>Soma + vencimento + 30</p><p>Subtração - elementos – 1</p><p>Multiplicação * quantidade * preco</p><p>Divisão / soma_notas / 4</p><p>Resto da divisão % número % 2</p><p>Quadro 15 – Operadores aritméticos. Fonte: Adaptado de Deitel (2011).</p><p>Esses operadores seguem a regra de precedência da matemática. Portanto, em uma</p><p>expressão contendo vários operadores, são calculadas primeiramente as multiplicações, divisões</p><p>e o resto; em seguida, são calculadas as somas e subtrações. Parênteses podem ser usados para</p><p>alterar essa ordem.</p><p>De acordo com Deitel (2011, p. 64), “C oferece vários operadores de atribuição que</p><p>abreviam as expressões de atribuição. Por exemplo, a instrução c = c + 3; pode ser abreviada com</p><p>o operador de atribuição com adição += para c += 3;”. Existe um operador de atribuição para</p><p>cada operador aritmético da linguagem C, conforme apresentado no Quadro 16 a seguir.</p><p>Operador Exemplo Equivalente a</p><p>+= x += y; x = x + y;</p><p>-= x -= y; x = x - y;</p><p>*= x *= y; x = x * y;</p><p>/= x /= y; x = x / y;</p><p>%= x %= y; x = x % y;</p><p>Quadro 16 – Operadores de atribuição. Fonte: Adaptado de Deitel (2011).</p><p>38WWW.UNINGA.BR</p><p>AL</p><p>GO</p><p>RI</p><p>TM</p><p>OS</p><p>E</p><p>P</p><p>RO</p><p>GR</p><p>AM</p><p>AÇ</p><p>ÃO</p><p>A</p><p>PL</p><p>IC</p><p>AD</p><p>A</p><p>| U</p><p>NI</p><p>DA</p><p>DE</p><p>1</p><p>EDUCAÇÃO A DISTÂNCIA</p><p>C também oferece os operadores de incremento (++) e decremento (--), que somam ou</p><p>subtraem 1, respectivamente, do seu operando. Eles são unários e podem ser usados como prefixo</p><p>ou sufixo da variável a ser alterada; contudo, possuem comportamento diferente, segundo Schildt</p><p>(1996):</p><p>• Se precederem a variável, alteram-na antes de usá-la na expressão;</p><p>• Se estiverem após a variável, usam seu valor atual na expressão antes de alterá-la.</p><p>O Quadro 17 a seguir ilustra alguns exemplos dos operadores de atribuição, incremento</p><p>e decremento.</p><p>int v1, v2, v3;</p><p>v1 = 10;</p><p>v2 = 5;</p><p>v1 += v2; // v1 = 15</p><p>v3 = ++v1 + v2; // v3 = 16 (incrementou v1 antes)</p><p>v3 = v1 + v2++; // v3 = 16 (incrementou v2 depois)</p><p>v1 -= 7; // v1 = 9</p><p>v2 *= 3; // v2 = 18</p><p>v3 /= 4; // v3 = 4</p><p>Quadro 17 – Operadores de atribuição, incremento e decremento. Fonte: O autor.</p><p>5.2 Expressões Relacionais</p><p>As expressões relacionais referem-se à comparação entre dois valores de um tipo básico;</p><p>a isso chamamos de condição, e o seu resultado consiste em um valor lógico verdadeiro ou falso.</p><p>Segundo Deitel (2011, p. 32), “[...] em C, uma condição pode ser, realmente, qualquer expressão</p><p>que resulte em um valor zero (falsa) ou diferente de zero (verdadeira)”.</p><p>O Quadro 18 a seguir apresenta os operadores relacionais da linguagem C.</p><p>Operador Símbolo Exemplo</p><p>Igual == a == 1</p><p>Diferente != a != b</p><p>Maior que > a > 5</p><p>Menor que = a >= 6</p><p>Menor ou igual a</p>valor 120, afinal: 5! = 5 x 4 x 3 x 2 x 1 = 120. No caso da versão à direita, cada chamada 
da função fatorial() ocorre de forma a empilhar cada uma de suas instâncias em operação para 
depois, no retorno, efetuar a multiplicação sucessiva, calculando assim o fatorial solicitado. Essa 
lógica é ilustrada na Figura 7 a seguir.
Figura 7 – Esquema lógico da função de fatorial. Fonte: Adaptado de Manzano e Oliveira (2012).
133WWW.UNINGA.BR
AL
GO
RI
TM
OS
 E
 P
RO
GR
AM
AÇ
ÃO
 A
PL
IC
AD
A 
 | U
NI
DA
DE
 4
EDUCAÇÃO A DISTÂNCIA
Outro exemplo muito comum de recursividade é a Sequência de Fibonacci, que começa 
com 0,1 e a partir daí cada termo subsequente corresponde à soma dos dois anteriores, compondo 
assim a seguinte sequência: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55 etc. (BACKES, 2016). O Quadro 22 a 
seguir ilustra um programa que pede a posição da sequência e retorna o valor correspondente 
usando a função recursiva fibonacci().
#include <stdio.h>
int fibonacci(int x) {
 if (x == 0 || x == 1)
 return x;
 else
 return fibonacci(x-2) + fibonacci(x-1);
}
int main(void) {
 int num;
 printf(“Digite um numero inteiro: “);
 scanf(“%d”, &num);
 
 printf(“O fibonacci na posicao %d eh: %d\n”, num, fibonacci(num));
 return 0;
}
Quadro 22 – Função recursiva que retorna o número da sequência de Fibonacci. Fonte: Adaptado de Backes (2016).
Segundo Manzano e Oliveira (2012), a recursividade tem uma vantagem e uma 
desvantagem em programação. A vantagem é que esse processo torna o código mais elegante, 
facilitando a abstração e a modularidade no desenvolvimento de funções que podem ser 
complexas. A desvantagem é o efeito de empilhamento provocado, que pode consumir um espaço 
de memória considerável do computador.
No exemplo do programa de Fibonacci, quanto mais alta for a posição do número da 
sequência que se deseja saber, maior será o processamento e o consumo de memória para efetuar 
os cálculos recursivos.
Programação em C/C++ - Aula 54 - Torre de Hanoi (Recursiva)
Mais um exemplo interessante de recursividade. O vídeo explica 
o desafio do quebra-cabeça e uma solução recursiva utilizando a 
linguagem C++.
Disponível em: https://www.youtube.com/watch?v=X-I53cLjidg
134WWW.UNINGA.BR
AL
GO
RI
TM
OS
 E
 P
RO
GR
AM
AÇ
ÃO
 A
PL
IC
AD
A 
 | U
NI
DA
DE
 4
EDUCAÇÃO A DISTÂNCIA
CONSIDERAÇÕES FINAIS
Nesta unidade, foram abordados os conceitos da modularização de programas e 
da importância de suas aplicações, como por exemplo o reaproveitamento de código e o 
desenvolvimento de rotinas genéricas.
Iniciamos a unidade abordando as sub-rotinas, que podem ser classificadas em 
procedimentos e funções. A diferença está em que as funções retornam valor e os procedimentos 
não retornam nada. Em C, as sub-rotinas são implementadas apenas por meio de funções, portanto 
abordamos como funções são declaradas e escritas nos programas. Explicamos como funciona 
a prototipagem de funções e como os valores retornados por elas são usados nas expressões da 
função chamadora.
Em seguida, abordamos o escopo de variáveis, explicando a diferença entre variáveis locais 
e globais, e destacando a importância de priorizar o uso de variáveis locais no desenvolvimento 
de programas. Também abordamos as classes de variáveis estáticas, externas e de registro, 
particulares da linguagem C.
Prosseguimos detalhando o recurso de ponteiros da linguagem C e como são importantes 
na passagem de parâmetros, assunto seguinte abordado, onde explicamos a diferença entre a 
passagem por valor e por referência. Concluímos a unidade abordando o conceito de recursividade, 
com alguns exemplos de uso.
Chegamos, enfim, ao final da disciplina de Algoritmos e Programação Aplicada. Com o 
conteúdo aprendido aqui, espera-se que o discente tenha o conhecimento básico dos principais 
recursos que compõem a lógica de programação e possa partir para o descobrimento de novas 
plataformas, ferramentas e linguagens que venham aprimorar esse conhecimento.
135WWW.UNINGA.BR
ENSINO A DISTÂNCIA
REFERÊNCIAS
ASCENCIO, A. F. G.; CAMPOS, E. A. V. Fundamentos da programação de computadores: 
Algoritmos, Pascal, C/C++. 3. ed. São Paulo: Prentice Hall, 2012.
BACKES, A. R. Estrutura de dados descomplicada: em linguagem C. Rio de Janeiro: Elsevier, 
2016.
DEITEL, P. J. C: como programar. Tradução de Daniel Vieira. 6. ed. São Paulo: Pearson Prentice 
Hall, 2011.
DIBBLE, J. UNIVAC/ERA 1101: primeiro computador da história que rodava um programa 
da memória. 2021. Disponível em: https://sites.google.com/site/byjessicadibble/home/abacus/
difference-engine/z1/colossus/abc/edsac/electronic-controls-company/univac-1101-era-1101. 
Acesso em: 9 set. 2021.
FORBELLONE, A. L. V.; EBERSPACHER, H. F. Lógica de Programação: a construção de 
algoritmos e estruturas de dados. 3. ed. São Paulo: Prentice Hall, 2005.
GERAÇÕES DE COMPUTADORES. Exemplo de um computador de quinta geração. 2021. 
Disponível em: https://geracoesdecomputadores.files.wordpress.com/2011/08/imac.png. Acesso 
em: 9 set. 2021.
GUEDES, S. Lógica de programação algorítmica. São Paulo: Pearson Education do Brasil, 2014.
LOPES, A.; GARCIA, G. Introdução à Programação: 500 Algoritmos Resolvidos. Rio de Janeiro: 
Elsevier, 2002.
MANZANO, A. L. N. G.; MANZANO, M. I. N. G. Estudo Dirigido de Informática Básica. São 
Paulo: Saraiva, 2009. 
MANZANO, J. A. N. G.; OLIVEIRA, J. F. Algoritmos: Lógica para Desenvolvimento de 
Programação de Computadores. 26. ed. São Paulo: Érica, 2012.
MICROSOFT DOCS. foreach, in (Referência em C#). 2019. Disponível em: https://docs.
microsoft.com/pt-br/dotnet/csharp/language-reference/keywords/foreach-in. Acesso em: 29 
dez. 2019.
PRESSMAN, R. S. Engenharia de Software. 7. ed. São Paulo: Makron, McGraw-Hill, 1995.
SCHILDT, H. C Completo e Total. Tradução de Roberto Carlos Mayer. 3. ed. São Paulo: Makron 
Books, 1996.
SEBESTA, R. W. Conceitos de linguagens de programação. Tradução de Eduardo Kessler Piveta. 
9. ed. Porto Alegre: Bookman, 2011.
SINTES, A. Aprenda Programação Orientada a Objetos em 21 dias. São Paulo: Pearson 
Education do Brasil, 2002.
https://sites.google.com/site/byjessicadibble/home/abacus/difference-engine/z1/colossus/abc/edsac/electronic-controls-company/univac-1101-era-1101.
https://sites.google.com/site/byjessicadibble/home/abacus/difference-engine/z1/colossus/abc/edsac/electronic-controls-company/univac-1101-era-1101.
https://geracoesdecomputadores.files.wordpress.com/2011/08/imac.png.
136WWW.UNINGA.BR
ENSINO A DISTÂNCIA
REFERÊNCIAS
SOUZA, M. F. F. Computadores e sociedade: da filosofia às linguagens de programação. Curitiba: 
InterSaberes, 2016.
TANENBAUM, A. S. Organização estruturada de computadores. 6. ed. São Paulo: Pearson 
Prentice Hall, 2013.
TUCKER, A. B.; NOONAN, R. E. Linguagens de programação: Princípios e Paradigmas. 
Tradução de Mario Moro Fecchio. 2. ed. Porto Alegre: AMGH, 2010.
VILARIM, G, O. Algoritmos: Programação Para Iniciantes. 3. ed. Rio de Janeiro: Ciência 
Moderna, 2017.
WIKIWAND. Intel 8008, 1972 - primeiro microprocessador de 8 bits. 2021. Disponível em: 
https://www.wikiwand.com/pt/Microprocessador. Acesso em: 9 set. 2021.
XAVIER, G. F. C. Lógica de Programação. 12. ed. São Paulo: Senac, 2011.
https://www.wikiwand.com/pt/Microprocessador.