Linguagem C

Valter Schastai
Introdução
 Programa x Algoritmo
• Um Programa é a formalização de um
algoritmo, utilizando alguma ferramenta,
capaz de permitir que o computador possa
entender a seqüência de ações.
 Linguagem do Computador
• A única linguagem que o computador
entende chama-se linguagem de máquina
• Portanto, todos os programas que se
comunicam com o computador devem estar
em linguagem de máquina
 Compiladores e Interpretadores
• A forma como os programas são traduzidos
para a linguagem de máquina classifica-se
em duas categorias:
– Interpretados
– Compilados
 Interpretadores
• Lê uma instrução, faz consistência da
sintaxe e se não houver erro converte-a para
linguagem de máquina para finalmente
executá-la
• Segue para a próxima instrução, repetindo o
processo até que a última instrução seja
executada, ou algum erro seja encontrado
 Compiladores
• Lê uma instrução, faz consistência da
sintaxe e se não houver erro converte-a para
linguagem de máquina e, em vez de
executá-la segue para a próxima instrução
repetindo o processo até que a última
instrução seja atingida ou algum erro seja
encontrado
 Compiladores
• Não havendo erros na compilação é gerado
um programa .OBJ
• A partir desse momento, entre em cena o
linkeditor, que fará a associação entre o
programa .OBJ e a biblioteca padrão do
compilador
• O produto final criado pelo linkeditor é o
executável (arquivo com extensão .EXE)
 Interpretadores x Compiladores
• O interpretador precisa estar presente todas as
vezes que um programa é executado
• Sendo assim, se uma parte do programa
necessitar ser executada muitas vezes, o
processo será feito o mesmo número de vezes
• Na execução de um programa compilado, o
compilador não precisa estar presente
 Interpretadores x Compiladores
• Programas compilados (arquivos .EXE),
não permitem alteração, o que protege o
código fonte
• A linguagem que utilizaremos nesse curso,
linguagem C, gera programas compilados
 A Linguagem C
• Criada por Dennis M. Ritchie e Ken
Thompson em 1972
• C é uma linguagem muito utilizada na
programação de qualquer tipo de sistema
(cálculos matemáticos, estruturas de dados,
sistemas operacionais, etc)
• Como por exemplo, o sistema operacional
UNIX é desenvolvido em C
 A Linguagem C
• C é suficientemente estruturada para
encorajar bons hábitos de programação
• Por exemplo, programas em C podem ser
desenvolvidos em partes separadas por
pessoas distintas e depois unidas em um
programa final
 Como Criar um Programa
Executável em C
• Escrever o programa em qualquer editor de texto e
salvá-lo em um arquivo com o sufixo .c (o arquivo
deve ser salvo no modo texto)
• Compilar o fonte seguindo as instruções do seu
compilador (isso criará o arquivo .EXE)
• Atualmente, a maioria dos compiladores possuem
uma interface que disponibiliza entrada do código
fonte (editor próprio) e funções para compilação
(por exemplo, ctrl+F9, no Turbo C++ 4.0)
 O Compilador que Utilizaremos
• No nosso curso utilizaremos o compilador
da borland Turbo C++ 4.0
 Algumas Funções Básicas da
Interface do Compilador
• Compilar: F9
• Compilar e Executar: Ctrl + F9
• Help Específico: Cursor na palavra e Ctrl +
F1
 Primeiro Programa
arquivo que contém a sub-rotina printf() arquivo que contém a sub-rotina getch()

#include <stdio.h>
#include <conio.h>

void main()
{
Escreve na Tela printf("Primeiro Programa!");
getch();
}

Pegar um caractere do Teclado

 A Estrutura Básica de um
Programa C
• Um programa C consiste em uma ou várias
“funções”
• Forma Geral: cabeçalho;

void main()
{
instruções;
}

tipo outras_funções()
{
instruções;
}
 A Estrutura Básica de um
