Programação em Linguagem C para quem tem pressa.

Por: Flávio Ferry de Oliveira Moreira, MSc.

Sumário
Prólogo .......................................................................................................................................... 3
Introdução ..................................................................................................................................... 3
Cap.1 – Motivação para programar .............................................................................................. 3
Preparando o Computador para Programar ............................................................................. 3
Como funciona um computador? ............................................................................................. 4
Cap. 2 – Comando de Saída ........................................................................................................... 4
Cap. 3 – Comandos de Entrada ..................................................................................................... 6
Cap. 4 – Comando de Decisão ....................................................................................................... 9
Cap. 5 – Laços de Repetição ........................................................................................................ 11
Cap. 6 – Seleção múltipla (caso).................................................................................................. 13
Cap. 7 – Boa conduta de programação ....................................................................................... 15
Cap. 8 – Variáveis homogêneas (vetores) ................................................................................... 16
Cap. 9 – Funções criadas pelo usuário ........................................................................................ 19
Cap. 10 – Registros (struct) ......................................................................................................... 20
Epílogo ......................................................................................................................................... 22

Página: 2
Prólogo
Este material é dedicado aos meus filhos Flávio José e Aline Maria, que me viram
ensinando programação em forma remota, durante um ano de pandemia e me pediram
para aprender a programar também.

Introdução
Este material é destinado para aqueles curiosos que desejam programar um
computador. Vamos mostrar as bases da lógica básica de programação já fazendo a
ponte com a prática usando a poderosa Linguagem C, nesta versão do material, usamos
sistema operacional Windows e ambiente Falcon C/C++, que é um ambiente de
programação gratuito, prático e leve. Muito fácil de ser baixado na Internet. Em um futuro
próximo faremos uma adaptação deste material para os usuários de Linux.

Cap.1 – Motivação para programar

No dia a dia temos a necessidade de passar instruções para outras pessoas o tempo
todo. Em alguns momentos nós é que recebemos estas instruções. Veja que um manual
de um eletrodoméstico, a sequência de passos para fazer uma comida, ou as instruções
para chegar a um destino são exemplos claros do que chamamos em computação de
ALGORITMO.
Instruções feitas em uma linguagem que seja compreensível por quem as recebe são
suficientes para realizamos uma nova tarefa, fazer um novo produto ou algo antes que
você não sabia.
Exemplo – Como fazer pipoca
1. Arranje uma porção de milho para pipoca;
2. Em uma panela que tenha tampa ponha o tanto de milho que cubra o fundo;
3. Adicione um pouco de óleo sobre o milho, sem exagerar;
4. Ponha a panela agora tampada sobre a chama do fogão (use alta para começar);
5. Aos primeiros estouros do milho, baixe a chama do fogo, abra um pouco a tampa
e volte a fechar;
6. Sacuda a panela fechada para movimentar o milho e a pipoca;
7. Ao diminuir a frequência dos estouros apague a chama, abra um pouco a panela
adicionando sal a gosto ou manteiga ou o que quiser, feche e sacuda novamente
a panela;
8. Coma a pipoca.
Esta receita acima dá certo em mais de 100% dos casos.

Preparando o Computador para Programar

Vamos na Internet e acesse endereço: https://sourceforge.net/projects/falconcpp/
Clique em Download, salve o arquivo em seu computador, faça dois cliques para realizar
a instalação na base do avançar e concluir. É super seguro, gratuito e sem perigos. Os
usuários de alguns antivírus podem ter falsos alertas de contaminação ao gerarem seus
programas em C, neste caso, informe ao antivírus que o programa é seguro.

Página: 3
Como funciona um computador?
Todo computador funciona baseado na arquitetura proposta por John Von Newmann,
ainda nos anos 50 do século XX. Onde existe uma caixa que faz a ENTRADA e outra
que recebe a SAÍDA, no meio temos a Unidade Central de Processamento – UCP (CPU
em Inglês). Veja a figura abaixo para melhor entendimento.

Figura 1 – Arquitetura Base de Von Newmann

Então nossos algoritmos devem levar em conta o projeto do computador, devemos
estudar comandos para ENTRADA, PROCESSAMENTO e SAÍDA.
Fazendo este entendimento, fica fácil instruirmos nosso computador como se fosse um
amigo, que vai aprender algo que sabemos, através de uma sequência finita de passos
claros e diretos.

Cap. 2 – Comando de Saída

Vamos dizer para o computador fazer algo como: ESCREVA (“Alô Mundo! ”); assim
esperamos que o computador deve entender que vai escrever a frase entre aspas na
tela.
No seu computador, execute o Falcon através do ícone do programa. A tela seguinte
deve se apresentar para você.

Página: 4
 Figura 2 – Tela Inicial do Falcon C/C++
No menu ARQUIVO clique em NOVO, aponte e clique em ARQUIVO C. Sempre
começaremos nossos algoritmos assim. Um espaço de edição de textos será
apresentado à direita da tela. Nesta área, digite os comandos a seguir, com cuidado
para não esquecer de nenhum símbolo.
#include <stdio.h>
int main (){
printf("Alo Mundo!");
return 0;
}

Agora clique no botão que tem esta aparência ou se preferir acione a tecla F9 no
teclado. Seu primeiro programa será executado em uma tela preta e terá o aspecto da
próxima figura.

Figura 3 – Tela de resultado de seu programa.

Página: 5
Vamos às explicações: Nosso programa começa com um comando de #include
<stdio.h> este comando serve para adicionar aos nossos programas os comandos
básicos de entrada e saída da linguagem. Os comandos de todos os programas são
organizados em blocos começados com { e terminados com }. Nossos programas são
organizados em funções sendo que sempre teremos a main() de uso obrigatório. No
caso de nosso exemplo temos int main() { (...) }. O comando central do programa é
printf que equivale ao escreva de nosso texto anterior. No último comando do nosso
programa temos um return 0; que diz ao Windows o seguinte: “Fiz o que meu
programador mandou e deu tudo certo, não se preocupe”.
Cuidado! não troque o zero do return, que é código de sucesso, por outro número
qualquer, você pode danificar seriamente os demais programas de seu computador.

IMPORTANTE: a linguagem C diferencia maiúsculas e minúsculas, sempre digite os

comandos da maneira que os encontrar na literatura ou nos sites de referência.
Predominantemente serão em letras minúsculas.

Dica final do comando de saída: a linguagem C tem umas “letras” especiais para fazer
alguns truques com o que escrevemos em um printf. Devemos usá-las em meio às
frases que escrevemos entre as aspas. Temos as mais úteis mostradas na tabela a
seguir:
Caractere especial O que faz?
\n Salta para a próxima linha
\t Faz um salto de tabulação como se fosse a tecla →|
\b Retrocesso do cursor
\” Escreve aspas na tela
\\ Escreve \ na tela

Por fim, tente refazer nosso exemplo desta seção com outra frase e use os caracteres
da tabela acima para ver o efeito de cada um deles.
Cada novo programa criado pode e deve ser salvo em um arquivo separado com o uso
do botão e dando um nome que lembre a você facilmente do conteúdo do programa
criado.
Um novo programa requer um arquivo novo, tipo C.

Cap. 3 – Comandos de Entrada

Lembrando da Figura 1, devemos saber que para realizarmos uma entrada no
programa, devemos ao menos usar a memória interna do computador para armazenar
o que foi entrado. Ainda é possível, com o dado entrado e memorizado, usar o
processamento realizado pela CPU. Para tanto a ferramenta de programação será
chamada por nós de variável.
Toda variável tem um nome que a identifica, este nome deve ser dado de acordo com
a função da mesma no seu programa. Pode usar palavras em português, dê preferência
a nomes intuitivos e com letras minúsculas.

Página: 6
Variáveis precisam ter um tipo associado para assim armazenar corretamente números
ou letras, cada um com suas possibilidades de processamento. Neste material
trabalharemos com três tipos básicos: números inteiros, números reais e letras.
Na linguagem C temos:

• Números Inteiros → int

• Números Reais → float
• Letras → char
Existem vários outros tipos, mas nesta etapa básica de programação, estes nos bastam.
Sendo assim, nosso comando de entrada que fará algo como LEIA (variável_inteira);
usará sempre uma variável para armazenar aquilo que a pessoa que usará seu
programa irá digitar. O Comando que fará esta função será o scanf, que deverá ser
usado nas variáveis numéricas em geral, pois no caso de letras existe um bug que será
discutido em seções posteriores deste material.
Vejamos nosso primeiro exemplo com entrada de valor numérico.
#include <stdio.h>
int main (){
int numero, outro;
printf("Programa para somar dois inteiros \n\n");
printf("Digite o primeiro valor: ");
scanf("%d",&numero);
printf("Digite o segundo valor: ");
scanf("%d",&outro);
printf("\n\nO resultado da soma: %d\n\n",numero+outro);
return 0;
}