Programa C
• A função main() é a primeira função a ser
executada no código (também é obrigatória)
• O identificador void indica que a função não
retorna qualquer valor
• A seção cabeçalho é usada para a definição
das bibliotecas que serão utilizadas no
programa (por exemplo, #include <stdio.h>)
 A Estrutura Básica de um
Programa C
• Além da função main() outras funções podem
ser colocadas no programa, essas novas
funções devem possuir um tipo de retorno (ou
void) e um nome identificando-as
• Na seqüência do curso, falaremos mais sobre
definição de funções
Tipos de Dados e Variáveis
 Tipos de Dados
• Um tipo de dado define a quantidade de
memória necessária para alojar o dado, a
abrangência de valores possíveis (escala) e
o tipo de operações que podem ser
executadas com este dado
• Definir um tipo de dado, significa informar
ao compilador de que forma este dado deve
ser interpretado e de como ele deve ser
gerenciado na memória
 Tipos Básicos
TIPO DESCRIÇÃO BYTES FAIXA
int Inteiro com sinal 2 -32768 a 32767
float Real com sinal 4 3.4 x 10 -38 até 3.4 x 10 38 (+ e -)
char Um ou mais caracteres 1 1 caractere

• Caso você necessite de faixas maiores de valores,

existem modificadores de tipos básicos (unsigned,
por exemplo) e também outros tipos de dados,
como por exemplo, long e double
 Variáveis
• Uma variável é um espaço da memória,
reservado quando da declaração da variável
e que será ocupado por um tipo de dado
onde o valor do dado irá variar ao longo da
vida útil do bloco de instruções ao qual a
variável pertence
Variáveis
 Declarando Variáveis
• Sintaxe:
tipo nome_da_variável;

• A declaração de variáveis consiste em

informar ao compilador o tipo de dado e o
nome da variável que irá ocupar uma certa
quantidade de memória
• Por enquanto, iremos declarar nossas
variáveis apenas no interior da função
main() (chamadas variáveis locais)
 Nomes de Variáveis
• O primeiro caractere deve ser uma letra ou um
sublinhado “_”
• Os demais caracteres podem ser letras, números
ou sublinhados
• Apenas os primeiros 31 caracteres são
significativos
• O nome da variável deve ser único no programa
• Vale ressaltar que a linguagem C é “Case Sentive”
 Atribuindo Valores às Variáveis
• Para atribuir um valor (dado) a uma
variável deve ser utilizado o operador de
atribuição “=”
• Podemos atribuir o valor a uma variável
quando da sua declaração, ou após a sua
declaração
• Exemplo:
int quantidade_produto = 15;
quantidade_produto = 15;
 Exercício
• Sabendo que duas variáveis a e b, possuem
respectivamente os valores 5 e 10, construa
um programa em C para trocar os valores
destas variáveis, ou seja, no final do
programa a deve possuir o valor 10 e b o
valor 5.
 Solução

void main()
{
int a = 5, b = 10, c;
c = a;
a = b;
b = c;
}
Saída de Dados
 Introdução
• Toda saída de dados é manipulada por
funções
• Para incluir estas funções em nossos
programas temos que dizer ao compilador
em que biblioteca de arquivos “header”
estas funções estão contidas
• Para a função de saída de dados que
usaremos a biblioteca stdio.h será suficiente
 printf()

• Sintaxe:
printf(“expressão de controle”, lista de argumentos);
 printf()
• Expressão de Controle
– A expressão de controle pode conter caracteres
que serão exibidos na tela
– Também podem ser inseridos manipuladores de
controle e códigos de formatação que indicam o
formato em que os argumentos devem ser
impressos
 printf()
Alguns Manipuladores de Controle
\n Nova linha
\xN Imprime caractere ASCII (N em hexa)
\” Imprime aspas
\\ Imprime barra
 printf()
Alguns Códigos de Formatação
%c char
%d int
%f float
%s string
%ld long
%lf double
 printf()
• Lista de argumentos:
– A lista de argumentos pode conter qualquer
quantidade de argumentos
– Cada argumento deve ser separado por vírgula
 printf()
#include <stdio.h>
#include <conio.h>

void main()
{
char sexo = 'F';
int idade = 15;
float altura = 1.75;

printf("Escrevendo um caractere: %c \n",sexo);

printf("Escrevendo um inteiro: %d \n",idade);
printf("Escrevendo um real: %f ",altura);
getch();
}
 printf()
#include <stdio.h>
#include <conio.h>

Quantidade total de caracteres exibidos.

void main()
Caso o argumento tenha uma quantidade
{
maior, não haverá truncamento. Caso seja
char sexo = 'F';
menor serão colocados brancos a esquerda
int idade = 15;
float altura = 1.75;

printf("Escrevendo um caractere: %c \n",sexo);

printf("Escrevendo um inteiro: %d \n",idade);
printf("Escrevendo um real: %5.2f ",altura); // _1.75
getch();
}
Quantidade de casas decimais com arredondamento
 printf()
#include <stdio.h>
#include <conio.h>

void main()
Quantidade total de caracteres exibidos.
{
Caso seja menor será complementado com
char sexo = 'F';
brancos a esquerda
int idade = 15;
float altura = 1.75;

printf("Escrevendo um caractere: %c \n",sexo);

printf("Escrevendo um inteiro: %5.3d \n",idade); //__015
printf("Escrevendo um real: %f ",altura);
getch();
}
Número de caracteres do argumento, caso seja menor será
complementado com 0’s à esquerda
 putchar()
• A função putchar() é mais uma das funções
de saída existentes na biblioteca stdio.h
• Esta função permite escrever na tela apenas
um caractere
• Sintaxe:

putchar(caractere);
Entrada de Dados
 Introdução
• Assim como a saída de dados é tratada com
funções da biblioteca stdio.h, também a
entrada de dados é tratada dessa forma
 scanf()
• A função scanf() é para entrada de dados o
que a função printf() é para saída de dados
• A função scanf() utiliza os mesmos códigos
para formatar dados, porém agora, para
entrada de dados
• Vale ressaltar que os argumentos de scanf()
devem ser endereços de variáveis
• O endereço de uma variável é dado pelo
operador & antes do nome da variável
 scanf()

• Sintaxe:
scanf(“expressão de controle”,lista de argumentos);
 scanf()
#include <stdio.h>
#include <conio.h>

void main()
{
float anos, dias;
printf("Digite sua idade em anos: ");
scanf("%f",&anos);
dias = anos * 365;
printf("Sua idade em dias e' = %.0f ",dias);
getch();
}
 getche() e getch()
• Essas duas funções estão definidas na
biblioteca conio.h e são utilizadas para ler
um caractere no instante em que é
datilografado, sem esperar [enter]
• A função getche() lê o caractere do teclado
e permite que seja impresso na tela
• Esta função não aceita argumentos e
devolve o caractere lido para a função que a
chamou
 getche() e getch()
• A função getch() lê o caractere do teclado e
não permite que seja impresso na tela
• Como getche(), esta função não aceita
argumentos e devolve o caractere lido para
a função que a chamou
 getche() e getch()
#include <stdio.h>
#include <conio.h>

void main()
{
char c;
printf("Pressione uma tecla : ");
c = getche();
printf("\nLeitura feita com getche()");
printf("\nPressione novamente uma tecla: ");
c = getch();
printf("\nLeitura feita com getch()");
getch();
}
Operadores
 Operadores Matemáticos
• Para efetuar cálculos envolvendo valores
numéricos podem ser utilizados os
seguintes operadores matemáticos
+ : Adição
- : Subtração
* : Multiplicação
/ : Divisão
% : Retorna o resto de uma divisão
 Operadores de Incremento e
Decremento
++ : Incrementa de 1 seu operando
-- : Decrementa de 1 seu operando
• Os dois operadores trabalham de dois
modos:
– Pré-fixado: O operador aparece antes do nome
da variável
– Pós-fixado: O operador aparece seguindo o
nome da variável
 Operadores de Incremento e
Decremento
• Em ambos os casos a variável é alterada, no
entanto, no modo pré-fixado a variável é
incrementada antes de seu valor seu usado e
no modo pós-fixado a variável é
incrementada depois de seu valor ser usado
 Operadores de Incremento e
Decremento
• Exemplo:

n = 5; n = 5;
x = n++; x = ++n;

// x = 5 // x = 6
// n = 6 // n = 6
 Operadores Aritméticos de
Atribuição
• Estes operadores simplificam a definição de
operações aritméticas
• Eles inicialmente realizam a operação
matemática envolvida e em seguida
atribuem o resultado a uma variável
• Exemplo:
x = x + 10;
pode ser substituído por:
x += 10;
 Operadores Aritméticos de
Atribuição
+= : Soma os operandos e o resultado atribui
à variável à esquerda
-= : Diminui os operandos e o resultado
atribui à variável à esquerda
*= : Multiplica os operandos e o resultado
atribui à variável à esquerda
/= : Divide os operandos e o resultado
atribui à variável à esquerda
 Operadores Aritméticos de
Atribuição
• Outros exemplos:

i += 2; equivale a i = i + 2;
x *= y+1; equivale a x = x * (y + 1);
t /= 2.5; equivale a t = t / 2.5;
d -= 3; equivale a d = d – 3;
 Operadores Relacionais
• Os operadores relacionais são muito
utilizados nas tomadas de decisões
== : igual
!= : diferente
> : maior que
< : menor que
>= : maior ou igual que
<= : menor ou igual que
 Operadores Lógicos
• Utilizados normalmente junto com os
operadores relacionais
– && : lógico E
– || : lógico OU
– ! : lógico de negação
 Precedência dos Operadores
Operadores Precedência
! maior (1)
* / % 2
+ - 3
> < >= =< 4
== != 5
&& 6
|| menor (7)
 Exercícios
• Qual é o erro lógico do programa abaixo ?
#include <stdio.h>
#include <conio.h>

void main()
{
int a,b,c;
printf("Digite 3 numeros: \n");
scanf("%d %d %d",a,b,c);
printf("\n %d %d %d",a,b,c);
getch();
}
 Exercícios
• Faça um programa para ler a base e a altura
de um triângulo. Em seguida, escreva a área
do mesmo.
Lembre: Área = ( Base * Altura ) / 2
 Solução
#include <stdio.h>
#include <conio.h>

void main()
{
float base, altura, area;
printf("\nEntre com a base do triangulo: ");
scanf("%f",&base);
printf("\nEntre com a altura do triangulo: ");
scanf("%f",&altura);
area = (base * altura) / 2;
printf("\nA area do triangulo e %f",area);
getch();
}
Introdução a Manipulação de
Strings
 Introdução
• String é uma das mais úteis e importantes
formas de dados em C e é usada para
armazenar e manipular textos como
palavras, nomes e sentenças
• Em C, string é um vetor unidimensional do
tipo char, terminada pelo caractere null
(‘\0’)
 Introdução
• Cada caractere de uma string pode ser
acessado individualmente, o que
proporciona uma grande flexibilidade aos
programas que processam texto
 Declarando uma String
• O tipo char deve ser usado antes do nome
dado para a variável string
• Após o nome da variável string declara-se o
tamanho da string entre colchetes
• Por exemplo:

char nome[50];
 Lendo Strings com scanf()
• Para ler uma string podemos fazer uso da
função scanf(“%s”,&string)
• Porém essa função quando encontra o
caractere “branco ou espaço” encerra a
leitura
• Portanto muitas vezes não é a função ideal
para leitura de strings
 Lendo Strings com gets()
• Normalmente usa-se para leitura de strings
a função gets()
• Essa faz a leitura de caracteres quaisquer
até que seja digitado [enter]
• Sintaxe:

gets(variável_string);
 Exemplo
#include <stdio.h>
#include <conio.h>

void main()
{
char nome[50];
printf("Entre com um nome: ");
gets(nome);
printf("O nome que voce digitou foi %s",nome);
getch();
}
 Inicializando Strings
• Uma string pode ser inicializada no
momento em que é declarada
• Exemplo:

char nome[] = “Marta”;

 Acessando Posições Individuais
de uma String
• Muitas vezes é necessário manipular
caracteres individuais em uma string
• A linguagem C possui uma forma toda
especial de permitir tal operação, através do
uso de colchetes ( [ ] ) logo após o nome da
variável do tipo string, e o número do
caractere que se deseja manipular entre os
colchetes.
 Acessando Posições Individuais
de uma String
• A primeira posição de uma string em C é
acessada pelo índice 0, a segunda pelo
índice 1, e assim por diante
• Exemplo:
char curso[] = “LPI”

curso[0] LPI curso[2]

curso[1]
 Exercício
• Construa um programa para ler uma string
que represente uma data no seguinte
formato: dd/mm/aaaa. Após lida a string,
escreva o dia, mês e ano (em números) da
data entrada pelo usuário.
 Solução
#include <stdio.h>
#include <conio.h>
#include <string.h>

void main()
{
char data[9];
printf("Entre com uma data no formato dd/mm/aaaa: ");
gets(data);
printf("\nO dia e %c%c",data[0],data[1]);
printf("\nO mes e %c%c",data[3],data[4]);
printf("\nO ano e %c%c%c%c",data[6],data[7],
data[8],data[9]);
getch();
}
Comandos de Seleção Única
 Introdução
• Na linguagem C temos comandos para
avaliar expressões e selecionar aquela ou
aquelas que forem verdadeiras
• Mais precisamente isto significa executar o
bloco de comandos que está subordinado à
expressão que resultou em verdadeiro
 if – Sem Alternativa
• Sintaxe:

if(condição)
{
instruções;
}
 if – Sem Alternativa
• Neste tipo de avaliação condicional há uma
expressão sendo avaliada e caso ela resulte
em verdadeiro o bloco de instruções que a
segue é executado
• Caso resulte em falso o bloco é saltado
• Os delimitadores de bloco de instruções
{ e } somente são obrigatórios caso o bloco
tenha mais que uma instruções
 Exemplo
#include <stdio.h>
#include <conio.h>

void main()
{
int a,b;
printf("Entre com dois numeros: \n");
scanf("%d %d",&a,&b);
if(a == b)
{
printf("Os Numeros sao Iguais");
}
getch();
}
 if – Com Alternativa
• Sintaxe:

if(condição)
{
instruções;
}
else
{
instruções
}
 if – Com Alternativa
• Nesta seleção há uma expressão de teste,
que se a expressão resultar em verdadeiro é
executado o bloco de instruções que segue o
if, caso contrário, é executado o bloco que
segue o else
 Exemplo
#include <stdio.h>
#include <conio.h>

void main()
{
int a,b;
printf("Entre com dois numeros: \n");
scanf("%d %d",&a,&b);
if(a == b)
{
printf("Os Numeros sao Iguais");
}
else
{
printf("Os Numeros sao Diferentes");
}
getch();
}
 if – Mais que uma Condição
• Sintaxe: if(condição)
{
instruções;
}
else if(condição)
{
instruções;
}
else if(condição)
{
instruções;
}
....
else
{
instruções;
}
 Exemplo
#include <stdio.h>
#include <conio.h>

void main()
{
int a,b;
printf("Entre com dois numeros: \n");
scanf("%d %d",&a,&b);
if(a > b)
{
printf("O primeiro e maior que o segundo");
}
else if (a < b)
{
printf("O primeiro e menor que o segundo");
}
else
{
printf("Os numeros sao iguais");
}
getch();
}
 Operador Ternário “? :”
• Sintaxe:

Expressão_de_teste ?
Expressão_executada_se_verdadeiro :
Expressão_executada_se_falso;
 Operador Ternário “? :”
• Um comando idêntico ao comando de
seleção onde há uma expressão de teste com
uma alternativa (if-else) é o operador “? :”
• Este operador é preferível quando for
necessário utilizar uma expressão de teste
mais sintética
• Este operador é denominado de ternário
pois requer três operandos
 Exemplo
#include <stdio.h>
#include <conio.h>

void main()
{
int a,b;
printf("Entre com dois numeros: \n");
scanf("%d %d",&a,&b);

a == b ? printf("Iguais") : printf("Diferentes");

// tambem poderiamos fazer

// printf("%s", a == b ? "Iguais" : "Diferentes");

getch();
}
 Outro Exemplo

int a,b,maior;
printf("Entre com dois numeros: \n");
scanf("%d %d",&a,&b);

maior = a > b ? a : b;
printf("\n Maior = %d",maior);

maior recebe o valor de a ou de b

 Exercícios
• Construa um programa capaz de informar
se um número inteiro é par ou impar
 Solução
#include <stdio.h>
#include <conio.h>

void main()
{
int numero;
printf("Entre com um numero: ");
scanf("%d",&numero);

if((numero % 2) == 0)
printf("Numero par");
else printf("Numero impar");

// (numero % 2) == 0 ? printf("Par") : printf("Impar");

getch();
}
 Exercício
• Complemente o programa feito para
calcular a média de um aluno do curso de
programação de computadores, adicionando
uma saída para o usuário da situação do
aluno (aprovado, reprovado ou final)
 Solução
.
.
.
if(media >= 7)
printf("Aprovado");
else if (media >= 4)
printf("Final");
else printf("Reprovado");
.
.
.
Comandos de Seleção Múltipla
 switch ... case
• Sintaxe:
switch(expressão) {
case constante1: {bloco de instruções; break;}
case constante2: {bloco de instruções; break;}
...
case constante3: {bloco de instruções; break;}
[default {bloco de instruções;}]
}
 switch ... case
• O comando switch...case testa
sucessivamente o valor de uma expressão
em relação a uma série de constantes
• Quando o teste resultar na igualdade de
valores, os comando subordinados à
constante (int ou char) são então executados
 Exemplo
#include <stdio.h>
#include <conio.h>

void main()
{
float num1, num2;
char operador;

printf("Digite: Primeiro Numero, Operador, Segundo Numero:\n");

scanf("%f %c %f",&num1,&operador,&num2);

switch(operador)
{
case '+': {printf("\nResultado: %f",num1 + num2); break;}
case '-': {printf("\nResultado: %f",num1 - num2); break;}
case '*': {printf("\nResultado: %f",num1 * num2); break;}
case '/': {printf("\nResultado: %f",num1 / num2); break;}
}
getch();
}
 Exercício
• Faça um programa que leia um número que
represente um determinado mês do ano.
Após a leitura escreva por extenso qual o
mês lido. Caso o número digitado não esteja
na faixa de 1..12 escreva uma mensagem
informando o usuário do erro da digitação.
 Solução
#include <stdio.h>
#include <conio.h>

void main()
{
int mes;
printf("Digite um numero entre 1 e 12: ");
scanf("%d",&mes);

switch(mes)
{
case 1: {printf("\nJaneiro"); break;}
case 2: {printf("\nFevereiro"); break;}
case 3: {printf("\nMarco"); break;}
// ...
case 12: {printf("\nDezembro"); break;}
default: {printf("\nNumero Invalido");}
}
getch();
}
Comandos de Repetição de
Blocos
 Introdução
• Os comandos de repetição de blocos em
linguagens de programação, também são
conhecidos como comandos de iteração, ou
comandos de laço ou ainda “loop” de
instruções
• Estes comandos executam os blocos de
instruções subordinados enquanto uma
determinada condição permanecer como
verdadeira
 Comando - for
• O comando for é o mais utilizado quando
devemos repetir a execução de um ou mais
blocos de instruções, um determinado
número de vezes
 Comando - for
• Sintaxe:

for(inicialização; teste; incremento)

{
instruções;
}
 Comando - for
• A primeira expressão é utilizada para a
inicialização, onde normalmente é
inicializada uma variável contadora
• A inicialização é executada somente uma
vez, no momento em que o laço é ativado
• O teste, normalmente é uma expressão
relacional, que testa a validade de nova
execução do laço
 Comando - for
• O incremento, modifica o valor da variável
utilizada para controle do laço
• Normalmente é um incremento de 1 no
valor da variável
 Exemplo
#include <stdio.h>
#include <conio.h>

void main()
{
int i;
for(i=1;i<=10;i++)
{
printf("\n%d",i);
}
getch();
}
Exemplos Flexibilidade - for
#include <stdio.h>
#include <conio.h>

void main()
{
int x,y;
for(x=0,y=0; x+y<10; x++,y++)
{
printf("\n%d",x+y);
}
getch();
}
Exemplos Flexibilidade - for
#include <stdio.h>
#include <conio.h>

void main()
{
char c;
for( ; (c=getch()) != 's'; )
{
printf("\n%c",c);
}
}
 Exercício
• Faça um programa que leia uma string do
teclado e após isso escreva ela invertida na
tela do usuário
 Solução
#include <stdio.h>
#include <conio.h>
#include <string.h>

void main()
{
char str[50];
int i;
printf("Entre com uma palavra: ");
gets(str);

for(i=(strlen(str)-1);i>=0;i--)
{
printf("%c",str[i]);
}
getch();
}
 Exercício
• Fazer um programa, usando
obrigatoriamente a estrutura for, que
calcule escreva o valor de S onde:

1 3 5 7 99
S     ...
1 2 3 4 50
 Solução
#include <stdio.h>
#include <conio.h>

void main()
{
int num, den;
float s=0;

for(num=1,den=1;num<=99;num+=2,den++)
{
s = s + (float)num/den;
}
printf("%f",s); Sem o (float) a divisão seria uma
getch(); divisão inteira
}
 Exercício
• Faça um programa que leia 20 valores reais
e escreva seu somatório (use a estrutura for)
 Solução
#include <stdio.h>
#include <conio.h>

void main()
{
int num,i, s=0;
printf("Entre com 5 numeros\n");

for(i=1;i<=5;i++)
{
scanf("%d",&num);
s = s + num;
}
printf("%d",s);
getch();
}
 Comando - while
• Comando normalmente utilizado quando é
necessário repetir um bloco de instruções
sem saber de antemão quantas vezes este
bloco deverá ser executado
 Comando - while
• Sintaxe:

while(condição)
{
instruções;
}
 Comando - while
• Quando precisamos testar uma condição
antes mesmo de iniciar a execução de um
bloco de instruções devemos então utilizar
o comando while com teste no início
 Exemplo
#include <stdio.h>
#include <conio.h>

void main()
{
int i=1;
while(i <= 10)
{
printf("%d \n",i);
i++;
}
getch();
}
 Exercício
• Faça um programa para calcular um valor A
elevado a um expoente B. Os valores A e B
deverão ser lidos, onde a > 0, b >= 0
 Solução
#include <stdio.h>
#include <conio.h>

void main()
{
int a, b, resultado = 1;
printf("Entre com a base e o expoente: \n");
scanf("%d %d",&a,&b);
while(b > 0)
{
resultado = resultado * a;
b--;
}
printf("Resultado: %d",resultado);
getch();
}
 Exercício
• Faça um programa para calcular N!, onde
N >= 0.
 Solução
#include <stdio.h>
#include <conio.h>

void main()
{
long int n, resultado=1;
printf("Entre com um numero: \n");
scanf("%ld",&n);

while(n > 0)
{
resultado = resultado * n;
n--;
}
printf("O fatorial eh igual a %ld",resultado);
getch();
}
 Comando – do ... while
• Para executar um bloco de instruções,
subordinado a um laço de repetição, pelo
menos uma vez, temos o comando
do...while
 Comando – do ... while
• Sintaxe:

do
{
instruções;
}while (condição);
 Exemplo
#include <stdio.h>
#include <conio.h>

void main()
{
int i=1;

do
{
printf("\n %d",i);
i++;
}while(i <=10);
getch();
}
 Exercícios
• Faça um programa para calcular a série
Fibonacci até o vigésimo termo. A série tem
a seguinte forma: 1,1,2,3,5,8,13,21,34,…
(use obrigatoriamente a estrutura do...while)
 Solução
#include <stdio.h>
#include <conio.h>

void main()
{
int ant=1, prox=1, novo, cont=2;
printf("%d, %d",ant,prox);
do
{
novo = ant + prox;
printf(“, %d",novo);
ant = prox;
prox = novo;
cont++;
}while(cont <=20);
getch();
}
 Exercícios
• Faça um programa para ler um valor X e
calcular Y = X+2X+3X+4X+5X+…+20X
(use a estrutura do...while)
 Solução
#include <stdio.h>
#include <conio.h>

void main()
{
int x, y=0, i=1;
printf("Entre com um valor para x: ");
scanf("%d",&x);

do
{
y = y + (i * x);
i++;
}while(i <= 20);
printf("y = %d",y);
getch();
}
 Comandos de Desvio de
Execução
• Muitas vezes é necessário interromper o
fluxo normal de processamento de um laço
de repetição, independente deste laço ter
sido implementado com for ou while
• Para fazer isso, temos dois comandos de
desvio: o break e o continue
 O Comando break;
• O comando break desvia o fluxo de
processamento para fora do comando de
repetição
• Mais precisamente, para a primeira linha
após o término do comando de repetição
 O Comando continue;
• O comando continue transfere o fluxo de
processamento para o teste do comando de
repetição
• Usando o continue com o for, antes do teste
de associado ao for ser verificado ocorre o
incremento das variáveis na seção de
incremento do for
void main()
{
float idade, total_idade=0, total_pessoa=0;
char resp;
while(1)
{
printf("\nIDADE: ");
scanf("%f",&idade);
if(idade <= 0)
{
printf("\nIdade Invalida, deseja continuar?(s/n)");
resp = getche();
if(resp == 's')
continue;
else break;
}
else{
total_idade += idade;
total_pessoa++;
}
}
printf("\nA Media de Idade e %f",(total_idade/total_pessoa));
getch();
}
 Exercício
• Altere o programa que calcula o fatorial de
um número, de maneira que seja perguntado
ao usuário se ele deseja calcular ou não o
fatorial de um próximo número.
void main()
{
double n, resultado;
char c;

while(1)
{
resultado = 1;
printf("Entre com um numero: \n");
scanf("%lf",&n);

while(n > 0)
{
resultado = resultado * n;
n--;
}
printf("O fatorial eh igual a %lf \n",resultado);
printf("\nDeseja Continuar(s/n)? ");
c = getch();
if(c == 's')
continue;
else break;
clrscr();
}
}
Funções Definidas pelo Usuário
 Introdução
• Funções dividem grandes tarefas de computação
em tarefas menores
• Em C, uma função é uma unidade de código de
programa autônoma desenhada para cumprir uma
tarefa particular
• Provavelmente a principal razão da existência de
funções é impedir que o programador tenha de
escrever o mesmo código repetidas vezes
 Sintaxe

tipo nome_função(parâmetros com tipos)

{
instruções;
}
 Tipo de uma Função
• O tipo de uma função é determinado pelo tipo de
valor que ela retorna e não pelo tipo de seus
argumentos
• Os tipos possíveis de retorno de uma função são
todos os tipos que o C suporta
• Para que um valor seja retornado pela função deve-
se utilizar o comando return(valor), onde valor é o
dado que se deseja retornar
• Quando uma função não retorna um valor deve-se
declarar a palavra reservada void no lugar do tipo
 Parâmetros de uma Função
• Em C, a maioria dos argumentos de funções
são passados “por valor”
• Isto significa que à função chamada é dada
uma cópia dos valores dos argumentos, e
ela cria outras variáveis temporárias para
armazenar estes valores
• Para todos os parâmetros da função é
necessário definir seu tipo de dado
 Protótipos de Função
• Protótipo de função significa declarar ao
compilador o formato das funções que serão
criadas por você programador
• Isto é feito, normalmente após a definição
do cabeçalho do programa (includes)
• Apenas a primeira linha da função deve ser
declarada e adicionalmente deve ser
colocado o símbolo de ponto e vírgula (;)
 Exemplo 1
void linha(); // protótipo da função

void main()
{
linha();
printf("\xDB PROGRAMA EM C \xDB\n");
linha();
getch();
}

void linha() // função propriamente dita

{
int j;
for(j=1;j<=17;j++)
{
printf("\xDB");
}
printf("\n");
}
 Exemplo 2
float potencia(float b, float e);

void main()
{
float base, expoente;
printf("Entre com a base e o expoente: \n");
scanf("%f %f",&base,&expoente);
printf("Resultado = %f",potencia(base,expoente));
getch();
}

float potencia(float b, float e)

{
int resultado = 1;
while(e > 0)
{
resultado = resultado * b;
e--;
}
return(resultado);
}
 Variáveis Locais e Globais
• Locais:
– Variáveis que são declaradas dentro de funções
– Seu escopo de visibilidade é somente para a
função a qual ela pertence
• Globais:
– Variáveis declaradas fora de qualquer função
– Este tipo de variável pode ser acessada por
todas as funções que fazem parte do código
fonte
 Exemplo
float valor_dolar, real; // variáveis globais

void converte(float qtd_dolar);

void main()
{
float montante;
printf("Digite o valor do Dolar em Reais: ");
scanf("%f",&valor_dolar);
printf("Digite um montante em Dolar: ");
scanf("%f",&montante);
converte(montante);
printf("\nMontante em Reais = %f",real);
getch();
}

void converte(float qtd_dolar)

{
real = qtd_dolar * valor_dolar;
}
 Exercícios
• Um número primo é qualquer inteiro
positivo que é divisível apenas por si
próprio e por 1. Escreva uma função que
recebe um inteiro positivo e, se este número
for primo, retorna 1, caso contrário, retorna
0.
int primo(int numero);

void main()
{
int entrada;
printf("Digite um numero: ");
scanf("%d",&entrada);
if(primo(entrada))
printf("\nNumero Primo");
else printf("\nNumero nao Primo");
getch();
}

int primo(int numero)

{
int i;
for(i=2;i<numero;i++)
{
if ((numero % i) == 0)
return 0;
}
return 1;
}
 Exercícios
• Construa um programa para calcular:
7
1

n 1 n!
• Obs.: Use funções
int fat(int numero);

void main()
{
float somatorio=0;
int i;
for(i=1;i<=7;i++)
{
somatorio = somatorio + (float)1/fat(i);
}
printf("\nResultado = %f",somatorio);
getch();
}

int fat(int numero)

{
int i, resultado_fat = 1;
for(i=numero;i>=1;i--)
{
resultado_fat = resultado_fat * i;
}
return(resultado_fat);
}
O Pré-Processador C
 Introdução
• O pré-processador C é um programa que
examina o programa fonte em C e executa
certas modificações nele, baseado em
instruções chamadas diretivas
• O pré-processador faz parte do compilador
e pode ser considerado uma linguagem
dentro da linguagem
 Introdução
• Ele atua antes da compilação de um
programa, fazendo pesquisa e substituição
no código fonte antes de iniciar a
compilação
• Como já dito, a substituição basea-se em
diretivas definidas no corpo do código fonte
• As diretivas em sempre iniciam com o
caracter #
 Introdução
• Algumas das principais diretivas da
linguagem C são as seguintes:
– #include
– #define
– #error
– #ifdef
– #undef
– entre outras
 A diretiva #define
• Com a diretiva #define definimos um
identificador (escrito em maiúsculo) que
deverá ser localizado
• Em seguida, após pelo menos um espaço
em branco, definimos o texto resultante que
substituirá o identificador localizado
• A operação toda (definição mais pesquisa e
substituição) é denominada de macro
 Exemplo
#include <stdio.h>
#include <conio.h>

#define PI 3.14159

float area(float r);

void main()
{
float raio;
printf("Digite o raio da esfera: ");
scanf("%f",&raio);
printf("A area da esfera eh %f",area(raio));
getch();
}

float area(float r)
{
return(4 * PI * r * r);
}
 Por Que Usar #define ?
• Talvez você se pergunte o que ganhamos
substituindo, no programa anterior, PI por 3.14159
• Suponhamos que você tenha um programa em que
a constante 3.14159 apareça muitas vezes
• Suponha, ainda, que agora você queira uma
precisão maior e queira trocar 3.14159 por
3.141592
 Por Que Usar #define ?
• Você deverá ir passo a passo através do
programa e trocar cada ocorrência que
encontrar da constante
• Entretanto, se você tiver definido 3.14159
como sendo PI na diretiva #define, você
deverá somente fazer uma troca
 Outro Exemplo
#include <stdio.h>
#include <conio.h>

#define SOMA(x,y) (x+y)

void main()
{
printf("Resultado: %d",SOMA(3,5));
getch();
}
 Outro Exemplo
#include <stdio.h>
#include <conio.h>

#define ERRO printf("\nERRO: NUMERO INVALIDO")

void main()
{
int i;
printf("Digite um numero de 0 a 100: ");
scanf("%d",&i);
if( (i<0) || (i>100))
ERRO;
getch();
}
 Exercícios
• Torne o código abaixo interpretável pelo
compilador C

algoritmo
inicio
escreva("teste");
espere;
fim
 Solução
#include <stdio.h>
#include <conio.h>

#define algoritmo void main()

#define inicio {
#define fim }
#define escreva(x) printf(x)
#define espere getch()

algoritmo
inicio
escreva("teste");
espere;
fim
Classes de Armazenamento
 Introdução
• Todas as variáveis em C têm dois atributos: um
tipo e uma classe de armazenamento
• Os tipos nós já conhecemos, e as classe de
armazenamento que veremos serão as seguintes:
– auto
– extern
– static
– register
 Classe auto
• A maioria das variáveis que declaramos até
agora estão confinadas nas funções que as
usam
• Isto é, são “visíveis” somente às funções
onde estão declaradas
• Tais variáveis são chamadas “locais” ou
“automáticas”, são criadas quando a função
é chamada e destruídas quando a função
termina a sua execução
 Classe auto
• As variáveis declaradas dentro de uma
função são automáticas por “default”
• Variáveis automáticas são as mais comuns
dentre as quatro classes
• A classe de variáveis automáticas pode ser
explicitada usando-se a palavra auto
 Classe auto
void main()
{
auto int n;
}

É EQUIVALENTE A

void main()
{
int n;
}
 Classe extern
• Todas as variáveis declaradas fora de
qualquer função têm a classe de
armazenamento extern
• Variáveis com este tipo de atributo serão
conhecidas por todas as funções declaradas
depois dela
• A declaração de variáveis externas é feita
da mesma maneira como declaramos
variáveis dentro do bloco de uma função
 Classe extern
#include <stdio.h>
#include <conio.h>

int n=10;

void main()
{
extern n;
printf("%d",n);
getch();
}
 Classe extern
• A palavra extern indica que a função usará
uma variável externa
• Este tipo de declaração, entretanto, não é
obrigatória se a definição original ocorre no
mesmo arquivo fonte
• Lembre-se que variáveis externas retém
seus valores durante toda a execução do
programa
 Classe static
• Variáveis static de um lado se assemelham
às automáticas, pois são conhecidas
somente as funções que as declaram e de
outro lado se assemelham às externas pois
mantém seus valores mesmo quando a
função termina
 Classe static
• Usa-se variáveis declaradas como static
normalmente para permitir que variáveis
locais guardem seus valores mesmo após o
término da execução do bloco onde são
declaradas
 Classe static
void soma();

void main()
{
soma();
soma();
soma();
getch();
}

void soma()
{
static int i=0;
i++;
printf("i = %d \n",i);
}
 Classe register
• A classe de armazenamento register indica
que a variável associada deve ser guardada
fisicamente numa memória de acesso
chamada registrador
• Um registrador da máquina é um espaço
onde podemos armazenar um int ou um char
• Cada máquina oferece um certo número de
registradores que podem ser manuseados
pelos usuários
 Classe register
• Basicamente variáveis register são usadas
para aumentar a velocidade de
processamento
• Fortes candidatas a este tratamento são as
variáveis de laços
• Segue a seguir um exemplo:
#include <time.h>

void main()
{
int i, j;
register int m,n;
long t;

t = time(0);
for(j=0;j<=10000;j++)
for(i=0;i<=10000;i++)
;
printf("Tempo = %ld\n",time(0)-t);

t = time(0);
for(m=0;m<=10000;m++)
for(n=0;n<=10000;n++)
;
printf("Tempo = %ld\n",time(0)-t);
getch();
}
Entrada e Saída com cin e cout
 Introdução
• Os objetos cin e cout são usados somente
em compiladores orientados a objetos
• Esses objetos não funcionam quando o
compilador não suporta orientação a objetos
• Se o compilador suporta orientação a
objetos é necessário incluir a biblioteca
<iostream.h>
 cout
• O objeto cout está associado à saída de
video
• É um dispositivo de saída que distingue o
tipo de dado
• Portanto não é necessário declarar o tipo a
ser enviado a saída, como necessariamente
o é, quando trabalhamos com o C
 cout
• Sintaxe:

cout << Valor de Saída

 Exemplo
#include <stdio.h>
#include <conio.h>
#include <iostream.h>

void main()
{
cout << "Testando Saida com COUT";
getch();
}
 cin
• O objeto de dados cin é um dispositivo que
envia o valor recebido para uma variável
• O objeto cin está associado ao teclado
• É um dispositivo de entrada de dados que
distingue o tipo de dado
 cin
• Sintaxe:

cin >> Variável

 Exemplo
#include <stdio.h>
#include <conio.h>
#include <iostream.h>

void main()
{
int numero;
cout << "Entre com um numero: ";
cin >> numero;
cout << numero;
getch();
}
 Exercícios
• Altere o programa feito para dizer se um
número é primo, de maneira que ele utilize
apenas os comandos cin e cout para entrada
e saída de dados
#include <iostream.h>
int primo(int numero);
void main(){
int entrada;
//printf("Digite um numero: ");
cout << "Digite um numero ";
//scanf("%d",&entrada);
cin >> entrada;
if(primo(entrada))
//printf("\nNumero Primo");
cout << "\nNumero Primo";
else //printf("\nNumero nao Primo");
cout << "\nNumero nao Primo";
getch();
}
int primo(int numero){
int i;
for(i=2;i<numero;i++)
{
if ((numero % i) == 0)
return 0;
}
return 1;
}
Variáveis Compostas
Homogêneas
 Introdução
• Uma variável do tipo composta homogênea
é usada para representar uma certa
quantidade de valores homogêneos
• Imagine o seguinte problema:
– Guardar na memória do computador 50 notas
de prova. Calcular e mostrar a média dessas
notas.
 Introdução
• Pelo que conhecemos até o momento da
linguagem C, a única forma para resolver
este problema é declararmos 50 variáveis e
atribuir as 50 notas a essas variáveis
• É evidente que precisamos de outra maneira
para referenciar tais coleções de dados
similares
 Introdução
• Para tanto, foi criado um novo conceito
para alocação de memória sendo, desta
forma, também criado uma nova maneira de
definir variáveis, a qual foi denominada de
variável indexada.
 Introdução
• Uma variável indexada corresponde a uma
seqüência de posições de memória, a qual
daremos único Nome, sendo que cada uma
destas pode ser acessada através do que
conhecemos por índice.
• O índice corresponde normalmente a um
valor númerico
 Introdução
• Cada uma das posições de memória de uma
variável indexada pode receber valores no
decorrer do programa como se fosse uma
variável comum, a única diferença reside na
sintaxe de utilização desta variável.
 Variáveis Indexadas
Unidimensionais
• Também conhecida por Vetor
Unidimensional
• Um vetor unidimensional é aquele em que o
acesso a um de seus componentes é feito
através de um único índice
 Declarando um Vetor
Unidimensional
• Sintaxe:
Tipo Nome[tamanho];

• Onde:
• Tipo: Declara o tipo de dado que cada
elmento irá conter
• Nome: Identificador do Vetor
• Tamanho: Define quantos elementos
conterá o vetor
 Referenciando Elementos do
Vetor
• Uma vez declarado o vetor, precisamos de
um modo de referenciar seus elementos
individualmente
• Isto é feito através de um índice entre
colchetes seguindo o nome do vetor

Vetor[índice]
 Referenciando Elementos do
Vetor
• Atribuindo valores as posições do vetor
NomeVetor[índice] = Valor;

• Lendo valores do vetor

printf(“%d”,NomeVetor[índice]);
Variavel = NomeVetor[índice];
 Exemplo
#define NUM_NOTAS 50

void main()
{
float nota[NUM_NOTAS];
float soma=0;
int i;
for(i=0;i<NUM_NOTAS;i++)
{
printf("Entre com uma nota: ");
scanf("%f",&nota[i]);
}
for(i=0;i<NUM_NOTAS;i++)
soma = soma + nota[i];
printf("\nMedia = %f",soma/NUM_NOTAS);

for(i=0;i<NUM_NOTAS;i++)
printf("\nNota %d: %f",i,nota[i]);
getch();
}
 Inicializando um Vetor
• Em C a inicialização de um vetor pode ser
feita em tempo de compilação
• Exemplo:

float nota[3] = {0,0,0};

 Exercício
• Faça um programa que leia, via teclado, 200
valores do tipo inteiro e os guarde na
memória. Após isso:
– Emita um relatório com todos os números pares
que você leu.
– Determine qual é o menor e o maior número do
vetor
– Determine a somatória dos elementos do vetor
 Solução
int vetor[TAM];
int i,soma=0,maior,menor;
for(i=0;i<TAM;i++)
{
printf("Entre com um Numero: ");
scanf("%d",&vetor[i]);
}

printf("\nNumeros Pares");
for(i=0;i<TAM;i++)
if((vetor[i] % 2) == 0)
printf("\n%d",vetor[i]);
 Solução
maior = vetor[0];
menor = vetor[0];
for(i=1;i<TAM;i++)
{
if(vetor[i] > maior)
maior = vetor[i];
if(vetor[i] < menor)
menor = vetor[i];
}
printf("\nMaior = %d, Menor = %d",maior,menor);

printf("\nSomatoria: ");
for(i=0;i<TAM;i++)
soma += vetor[i];
printf("\n%d",soma);
 Exercício
• Faça um programa para ler uma seqüência
de 40 notas e mostrar quais as notas
maiores que a média dessas notas
 Solução
void main()
{
float vetor[TAM];
int i;
float media,soma=0;
for(i=0;i<TAM;i++)
{
printf("Entre com uma nota: ");
scanf("%f",&vetor[i]);
soma += vetor[i];
}
media = (float)soma/TAM;

for(i=0;i<TAM;i++)
if(vetor[i]>media)
printf("\n%f",vetor[i]);
getch();
}
 Variáveis Indexadas
Bidimensionais
• Também conhecida por Matriz
• Um vetor bidimensional é aquele em que o
acesso a um de seus componentes é feito
por meio de dois índices (comumente
chamados de linha e coluna)
 Declarando uma Matriz
• Sintaxe:
Tipo NomeMatriz[QtdLinhas][QtdColunas];

• Onde:
• Tipo: Declara o tipo de dado que cada
elemento irá conter
• NomeMatriz: Identificador da Matriz
• QtdLinha e QtdColunas: Define quantos
elementos conterá a matriz (linha x coluna)
 Referenciando Elementos da
Matriz
• Uma vez declarada a matriz, precisamos de
um modo de referenciar seus elementos
individualmente
• Isto é feito através de dois índices entre
colchetes seguindo o nome do vetor

Matriz[linha][coluna]
 Referenciando Elementos da
Matriz
• Atribuindo valores as posições da matriz
NomeMatriz[linha][coluna] = Valor;

• Lendo valores da matriz

printf(“%d”,NomeMatriz[linha][coluna]);
Variavel = NomeMatriz[linha][coluna];
 Exemplo
#define TAM 3
void main()
{
int matriz[TAM][TAM];
int linha, coluna;
for(coluna=0;coluna<TAM;coluna++)
for(linha=0;linha<TAM;linha++)
{
printf("Entre com um numero: ");
scanf("%d",&matriz[linha][coluna]);
}

for(linha=0;linha<TAM;linha++)
{
for(coluna=0;coluna<TAM;coluna++)
{
printf("%d ",matriz[linha][coluna]);
}
printf("\n");
}
}
 Inicializando uma Matriz
• Em C a inicialização de uma matriz também
pode ser feita em tempo de compilação
• Exemplo:

int matriz[3][3] = {{0,0,0},

{0,0,0},
{0,0,0}};
 Exercício
• Faça um programa que diga se uma matriz
4x4 é simétrica
#define TAM 4
void main()
{
int matriz[TAM][TAM] = {{0,1,2,3},{1,0,1,2},
{2,1,0,5},{3,2,5,0}};
int linha, coluna, simetrica=1;
for(linha=0;linha<TAM;linha++)
{
for(coluna=linha+1;coluna<TAM;coluna++)
if(matriz[linha][coluna] != matriz[coluna][linha])
{
simetrica = 0;
break;
}
if(!simetrica)
break;
}
if(simetrica)
printf("Matriz Simetrica");
else printf("Matriz nao Simetrica");

getch();

}
 Exercício
• Dada uma matriz 3x4, faça um programa
que determine sua transposta e a imprima
 Solução
#define TAML 3
#define TAMC 4
void main()
{
int matriz[TAML][TAMC] = {{0,1,2,3},
{1,0,1,2},
{2,1,0,5}};
int linha, coluna;
for(coluna=0;coluna<TAMC;coluna++)
{
for(linha=0;linha<TAML;linha++)
printf("%d ",matriz[linha][coluna]);
printf("\n");
}

getch();
}
 Exercício
• Dadas duas matrizes 4x4, faça um programa
que some as duas e gera uma terceira matriz
com o resultado.
 Solução
#define TAM 4
void main()
{
int matriz1[TAM][TAM] = {{0,1,2,3},{1,0,1,2},
{2,1,0,5},{2,1,0,5}};
int matriz2[TAM][TAM] = {{0,1,2,3},{1,0,1,2},
{2,1,0,5},{2,1,0,5}};
int matriz_soma [TAM][TAM];
int linha, coluna;
for(linha=0;linha<TAM;linha++)
{
for(coluna=0;coluna<TAM;coluna++)
matriz_soma[linha][coluna] = matriz1[linha][coluna]+
matriz2[linha][coluna];
}
}
 Exercício
• Dadas duas matrizes de ordem 3x2 e 2x3,
faça um programa que calcule o produto
dessas matrizes e o imprima para o usuário.
• Exemplo:

31 (3 * 2) + (1 * 7) (3 * 0) + (1 * 5) ...
20 203 (2 * 2) + (0 * 7)
46 758
void main()
{
int m1[3][2] = {{0,1},{1,0},{2,1}};
int m2[2][3] = {{0,1,2},{1,0,1}};
int lm1, cm2, i, r;

for(lm1=0;lm1<3;lm1++)
{
for(cm2=0;cm2<3;cm2++)
{
r = 0;
for(i=0;i<2;i++)
{
r = r + (m1[lm1][i] * m2[i][cm2]);
}
printf("%d ",r);
}
printf("\n");
}

}
 Exercício Proposto
• Dada uma matriz (NxN) de inteiros,
construa um programa para solicitar um
número do usuário e verifique se este
número pertence a matriz
 Vetores como Argumentos de
Funções
• Temos visto exemplos de passagem de
vários tipos de variáveis como argumentos
• C permite também passar uma matriz para
uma função
• Vejamos o seguinte exemplo:
int max(int vet[]);
void main()
{
int vetor[TAM];
int i = 0;
do
{
printf("Entre com um numero: ");
scanf("%d",&vetor[i]);
i++;
}
while(i<TAM);
printf("NumMax = %d",max(vetor));
}

int max(int vet[])

{
int i, maior;
maior = vet[0];
for(i=1;i<TAM;i++)
if(maior < vet[i])
maior = vet[i];
return(maior);
}
 Vetores como Argumentos de
Funções
• A parte crítica a ser considerada aqui é
como foi passada a matriz para a função
• Para tanto, usa-se unicamente o nome da
matriz
• O nome de uma matriz desacompanhado de
colchetes é equivalente ao endereço da
matriz
 Curiosidade
• O que você acha, a condição abaixo é
verdadeira ou falsa:

int list[40];

list = = &list[0]
 Exercício
• Construa uma função em C para copiar uma
sub-string de uma string. A função deve
possuir os seguintes parâmetros:
– String de origem
– Posição para inicio da cópia
– Quantidade de caracteres a serem copiados
– String que conterá a sub-string copiada
void substr(char str_origem[], int i, int qtdade, char sub_str[]);

void main()
{
char str[10] = "Faculdade";
char parte_str[10];
substr(str,0,2,parte_str);
printf("%s",parte_str);
getch();
}

void substr(char str_origem[], int i, int qtdade, char sub_str[])

{
int nc;
for(nc=0;nc<qtdade;nc++)
{
sub_str[nc] = str_origem[i];
i++;
}
sub_str[nc] = '\0';
}
 Matrizes como Argumentos de
Funções
• A passagem de uma matriz para uma função
é similar à passagem de um vetor
• O método de passagem do endereço da
matriz para a função é idêntico, não
importando quantas dimensões tem a
matriz, visto que sempre passamos o
endereço da matriz
 Matrizes como Argumentos de
Funções
• Entretanto, a declaração da matriz na
função é diferente
• É necessário informar o número de colunas
da matriz que função receberá

void qualquer_funcao(int matriz[][TAMC])

{
}
 Exercício
• Construa uma função para mostra a
transposta de uma matriz (passe a matriz
como argumento da função)
 Solução
void transposta(int m_origem[][TAMC])
{
int linha, coluna;
for(coluna=0;coluna<TAMC;coluna++)
{
for(linha=0;linha<TAML;linha++)
printf("%d ",m_origem[linha][coluna]);
printf("\n");
}
}
 Manipulação de Strings :
Funções para Manipulação
 A Função strcmp()
• Analisemos o seguinte problema:

Void main()
{
char str_a[10], str_b[10];

if(str_a == str_b)
printf(“Iguais”);
}
 A Função strcmp()
• Este programa não trabalhará corretamente,
pois str_a e str_b são endereços
• Sendo assim, a expressão str_a == str_b não
pergunta se as strings são iguais, mas sim se
seus endereços são iguais
• Uma comparação de strings deve sempre
ser feita por meio da função strcmp()
 A Função strcmp()
• A função retorna 0 se as strings são iguais e
outro número qualquer caso contrário
void main()
{
char str_a[10]="teste", str_b[10]="teste";

if(strcmp(str_a,str_b) == 0)
printf("Iguais");
getch();
}
 A Função strcat()
• A função strcat() concatena duas strings,
isto é, junta uma string ao final de outra
• Ela toma dois endereços de string como
argumento e copia a segunda string no final
da primeira e esta combinação gera uma
nova primeira string
• A segunda string não é alterada
 A Função strcat()

void main()
{
char str_a[10]="Teste", str_b[10]=" de LPI";
strcat(str_a,str_b);
printf("%s",str_a);
getch();
}
 A Função strcpy()
• A função strcpy() copia uma string em outra
string

void main()
{
char str_a[10]="LPI", str_b[10];
strcpy(str_b,str_a);
printf("%s",str_b);
getch();
}
 Exercício
• Encontre no help do seu compilador C as
funções para tornar um texto todo em letras
minúsculas e para tornar um texto todo em
maiúsculas. Aplique essas funções em
algum programa em C.
 Exercício
• Construa uma função para retornar a
quantidade de ocorrências de uma
determinada letra do alfabeto em uma
palavra ou frase. Obs.: Tanto a palavra
como a letra devem ser passados como
parâmetros para a função.
 Solução

int num_vogal(char v, char str[])

{
int cont = 0, i;
for(i=0;i<strlen(str);i++)
if(str[i] == v)
cont = cont + 1;
return(cont);
}
 Exercício
• Dado um vetor com 50 elementos inteiros,
faça um programa que verifique se um dado
valor existe neste vetor. Use uma função
onde o retorno deve ser a posição do
número procurado no vetor ou –1 caso o
número não exista.
 Solução

int procura(int num, int vet[])

{
int i;
for(i=0;i<TAM;i++)
if(num == vet[i])
return(1);
return(-1);
}
Os Argumentos da Função
main()
 Introdução
• Algumas vezes é útil passar informações
para um programa ao executá-lo
• Você pode passar informações para a
função main() usando argumentos de linha
de comando
• Um argumento de linha de comando é a
informação que segue o nome do programa
na linha de comando do sistema operacional
 argc e argv
• Você usa dois argumentos intrínsecos –
argv e argc para receber os argumentos da
linha de comando
• Estes são os únicos argumentos que main()
pode ter
• O parâmetro argc contém o número de
argumentos na linha de comando e é um
inteiro
 argc e argv
• Ele será pelo menos 1, porque o nome do
programa se qualifica como o primeiro
argumento
• O parâmetro argv é um ponteiro para um
vetor de strings
• Assim sendo, todos os argumentos entrados
por linha de comando são considerados
strings
 Exemplo – entrada.cpp
#include <stdio.h>
#include <conio.h>

int main(int argc, char *argv[])

{
if(argc != 2)
printf("Voce esqueceu de digitar seu nome!");
else printf("Hello, %s", argv[1]);
getch();
}
 argc e argv
• Os argumentos passados para o programa
devem ser separados por espaços
• A linguagem C, não considera a vírgula, o
ponto-e-vírgula e outros como separadores
 Exemplo – soma.cpp

#include <stdio.h>
#include <conio.h>
#include <stdlib.h>

int main(int argc, char *argv[])

{
printf("%d", atoi(argv[1]) + atoi(argv[2]));
getch();
}
 argc e argv
• É possível também acessar caracteres
individuais das strings passadas como
argumentos do programa
• Para tanto, deve ser acrescentado um novo
índice a argv
• Veja o exemplo seguinte:
 Exemplo

int main(int argc, char *argv[])

{
int i;
for(i=0;i<strlen(argv[1]);i++)
printf("\n%c",argv[1][i]);
getch();
}
 Exercício
• Construa um programa que receba a entrada
de um número passado como argumento e
calcule o fatorial deste número
 Solução
#include <stdlib.h>

void main(int argc, char *argv[])

{
if(argc < 2)
printf("Voce esqueceu o numero!");
else
{
int resultado = 1, n;
n = atoi(argv[1]);
while(n > 0)
{
resultado = resultado * n;
n--;
}
printf("O fatorial eh igual a %d",resultado);
}
getch();
}
 Exercício
• Construa um programa que receba a entrada
de uma string passada como argumento e
mostre o número de vogais existentes na
string
 Solução
void main(int argc, char *argv[])
{
int i, cont=0;
for(i=0;i<strlen(argv[1]);i++)
{
switch (argv[1][i])
{
case 'a' : {cont++;break;}
case 'e' : {cont++;break;}
case 'i' : {cont++;break;}
case 'o' : {cont++;break;}
case 'u' : {cont++;break;}
}
}
printf("%d",cont);
getch();
}
Operações com Arquivos em
Disco
 Introdução
• Operações em discos são executadas em
entidades chamadas “arquivos”
• Um arquivo é uma coleção de bytes
referenciados por um nome único
• O acesso ao arquivo (leitura ou gravação)
pode ser feito tanto em modo texto como
binário
 Introdução
• C oferece um pacote de funções de biblioteca que
nos permite acessar arquivos de quatro modos
diferentes
• CARACTERE (modo texto):
– getc() e putc()
• STRING (modo texto):
– fgets() e fputs()
• FORMATADA (modo texto):
– fscanf() e fprintf()
• REGISTRO (modo binário):
– fread() e fwrite()
 Introdução
• Antes de iniciarmos a aplicação prática da
utilização de arquivos, precisamos ainda
entender dois conceitos:
– A estrutura FILE
– A função fopen()
– A função fclose()
 A Estrutura FILE
• Para que um arquivo em disco seja utilizado
por um programa C, é necessário que o
programador defina um ponteiro para a
estrutura FILE
• Sempre que um arquivo do disco é acessado
são carregadas informações sobre esse
arquivo em uma estrutura FILE
 A Estrutura FILE
• Essas informações podem ser: tamanho do
arquivo, status do arquivo, buffers de dados,
ponteiros para o arquivo do disco, etc...
• Assim sendo, é necessário que uma variável
(do tipo ponteiro) tenha essas informações
para o programa C
• Exemplo:
FILE *fptr;
 A Função fopen()
• A função fopen() é utilizada para abrir um
arquivo do disco (carregar a estrutura FILE)
• Ela retorna um ponteiro para a estrutura
FILE
• A função fopen() possui como primeiro
parâmetro uma string que indica o caminho
e nome do arquivo a ser aberto
• O segundo parâmetro da função fopen() é o
modo que arquivo será aberto (veja os tipos
possíveis no slide seguinte)
 A Função fopen()
• Modos para abertura de arquivo:
– “r” : Abrir um arquivo texto para leitura. O arquivo
deve estar presente no disco.
– “w” : Abrir um arquivo texto para gravação. Se o
arquivo estiver presente ele será destruído e
reinicializado. Se não existir, ele será criado.
– “a” : Abrir um arquivo texto para gravação. Os dados
serão adicionados ao fim do arquivo existente, ou um
novo arquivo será criado.
– “r+”, “w+” e “a+” : Como a descrição dos anteriores,
porém ambas, leitura ou gravação podem ser utilizadas
 A Função fopen()
• Exemplo:

FILE *fptr;
fptr = fopen(“arq.txt”,”w”);
 A Função fclose()
• Quando terminamos as operações em um
arquivo precisamos fechá-lo
• Fechar um arquivo provoca dois efeitos:
– Qualquer coisa que permanece no buffer é
gravada
– Libera a estrutura FILE para que seja utilizada
para abertura de outro arquivo
 A Função fclose()
• Exemplo:

FILE *fptr;
fptr = fopen(“arq.txt”,”w”);
// Operações com o arquivo
fclose(fptr);
Operações com Arquivos em
Disco
Gravando e Lendo um Arquivo
Caractere a Caractere
 Exemplo
#include <conio.h>
#include <stdio.h>

void main()
{
FILE *fptr;
char ch;
fptr = fopen("arqtext.txt","w");
while((ch=getche()) != '\r')
putc(ch,fptr);
fclose(fptr);
}
 A Função putc()
• A função putc() grava um caractere em um
arquivo
• No exemplo, putc() toma um caractere
(desde que este não seja o <enter>) e o
grava no arquivo cuja estrutura FILE é
apontada por fptr (ponteiro para o arquivo)
 Exemplo
#include <conio.h>
#include <stdio.h>

void main()
{
FILE *fptr;
int ch;
fptr = fopen("arqtext.txt","r");
while((ch=getc(fptr)) != EOF)
printf("%c",ch);
fclose(fptr);
getch();
}
 A Função getc()
• A função getc lê um caractere por vez de
um arquivo
• No exemplo, getc() lê um caractere por vez
do arquivo apontado por fptr até que o final
do arquivo seja encontrado
 Exercício
• Construa um programa que conte a
quantidade de caracteres do interior de uma
arquivo texto
 Solução
#include <conio.h>
#include <stdio.h>

void main()
{
FILE *fptr;
int cont=0;
fptr = fopen("arqtext.txt","r");
while(getc(fptr) != EOF)
cont++;
fclose(fptr);
printf("%d",cont);
getch();
}
 Exercício
• Complemente o programa anterior para
contar apenas as vogais
 Solução
void main()
{
FILE *fptr;
int ch, cont=0;
fptr = fopen("arqtext.txt","r");
while((ch = getc(fptr)) != EOF)
switch (ch)
{
case 'a' : {cont++;break;}
case 'e' : {cont++;break;}
case 'i' : {cont++;break;}
case 'o' : {cont++;break;}
case 'u' : {cont++;break;}
}
fclose(fptr);
printf("%d",cont);
getch();
}
Operações com Arquivos em
Disco
Gravando e Lendo um Arquivo Linha
a Linha
 Exemplo
#include <conio.h>
#include <stdio.h>
#include <string.h>

void main()
{
FILE *fptr;
char string[51];
fptr = fopen("arqtext.txt","w");
while(strlen(gets(string))>0)
{
fputs(string,fptr);
fputs("\n",fptr);
}
fclose(fptr);
}
 A Função fputs()
• A função fputs() grava uma string em um
arquivo
• No exemplo, fputs() grava o conteúdo da
variável string no arquivo que é apontado
por fptr (ponteiro para o arquivo)
• Vale ressaltar que a função fputs() não
coloca, automaticamente, o caractere de
nova-linha no fim de cada linha
 Exemplo
#include <conio.h>
#include <stdio.h>
#include <string.h>

void main()
{
FILE *fptr;
char string[51];
fptr = fopen("arqtext.txt","r");
while(fgets(string,51,fptr) != NULL)
printf("%s",string);
fclose(fptr);
getch();
}
 A Função fgets()
• A função fgets() é o complemento de
fputs(), isto é, fgets() lê uma linha por vez
de um arquivo texto
• No exemplo, fgets() faz a leitura de uma
string, do arquivo texto, de tamanho 51 e
adiciona o conteúdo na variável string
• fgets() retorna NULL quando chega ao final
do arquivo
 A Função fgets()
• A função fgets() inclui o caractere de nova
linha e o caractere de fim de string ao final
da string
Operações com Arquivos em
Disco
Gravando um Arquivo de Forma
Formatada
 Exemplo
void main()
{
FILE *fptr;
char titulo[51];
float preco;
fptr = fopen("arqtext.txt","w");
do
{
printf("\nDigite o titulo e preco: ");
scanf("%s %f",titulo,&preco);
fprintf(fptr,"%s %f",titulo,preco);
printf("Continua s/n");
} while (getche()!= 'n');
fclose(fptr);
}
 A Função fprintf()
• Com a função fprintf() torna-se possível
formatar dados de várias maneiras,
inclusive escrever um valor de uma variável
numérica em um arquivo
• No exemplo, fprintf() foi utilizada para
escrever no arquivo o conteúdo de duas
variáveis, uma do tipo string e outra do tipo
float
• fprintf() assemelha-se muito a função
printf()
 A Função fprintf()
• Vale ressaltar que os dados escritos por
fprintf() são todos (independente do tipo)
gravados como caracteres
 Exemplo
void main()
{
FILE *fptr;
char titulo[51];
float preco;
fptr = fopen("arqtext.txt","r");
while(fscanf(fptr,"%s %f",titulo,&preco) != EOF)
printf("%s %f \n",titulo,preco);
fclose(fptr);
getch();
}
 A Função fscanf()
• A função fscanf() é similar à função scanf(),
exceto que, como em fprintf(), um ponteiro
para FILE seja incluído como primeiro
argumento
• No exemplo, fscanf() lê os dados do
arquivo escrito por fprintf()
 Exercício
• Escreva um programa que leia um arquivo
texto, escreva o arquivo na tela e no fim
mostre o número de linhas desse arquivo (é
sabido que no arquivo não existem linhas
com mais de 60 caracteres)
 Solução
void main()
{
FILE *fptr;
char string[61];
int cont=0;
fptr = fopen("arqtext.txt","r");
while(fgets(string,61,fptr) != NULL)
{
cont++;
printf("%s",string);
}
fclose(fptr);
printf("\nNumero Linhas = %d",cont);
getch();
}
Operações com Arquivos em
Disco
Gravando um Arquivo na Forma
Registro
 Introdução
• Nós já vimos como números podem ser
gravados usando as funções de leitura e
gravação formatada: fscanf() e fprintf()
• Entretanto, guardar números nos formatos
oferecidos por estas funções pode tomar um
grande espaço em disco, pois cada dígito é
armazenado como um caractere
 Introdução
• Estas funções apresentam ainda um outro
problema: não é a maneira direta de ler e
escrever tipos de dados complexos como
vetores, matrizes e estruturas
• Matrizes e estruturas são manuseadas
ineficientemente escrevendo cada elemento
da matriz um por vez
 Introdução
• O modo registro grava números em
arquivos em disco no formato binário
• Dessa forma, inteiros são gravados em dois
bytes, números em ponto flutuante em
quatro bytes, etc
• Também: vetores, matrizes e estruturas
podem ser gravadas com uma simples
instrução
void main()
{
struct {
char titulo[30];
int codigo;
float preco;
} livro;

char numstr[81];
FILE *fptr;
fptr = fopen("livros.dat","wb");
do{
printf("\nDigite o titulo: ");
gets(livro.titulo);
printf("\nDigite o codigo: ");
gets(numstr);
livro.codigo = atoi(numstr);
printf("\nDigite o preco: ");
gets(numstr);
livro.preco = atof(numstr);
fwrite(&livro,sizeof(livro),1,fptr);
printf("\nOutro livro (s/n)?");
}while(getche() == 's');
fclose(fptr);
}
 A Função fwrite()
• A função fwrite() toma 4 argumentos
• O primeiro é o endereço do dado (estrutura)
a ser gravado
• O segundo argumento é um número inteiro
que indica o tamanho do tipo de dado a ser
gravado
• O terceiro argumento é um número inteiro
que informa a fwrite() quantos itens do
mesmo tipo serão gravados
• O quarto é o ponteiro para a estrutura FILE
void main()
{
struct {
char titulo[30];
int codigo;
float preco;
} livro;

char numstr[81];
FILE *fptr;
fptr = fopen("livros.dat","rb");
while(fread(&livro,sizeof(livro),1,fptr) == 1)
{
printf("\nTitulo: %s",livro.titulo);
printf("\nCodigo: %d",livro.codigo);
printf("\nPreco: %f \n",livro.preco);
}
fclose(fptr);
getch();
}
 A Função fread()
• A função fread() toma 4 argumentos
• O primeiro é o endereço para o qual os
dados lidos serão armazenados
• O segundo indica a quantidade de bytes do
tipo de dado a ser lido
• O terceiro indica a quantidade de itens a
serem lidos
• O quarto é o ponteiro para a estrutura FILE
 Exercício
• Faça um programa para ler do teclado uma
matriz de dimensão (5x5) e gravar ela em
um arquivo
void main()
{
int matriz[5][5];
int l,c;
FILE *fptr;
fptr = fopen("matriz.dat","wb");
for(l=0;l<5;l++)
for(c=0;c<5;c++)
{
printf("Entre com um valor: ");
scanf("%d",matriz[l][c]);
}
fwrite(matriz,sizeof(matriz),1,fptr);
fclose(fptr);
getch();
}
 Exercício
• Leia do arquivo a matriz gravada no
exercício anterior
void main()
{
int matriz[5][5];
int l,c;
FILE *fptr;
fptr = fopen("matriz.dat","rb");
fread(matriz,sizeof(matriz),1,fptr);
for(l=0;l<5;l++)
{
for(c=0;c<5;c++)
{
printf("%d ",matriz[l][c]);
}
printf("\n");
}
fclose(fptr);
getch();
}
Cuidados ao Abrir Arquivos
 Por Que um Arquivo Pode Não
Ser Aberto ?
• Razões:
– Não exista mais espaço em disco
– Arquivo não exista (caso da leitura)
• Para tratar isso deve-se verificar o retorno
da função fopen()
• Se o arquivo não pode ser aberto, a função
fopen() devolve o valor NULL
 Exemplo
void main()
{
FILE *fptr;
if( (fptr = fopen("matriz.dat","rb")) == NULL)
{
printf("ERRO ao abrir o arquivo! ");
getch();
exit(0);
}
printf("Arquivo aberto com sucesso!");
fclose(fptr);
getch();
}