Salve este exemplo e execute com F9.

Agora vamos às explicações: O comando de entrada scanf precisa de alguns cuidados
especiais: entre aspas é usado um símbolo de % e uma letra que indica o tipo da
variável que será usada. Em seguida da última aspa da sequência o símbolo & deve
preceder o nome da variável. O significado é, por exemplo, %d – leia um inteiro -
&numero – e o armazene DENTRO da variável número. Abaixo listamos uma tabela
onde são resumidos os códigos de tipos de variáveis usados em comandos de entrada
(scanf) e saída (printf).

Comando Tipo de Variável

%d Inteiro
%f Float (ou real)
%c Uma Letra
%s Uma palavra (aqui mora o bug do scanf)
Obs.: Entre o % e o f das variáveis float, durante o uso de printf, podemos usar números
como x.y onde x será a quantidade de casas da parte inteira do número e y será a
quantidade de casas decimais do mesmo.
Deixamos ao leitor a missão de procurar fazer programas para outros cálculos como:

Página: 7
 • Área de uma sala retangular;
• Volume de uma caixa d’água cúbica;
• O preço de um produto com um desconto aplicado.
Uma tabela a mais é apresentada a seguir com os símbolos das principais operações
matemáticas básicas:
Símbolo O que faz?
+ Soma
- Subtração
* Multiplicação
/ Divisão
% Resto da Divisão
= Atribuição – Usado para guardar em uma variável o resultado de uma
operação.
== Igualdade – Usado para testar igualdade de valores em uma
comparação.

Se o resultado da divisão for guardado por atribuição em uma variável inteira, será
apenas o quociente inteiro a ser guardado. Se este armazenamento é feito em variável
float, será feita a divisão decimal a mais aproximada possível. Veremos isto no nosso
próximo exemplo.
#include <stdio.h>
int main (){
int numero, outro, quo, resto;
float resultado;
printf("Programa para dividir dois numeros. \n\n");
printf("Digite o primeiro valor: ");
scanf("%d",&numero);
printf("Digite o segundo valor: ");
scanf("%d",&outro);
quo=numero/outro;
resultado=(float)numero/(float)outro;
resto=numero%outro;
printf("\n\nOs resultados obtidos\n\n");
printf("Quociente: %d Resto: %d Resultado da Divisao: %f
\n\n",quo,resto,resultado);
return 0;
}
➔Um detalhe a penúltima linha é o printf final, ficou quebrada em duas por questão de
tamanho de papel e margem, mas no Falcon deve ficar em uma linha só.
Observe na Figura 4 a seguir, o resultado deste nosso novo exemplo.

Página: 8
 Figura 4 – Resultado do algoritmo das formas de divisão na linguagem C.

Cap. 4 – Comando de Decisão

Uma funcionalidade importante na programação de computadores é fazer testes de
valores, comparações de variáveis e valores para tomar decisões de comandos e rumos
do programa.
O comando usado para esta funcionalidade é o SE --- ENTÃO --- SENÃO. Vamos a um
caso prático:
Instruções para solução de problemas – Controle remoto sem funcionar
1. Verifique a distância sua até o aparelho, não pode ser muito longe;
2. Se estiver há mais de 5 metros então fique mais próximo;
3. Senão estando próximo e mesmo assim o controle não funciona, troque as
pilhas e tente novamente;
4. Caso não resolva procure uma assistência técnica.
Na linguagem C usa-se o comando if (condição) ---- else ----. Queremos chamar a
atenção para a condição que pode ser simples ou composta.
Na condição simples fazemos a comparação de uma variável com um valor ou uma
variável com outra, os símbolos de comparação envolvem as operações resumidas na
tabela a seguir.

Símbolo Operação de Comparação

== IGUALDADE
!= DIFERENTE
< MENOR QUE
<= MENOR OU IGUAL
> MAIOR QUE
>= MAIOR OU IGUAL
! NEGAÇÃO

Vamos ver um exemplo de comparação com condição simples. Imagine que tem que
fazer um programa para calcular o preço de um produto a ser revendido, onde o

Página: 9
acréscimo será de 45% se o preço de custo for abaixo de R$ 20,00. E o preço de
revenda será 30% a mais que o de custo no caso contrário.
#include <stdio.h>
int main()
{
float valor_produto;
printf("Informe o valor do produto: ");
scanf("%f", &valor_produto);
if (valor_produto < 20)
printf("O valor da venda eh %3.2f\n", valor_produto * 1.45);
else
printf("O valor da venda eh %3.2f\n", valor_produto * 1.30);
return 0;
}

Vamos agora falar da condição composta. Muitas vezes duas ou mais comparações
precisam ser feitas ao mesmo tempo e no mesmo if. Entre uma e outra condição
precisamos usar um conector lógico. A parte positiva do SE será executada ou não de
acordo com o resultado desta operação lógica. Os principais conectores são E, OU e
NÃO. Existem outros porém de uso mais avançado. Novamente apresentamos uma
tabela a seguir com os usos de cada conector.

OPERAÇÃO SIMBOLO EM C EXECUTA O POSITIVO QUANDO...

E && AS DUAS COMPARAÇÕES SÃO
VERDADEIRAS
OU || AO MENOS UMA DAS DUAS
COMPARAÇÕES É VERDADEIRA
NÃO ! TESTA O INVERSO DO RESULTADO DA
COMPARAÇÃO

Vejamos um exemplo agora com teste de condição composta. Vamos testar a

temperatura de conservação de um produto que deve ficar entre 5 e 12 graus Celsius.
#include <stdio.h>
int main (void)
{
float limite_min = 5.0 , limite_max = 12.0, temperatura ;

printf("Informe o valor da temperatura: ");

scanf("%f", &temperatura);

if (temperatura <= limite_max && temperatura > limite_min)

printf("Temperatura OK \n");
else
printf("Alerta: Temperatura fora da faixa permitida!!! \n");

return 0;
}

Página: 10
Vamos falar das explicações: nosso programa começa definindo os limites aceitos de
mínimo e máximo através de atribuições. A temperatura lida é a obtida pelo usuário. O
if faz o teste dos limites e informa o resultado do teste.

ATENÇÃO: Em todos os casos de if --- else, tendo mais de um comando dentro

da parte positiva (if) ou da parte negativa da condição (else) o uso de { antes do
primeiro comando e } após o último será OBRIGATÓRIO, para formar assim um
bloco.

Cap. 5 – Laços de Repetição

Realizar tarefas repetitivas é quase um sinônimo de usar computador. Muitos de seus
programas precisarão fazer tarefas repetitivas, por uma quantidade determinada ou não.
Os laços usados em programação são: PARA, ENQUANTO e REPITA. Cada um tem
suas características próprias, o laço PARA tem mais automatismo e é usado quando se
tem a noção exata de quantas vezes será repetido. O ENQUANTO será usado quando
o automatismo do PARA não for tão necessário e finalmente o REPITA é comumente
usado quando o programador não tem noção de quantas vezes o laço será repetido,
isto tem cara de MENU de programa, mas com certeza, este será assunto de um
capítulo futuro.
Na linguagem C vamos mostrar como se resume e se escreve cada laço destes:
PARA

for (<var=inicio>; <condição de parada>; <comando de aumento ou diminuição de var>) {

---- Comados do laço ---

ENQUANTO

while (condição de repetição) {

---- Comados do laço ---

comando de contagem;

REPITA

do{

---- Comados do laço ---

comando de contagem (se necessário);

}while(condição de parada);

Vamos a um exemplo, que será repetido com cada laço. Programa para contar até 100.

Página: 11
Laço for

#include <stdio.h>
int cont;
int main(){
printf ("Programa para contar ate 100.\n\n");
for(cont=1;cont <=100;cont++){
printf(" %d",cont);
}
printf("\nTerminou...\n\n");
return 0;
}
Laço while
#include <stdio.h>
int cont;
int main(){
printf ("Programa para contar ate 100.\n\n");
cont=1;
while(cont <=100){
printf(" %d",cont);
cont++;
}
printf("\nTerminou...\n\n");
return 0;
}
Laço do...while
#include <stdio.h>
int cont;
int main(){
printf ("Programa para contar ate 100.\n\n");
cont=1;
do{
printf(" %d",cont);
cont++;
}while(cont <=100);
printf("\nTerminou...\n\n");
return 0;
}
Veja que o resultado de cada exemplo é quase o mesmo, dentro da Ciência da
Computação existem pesquisas onde, dentre outras coisas, são estudadas as
diferenças de execução dentro da CPU do computador de cada um destes laços,
indicando precisamente qual o melhor para trabalhos realmente grandes de
processamento.
Tente fazer exemplos com necessidades de repetição, dentre os quais sugerimos:

• Somar várias parcelas até a pessoa digitar ZERO;

• Ler duas notas (float) e calcular a média aritmética de 3 alunos.

Página: 12
Cap. 6 – Seleção múltipla (caso)
Muitas vezes um simples SE --- SENÃO não é suficiente para testar tantos valores que
uma variável pode assumir. Alguém pode ter a ideia ruim de colocar um novo SE dentro
de um SENÃO, porém este aninhamento é muito ruim para a legibilidade do programa
e sua manutenção futura.
Esta estrutura de programação é conhecida como caso, onde cada caso possível de
valor para a variável pode ser tratado individualmente pelo programador. Em C usam-
se dois comandos em conjunto switch e case. Vamos acompanhar alguns exemplos a
seguir:
Vamos testar vários casos de uma variável inteira de 1 a 7, dando a cada valor lido um
dia da semana como significado.
#include <stdio.h>
int main ()
{
int valor;

printf ("Digite um valor de 1 a 7: ");

scanf("%d", &valor);

switch ( valor )
{
case 1 :
printf ("Domingo\n");
break;

case 2 :
printf ("Segunda\n");
break;

case 3 :
printf ("Terca\n");
break;

case 4 :
printf ("Quarta\n");
break;

case 5 :
printf ("Quinta\n");
break;

case 6 :
printf ("Sexta\n");
break;

case 7 :
printf ("Sabado\n");
break;

default :
printf ("Valor invalido!\n");
}

Página: 13
 return 0;
}

Explicando o exemplo: o comando switch faz a seleção da variável que será tratada
nos casos. Cada caso de valor tem seus comandos listados, sendo cada um
obrigatoriamente finalizado pelo comando break, se este comando for omitido o caso
seguinte será executado também e seu programa terá um comportamento errado. Um
último caso chamado default pode ser usado para tratar de casos não previstos nos
comandos acima.
Vamos agora criar um programa com menu em modo texto, onde o usuário deve digitar
sua opção em forma de número.
#include <stdio.h>
int opc;
int main(){
printf("Programa para mostrar o uso do switch...case. \n\n");
do{
printf("\n Digite 1 para a PRIMEIRA opcao, 2 para a SEGUNDA e 3
para SAIR. ");
scanf("%d",&opc);
switch(opc){
case 1: {
printf("\n\n Primeira Opcao Selecionada...");
break;
}
case 2: {
printf("\n\n Segunda Opcao Selecionada...");
break;
}
case 3: {
printf("\n\n SAINDO...");
break;
}
default:{
printf("\n Opcao Invalida.");
break;
}
}
}while(opc!=3);
return 0;

Este é um exemplo clássico e simples de menu, usamos um laço que vai repetir os
comandos de menu até que o usuário comande a saída do programa. Cada caso de
menu pode ser programado para ativar uma funcionalidade diferente, como nosso
exemplo é simplificado, apenas mostramos uma frase.

Página: 14
Cap. 7 – Boa conduta de programação
Já apresentamos algumas dicas de boas práticas de programação até agora, mas
devido ao ponto chegado este é o momento de fazer um apanhado geral de boas
condutas de programação onde trabalharemos dentro de padrões corretos, evitando
perder tempo com desorganização e até mesmo fazer feio em um ambiente de trabalho
onde se programe computadores. Estas dicas valem para qualquer linguagem, mas
focaremos no caso específico da linguagem C.
Regra 01 → Variáveis e funções devem ser nomeadas de acordo com seus papeis
dentro do programa. Resista a tentação de nomear as variáveis de seu programa como
X1 e X2 ou Caju e Cajá, isto pode tornar impossível você lembrar depois para que elas
servem, se daqui a alguns anos você precisar revisar este programa certamente perderá
muito tempo para lembrar pra que serve cada variável.
Regra 02 → Use identação. Este espaço que damos ao começar um bloco de comandos
e o Falcon procura preservar, pode parecer um detalhe bobo, mas ajuda muito a separar
quais comandos estão trabalhando juntos. Por exemplo, os comandos de um if, um laço
ou de um case devem ficar no mesmo nível para serem melhor lidos no futuro ou por
outro programador.
Regra 03 → Ao salvar seus algoritmos não use espaço no nome do arquivo, isto pode
confundir o compilador, o programa que transforma seu texto em bits a serem
executados pela CPU, seu texto pode mandar fazer uma coisa, mas tem outro arquivo
com nome parecido sendo executado no lugar.
Regra 04 → Use comentários. Estes são pequenos textos que podem ser inseridos em
seu programa sem ser comandos para o computador. São úteis para identificar quem
fez alterações no programa e para que serve determinado trecho. Em alguns casos
comentários são usados para isolar determinada área do programa que está dando bug,
para testar como seria este sem este trecho.
Comentários em linguagem C
Para várias linhas faça assim:
/* Um texto a ser considerado por pessoas mas não para o computador,
pode ser de várias linhas. E será finalizado por */

Já o comentário do tipo:
// Anotação até o fim da linha. O programa continua na próxima linha.

Comentários de várias linhas são muito usados para cabeçalhos de programas. As

empresas geralmente têm um padrão de cabeçalho.

Página: 15
Cap. 8 – Variáveis homogêneas (vetores)
Este tipo de variável é bem interessante quanto se faz necessário trabalhar com várias
variáveis do mesmo tipo e ao mesmo tempo. Torna possível implementar matrizes da
matemática (neste nível trataremos apenas as unidimensionais, mas pode ser estendido
o entendimento para várias dimensões, cada uma com seu laço de acesso). Se o vetor
for feito de char (letras) temos finalmente programas para ler nomes ou frases, as
chamadas STRINGS na programação.
Uma curiosidade: quando a palavra tem significado é chamada de WORD, mas quando
não precisa ter necessariamente significado (uma senha é o exemplo mais claro disso),
é chamada de STRING.
Na memória fica conforme representado na figura 5 a seguir:
Mapa de Memória do Computador
Posição 0 Posição 1 Posição 2 Posição 3
DADO DADO DADO DADO
ARMAZENADO ARMAZENADO ARMAZENADO ARMAZENADO

{
{

{
{

ESPAÇO DE ESPAÇO DE ESPAÇO DE ESPAÇO DE

MEMÓRIA MEMÓRIA MEMÓRIA MEMÓRIA

Figura 5 – Representação gráfica do vetor na memória

Na linguagem C, por uma questão de concepção, todo vetor começa a contar da posição
ZERO. Isto foi uma decisão dos criadores da linguagem, todo programador deve
respeitar. Às vezes, ao mostrar para o usuário a posição do vetor, fazemos uma soma
de 1 para ficar mais compreensível pelo leigo. Vejamos um exemplo a seguir:
#include <stdio.h>
int main()
{
int lista[3], indice;
//Preenchimento
for(indice=0 ; indice <= 2 ; indice++){
printf("Entre com o numero %d: ", indice+1);
scanf("%d", &lista[indice]);
}
//Mostrando os valores
for(indice=0 ; indice <= 2 ; indice++){
printf("Numero %d = %d\n", indice+1, lista[indice]);
}
return 0;
}
Nosso programa vai ter o resultado mostrado na Figura 6 a seguir:

Página: 16
 Figura 6 – Resultado do vetor numérico
Agora vamos trabalhar com palavras, frases e diversão. Diversas linguagens têm
comandos específicos para ler nomes e frases, a linguagem C não é diferente.
Conforme já falamos antes o comando de entrada scanf tem um bug no tratamento de
string, trata-se da má intepretação do espaço, tão necessário em uma frase, este
costuma ser confundido com o ENTER e a string termina sua leitura prematuramente.
Para contornar este problema recomendamos o uso do comando gets(nome_da_var);
isto resolve o incômodo bug de entrada. Uma vez lida a string, podemos exibi-la com
printf usando o parâmetro %s, ou fazer acesso letra a letra com uso de laço. Ainda
temos as divertidas e úteis funções das bibliotecas string.h e strings.h, que devem ser
declaradas no início do programa na seção de include. Vamos a exemplos com strings:
#include <stdio.h>
int main ()
{
char nome[38];
printf ("Digite o seu nome: ");
gets (nome);
printf ("\n\n Ola %s",nome);
return 0;
}
Eis um programa que lê um nome e o mostra depois na tela. A variável nome foi
declarada com tamanho 38, isto significa que ela pode armazenar até 38 caracteres,
mas pode terminar até na primeira letra, basta o usuário teclar ENTER. O resultado pode
ser visto na Figura 7 a seguir:

Figura 7 – Resultado do uso de string

O fato de uma string ser preenchida e exibida somente até onde o usuário comandou é
graças ao uso de uma letra “invisível” pela linguagem C: sempre que o usuário tecla

Página: 17
ENTER para finalizar uma string, o C insere uma letra ‘\0’ na string, sendo este o caracter
TERMINADOR de string. Vamos listar agora alguns exemplos interessantes.
#include <stdio.h>
int main ()
{
char nome[38];
int cont;
printf ("Digite o seu nome: ");
gets (nome);
printf ("\n\n");
for (cont=38;cont>=0;cont--){
printf ("%c",nome[cont]);
}
return 0;
}
Este exemplo é muito parecido com o anterior, mas ele tenta mostra o nome lido “de
trás pra frente” mas ignorando o terminador, isto mostra que o resto da string tem lixo
dentro. Vamos já melhorar isso com a ajuda dos comandos da biblioteca string.h
#include <stdio.h>
#include <string.h>

int main ()
{
char nome[38];
int cont;
printf ("Digite o seu nome: ");
gets (nome);
printf ("\n\n");
for (cont=strlen(nome);cont>=0;cont--){
printf ("%c",nome[cont]);
}
return 0;
}
A mudança agora foi o auxílio da função strlen() que retorna até que tamanho o usuário
de seu programa preencheu a string. Agora nosso nome invertido não tem mais lixo na
tela.
Mais exemplos interessantes podem ser encontrados facilmente na Internet:

• Simulação de leitura de senha;

• Teste de palavra lida e armazenada em outra variável com strcmp();
• Exemplos de outras funções de string.h

Página: 18
Cap. 9 – Funções criadas pelo usuário
Até agora nossos programas tiveram uso obrigatório da função main, pois todo
programa na linguagem C deve ter esta função. Nesta etapa do material vamos criar
nossas próprias funções adicionais. É recomendado criar função sempre que tiver um
trecho de comandos de seu programa que seja necessário de replicação.
Serve de exemplo, um cálculo muito requisitado, o menu, opções de menu dentre
outros. Tal qual nas funções da matemática, podemos atribuir valores para a função
receber, em programação chamamos isso de parâmetros. A função pode ou não
retornar um resultado, quando não retorna muitos programadores a chamam de
procedimento. E ainda a função pode ter variáveis de uso exclusivo e interno, que não
são acessadas por outras funções e nem mesmo na main, a este último conceito
chamamos de escopo de variável, escopo local quando dentro da função e a variável
tem escopo global quando criada fora de função ou dentro da função main. Uma
variável global é vista por todas as funções do programa.
Vamos criar alguns exemplos para clarear as ideias.

#include <stdio.h>

int numero; //variavel de escopo global

int quad(int x){ //esta funcao calcula o quadrado de um inteiro.

return x*x; //x tem escopo local mas eh retorno.
}

int main(){
printf("Digite um inteiro para calcular o quadrado. ");
scanf("%d",&numero);
printf("\n A Resposta eh: %d",quad(numero));
return 0;
}
No nosso primeiro exemplo temos uma função criada para retornar o quadrado de um
número inteiro que é passado como parâmetro. Esta função pode ser chamada quantas
vezes for necessária no programa, seu resultado tanto pode ser impresso direto por
printf quanto pode ser atribuído a uma variável compatível.
Agora no segundo exemplo, mostraremos uma função com retorno vazio. O resultado
produzido é exibido pela própria.
#include <stdio.h>

void calc(){
float a,b;
printf("Entre com o valor de A: ");
scanf("%f",&a);
printf("Entre com o valor de B: ");
scanf("%f",&b);
printf("\n\nTOTAL: %f\n",(a+b)/2);
return;
}

Página: 19
int main(){
printf("Programa Calcula Media.\n\n\n");
calc();
return 0;
}
Veja que todas as variáveis do programa são locais à função calc. O retorno da função
é declarado como void e no seu final o comando return não tem valores ou variáveis
como parâmetros.
Agora você já pode entender vários exemplos encontrados de algoritmos que contêm
funções próprias e o porquê de o programador ter criado as mesmas.

Cap. 10 – Registros (struct)

Finalmente para este curso rápido e introdutório, vamos trabalhar com este tipo de
variável classificado como heterogêneo por permitir misturar em uma só estrutura de
variável vários tipos básicos como inteiros, reais ou caracteres. Estes tipos usados em
conjunto vão compor um tipo de ficha eletrônica, conhecida amplamente pelo nome de
registro, até mesmo na cultura popular é comum ouvirmos em um filme por exemplo,
personagens citando que determinado dado ou pessoa não tem registro no computador.
Isto nos mostra a importância deste conceito de programação que serve de base inicial
para bancos de dados e sistemas de automação em geral.
Em um treino inicial de programação as structs são comumente usadas dentro de
vetores, para simular um cadastro na memória volátil do computador. Em um outro curso
mais avançado você poderá trabalhar este conceito em arquivos, ou mesmo interagindo
com Sistemas Gerenciadores de Bancos de Dados.
Na linguagem C a criação da struct pode ser de duas formas diferentes conforme
veremos a seguir:
struct ficha {
int matricula;
char nome[50];
int idade;
};
//nas variáveis um vetor seria declarado assim
struct ficha pessoas[4];
//podemos cadastrar até 4 pessoas.

Outro modo de criar struct seria assim:

typedef struct ficha {
int matricula;
char nome[50];
int idade;
}REGISTRO;
//nas variáveis um vetor seria declarado assim
REGISTRO pessoas[4];
//podemos cadastrar até 4 pessoas.

Vamos ao nosso primeiro exemplo com registro e sua posterior explicação.

Página: 20
#include <stdio.h>
int main()
{
typedef struct funcionario
{
int matricula;
char nome[60];
char email[50];
}REGISTRO;

REGISTRO colaboradores[5];
int count;
//laço de cadastro de 5 funcionarios
for(count = 0 ; count < 5 ; count++)
{
fflush(stdin);
printf("\nMatricula do funcionario %d: ", count+1);
scanf ("%d", &colaboradores[count].matricula);
fflush(stdin);
printf("\nNome do funcionario %d: ", count+1);
gets(colaboradores[count].nome);
fflush(stdin);
printf("\ne-mail do funcionario %d: ", count+1);
gets(colaboradores[count].email);
}
//mostrando os cadastrados
printf("\n\n\nExibindo valores cadastrados: \n");
for(count = 0 ; count < 5 ; count++)
{
printf("\nFuncionario %d\n", count+1);
printf("Matricula: %d\n",colaboradores[count].matricula);
printf("Nome: %s\n",colaboradores[count].nome);
printf("E-mail: %s\n", colaboradores[count].email);
}
return 0;
}
Pronto, fizemos nosso exemplo mais longo do curso. Agora vamos explicar como
tivemos a saída da Figura 8 abaixo mostrada.

Página: 21
 Figura 8 – Saída do exemplo de registro com dados de teste cadastrados
No exemplo acima temos a declaração da estrutura base do registro pela opção do
typedef, onde o mesmo foi chamado de REGISTRO em maiúsculas, um vetor de 5
elementos foi criado para cadastrar 5 pessoas na memória RAM. Durante a leitura dos
cadastros se faz necessário usar o comando fflush(stdin); a cada comando de entrada
usado, isto é necessário para evitar a contaminação de um campo com restos do
preenchimento do anterior, pois o teclado, bem como todo periférico do computador tem
uma pequena memória chamada de buffer, esta memória fica com resíduos quando
muito requisitada em determinadas linguagens de programação. Para garantir que o
buffer do teclado esteja sempre limpo e o preenchimento de seu registro seja preciso,
usa-se o comando fflush citado acima. No mais o programa termina com um outro laço
exibindo na tela os dados cadastrados conforme ilustrado na Figura 8 acima.

Epílogo
Espero que este material seja útil para despertar novos programadores, ou pelo menos
como auxiliar no processo de ensino e aprendizagem de cursos introdutórios de
programação de computadores com uso da linguagem C.

Página: 22