Escolar Documentos
Profissional Documentos
Cultura Documentos
Programação
- Introdução à Linguagem C -
ICEx/UFF
Volta Redonda-RJ
© 1999-2020
Introdução à Programação – Introdução à Linguagem C –
Sumário
Funções ..................................................................................................... 03
Perguntas Básicas para Criação de Funções ......................................... 03
Variáveis Locais ....................................................................................... 04
Chamando uma Função ........................................................................... 04
Passagem de Parâmetros por Valor (Cópia) .......................................... 05
Exercícios .................................................................................................. 06
Ponteiros ................................................................................................... 07
Operadores de Ponteiros ......................................................................... 07
Aritmética de Ponteiros ........................................................................... 08
Comparações com Ponteiros .................................................................... 09
Indireção Simples .................................................................................... 09
Indireção Múltipla ................................................................................... 09
Inicialização de Ponteiros ........................................................................ 10
Passagem de Argumentos por Referência .............................................. 12
Ponteiros e Vetores .................................................................................. 15
Exercícios .................................................................................................. 17
Alocação Dinâmica ................................................................................... 18
Exercícios .................................................................................................. 21
Registros ................................................................................................... 22
Registros Dentro de Registros ................................................................. 23
Vetores e Registros .................................................................................. 25
Registros e Ponteiros ............................................................................... 26
Exercícios .................................................................................................. 28
Arquivos .................................................................................................... 28
Acessando Arquivos em C ....................................................................... 29
Abertura e Fechamento de Arquivos ...................................................... 29
Modos de Abertura de Arquivos ............................................................. 29
Funções para Acessar Dados de Arquivos ............................................. 30
© 1999 – 2020 Prof. Dr. Adriano Caminha e Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – ICEx/UFF – Volta Redonda-RJ 2
Introdução à Programação – Introdução à Linguagem C –
Exercícios .................................................................................................. 34
© 1999 – 2020 Prof. Dr. Adriano Caminha e Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – ICEx/UFF – Volta Redonda-RJ 3
Introdução à Programação – Introdução à Linguagem C –
Funções
Sintaxe:
<tipo de retorno> <nome>(<parâmetros>)
{
<declaração das variáveis locais>
<bloco de instrução>
<valor de retorno se existir>
}
Onde:
<tipo de retorno> = float, int, void (“vazio” ou “sem valor de
retorno”), etc.
<nome> = nome da função que será utilizado nas chamadas à função.
<parâmetros> = Lista de valores recebidos pela função para o
cálculo ou tarefa. A função pode não ter parâmetros, neste caso os
parênteses ficarão vazios.
Variáveis Locais
© 1999 – 2020 Prof. Dr. Adriano Caminha e Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – ICEx/UFF – Volta Redonda-RJ 5
Introdução à Programação – Introdução à Linguagem C –
Exemplo:
#include <stdio.h>
//função que imprime n vezes um caracter ch
void imprimeCaracter(char ch, int n)
{ int i; //variável local
for(i=0; i<n; i++)
printf("%c", ch);
}
int main()
{ //os parâmetros devem ser chamados na ordem
//argumentos '*' e 35 (valores para ch e n)
imprimeCaracter('*', 35);
printf("\nEstudando passagem de parâmetros.\n");
//outra chamada
imprimeCaracter('#', 40);
printf("\n\n");
}
© 1999 – 2020 Prof. Dr. Adriano Caminha e Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – ICEx/UFF – Volta Redonda-RJ 6
Introdução à Programação – Introdução à Linguagem C –
#include <stdio.h>
//função que retorna o triplo de um real
float calcTriplo (float n) //n recebe valor de x
{ float triplo = 3 * n;
return triplo;
}
int main()
{ float x;
//leitura
printf("Digite um numero: ");
scanf("%f", &x);
© 1999 – 2020 Prof. Dr. Adriano Caminha e Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – ICEx/UFF – Volta Redonda-RJ 7
Introdução à Programação – Introdução à Linguagem C –
Exercícios
© 1999 – 2020 Prof. Dr. Adriano Caminha e Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – ICEx/UFF – Volta Redonda-RJ 8
Introdução à Programação – Introdução à Linguagem C –
Ponteiros
Operadores de Ponteiros
Exemplo 1:
#include <stdio.h>
int main()
{ int x=10, y = 20;
int *p; //declara apontador p
© 1999 – 2020 Prof. Dr. Adriano Caminha e Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – ICEx/UFF – Volta Redonda-RJ 9
Introdução à Programação – Introdução à Linguagem C –
© 1999 – 2020 Prof. Dr. Adriano Caminha e Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – ICEx/UFF – Volta Redonda-RJ 10
Introdução à Programação – Introdução à Linguagem C –
Exemplo 2:
#include <stdio.h>
int main()
{ int y;
int *p, *q; //declara apontadores p e q
y = 10;
p = &y; //p "aponta" para y
q = p; //q "aponta" para p
*q = 40; //"apontado" por q recebe 40
printf("\ny=%d, *p=%d, *q=%d\n\n",y,*p,*q);
}
→ Ao final: y=40, *p=40, *q=40
Exemplo 3:
#include <stdio.h>
int main()
{ int *a; //a = apontador para vars int
int c, b=2;
a = &b; //a recebe o endereco de b
c = b;
//valor apontado por a, valor b, valor c
printf("\n\n*a=%d, b=%d, c=%d\n\n", *a, b, c);
b = 3;
//valor apontado por a, valor b, valor c
printf("\n\n*a=%d, b=%d, c=%d\n\n", *a, b, c);
}
Aritmética de Ponteiros
#include <stdio.h>
int main()
{ int *a; //a = apontador para vars int
int x = 10;
Os operadores:
Indireção Simples
Apontador → Endereço
Indireção Múltipla
© 1999 – 2020 Prof. Dr. Adriano Caminha e Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – ICEx/UFF – Volta Redonda-RJ 12
Introdução à Programação – Introdução à Linguagem C –
Exemplo 5:
#include <stdio.h>
int main()
{ int x, *p, **q; //q apontador para apontador
//de vars int
p = &x; //p aponta para x
q = &p; //q aponta para p
x = 100; //atribui valor a x
Inicialização de Ponteiros
Exemplo:
Errado Certo
int *p; int *p, x;
*p=100; //apontado por p? p=&x; //ok!
*p=100;
© 1999 – 2020 Prof. Dr. Adriano Caminha e Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – ICEx/UFF – Volta Redonda-RJ 14
Introdução à Programação – Introdução à Linguagem C –
Exemplo 6:
#include <stdio.h>
int main()
{ int *a, *b, x, y, aux;
x=10;
y=20;
a=&x; //ok, apontador inicializado
b=&y; //ok, apontador inicializado
//valor apontado a, valor apontado b
printf("\n*a=%d, *b=%d\n", *a, *b);
//troca
aux=*a;
*a=*b;
*b=aux;
//após a troca
printf("\nTroca: *a=%d, *b=%d\n", *a, *b);
}
Explicação:
→ Na passagem de argumentos por valor, trocam-se os valores
dentro da função, mas não na função chamadora, ou seja, não funciona
com passagem por valor!
© 1999 – 2020 Prof. Dr. Adriano Caminha e Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – ICEx/UFF – Volta Redonda-RJ 15
Introdução à Programação – Introdução à Linguagem C –
Exemplo 7:
#include <stdio.h>
void troca(int x, int y) //por valor
{ int aux;
aux = x;
x = y;
y = aux;
}
int main()
{ int x=10, y=20;
printf("\nx=%d, y=%d\n", x, y);
troca(x, y);
printf("\nTroca: x=%d, y=%d\n", x, y);
}
→ Na memória:
Endereço Comando
...
110 aux=a;
108 b=20; b=aux;
106 a=10; a=b;
104 y=20
102 x=10
...
Solução:
→ Utilizar passagem de argumentos por referência!
Exemplo 8:
#include <stdio.h>
void troca(int *x, int *y) //por referência
{ int aux;
© 1999 – 2020 Prof. Dr. Adriano Caminha e Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – ICEx/UFF – Volta Redonda-RJ 16
Introdução à Programação – Introdução à Linguagem C –
#include <stdio.h>
int main()
{ int *p1, valor, idade, *p4, *p5, vetor[3];
float *p2, temp;
char aux, *nome="Algoritmos", *p3;
//a
valor = 10;
p1 = &valor;
*p1 = 20;
printf("%d\n", valor);
//b
temp = 27.59;
p2 = &temp;
*p2 = 29.35;
printf("%f\n", temp);
//c
p3 = &nome[0];
aux = *p3;
printf("%c\n", aux);
//d
p3 = &nome[4];
© 1999 – 2020 Prof. Dr. Adriano Caminha e Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – ICEx/UFF – Volta Redonda-RJ 17
Introdução à Programação – Introdução à Linguagem C –
aux = *p3;
printf("%c\n", aux);
© 1999 – 2020 Prof. Dr. Adriano Caminha e Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – ICEx/UFF – Volta Redonda-RJ 18
Introdução à Programação – Introdução à Linguagem C –
//e
p3 = nome;
printf("%c", *p3);
//f
p3 = p3 + 4;
printf("%c\n", *p3);
//g
p3--;
printf("%c\n", *p3);
//h
vetor[0] = 33;
vetor[1] = 55;
vetor[2] = 27;
p4 = vetor;
idade = *p4;
printf("%d\n", idade);
//i
p5 = p4+1;
idade = *p5;
printf("%d\n", idade);
//j
p4 = p5+1;
idade = *p4;
printf("%d\n", idade);
//k
p4 = p4-2;
idade = *p4;
printf("%d\n", idade);
//l
p5 = &vetor[2]-1;
printf("%d\n", *p5);
//m
p5++;
printf("%d\n", *p5);
}
Saída:
20
29.350000
A
r
A
r
o
33
55
27
33
© 1999 – 2020 Prof. Dr. Adriano Caminha e Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – ICEx/UFF – Volta Redonda-RJ 19
Introdução à Programação – Introdução à Linguagem C –
55
27
#include <stdio.h>
int quadrado(int *a)
{ *a=(*a)*(*a);
return *a;
}
int main()
{ int x=10;
printf("\n\nQuadrado de %d=",x);
printf("%d\n\n", quadrado(&x));
}
Ponteiros e Vetores
Exemplo 9:
#include <stdio.h>
int main()
{ int i,*p, x[]={8,3,5,1,7};
p = x; //p aponta para o 1o elemento de x
for(i=0; i<5; i++)
{ printf("%d\t", *p);
p++;
}
printf("\n");
}
Exemplo 10:
#include <stdio.h>
int main()
{ int i, x[]={8,3,5,1,7};
for(i=0; i<5; i++)
© 1999 – 2020 Prof. Dr. Adriano Caminha e Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – ICEx/UFF – Volta Redonda-RJ 20
Introdução à Programação – Introdução à Linguagem C –
#include <stdio.h>
int main()
{ int v[]={10, 20, 30, 40, 50}, *p1, *p2, j, i=100;
for (j=0; j<5; j++)
printf("%d\t", v[j]); //elemento pelo índice
printf("\n");
p1=&v[2];
printf("%d\n", *p1);
p2=&i;
printf("%d\n", *p2);
p2=p1;
printf("%d\n", *p2);
p2++;
printf("%d\n", *p2);
p1=p1+2;
printf("%d\n", *p1);
}
#include <stdio.h>
//declaração permite implementação após a main
void strcop(char *d, char *o); //protótipo
int main()
{ char destino[30];
char *origem = "Cadeia de caracteres de origem.";
strcop(destino, origem);
printf("%s\n%s\n\n", origem, destino);
}
//implementação da função declarada
void strcop(char *d, char *o)
{ while( *o != '\0')
{ *d = *o;
o++;
© 1999 – 2020 Prof. Dr. Adriano Caminha e Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – ICEx/UFF – Volta Redonda-RJ 21
Introdução à Programação – Introdução à Linguagem C –
d++;
}
}
Solução:
#include <stdio.h>
void strcop(char *d, char *o); //protótipo
int main()
{ char destino[30];
char *origem="Cadeia de caracteres de origem.";
strcop(destino, origem);
printf("%s\n%s\n\n", origem, destino);
}
void strcop(char *d, char *o) //implementação
{ while( ( *d++ = *o++) != '\0' );
}
Exercícios
© 1999 – 2020 Prof. Dr. Adriano Caminha e Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – ICEx/UFF – Volta Redonda-RJ 23
Introdução à Programação – Introdução à Linguagem C –
Alocação Dinâmica
Sintaxe:
ponteiro = (tipo*)malloc(tam*sizeof(tipo));
Onde:
Exemplo 1:
#include <stdio.h>
#include <stdlib.h>
int main()
{ int *p; //declara apontador
© 1999 – 2020 Prof. Dr. Adriano Caminha e Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – ICEx/UFF – Volta Redonda-RJ 24
Introdução à Programação – Introdução à Linguagem C –
//alocar 50 inteiros:
p = (int*)malloc(50 * sizeof(int));
#include <stdio.h>
#include <stdlib.h>
int main()
{ float *v;
int i, tam;
//alocação:
v = (float*)malloc(tam * sizeof(float));
if( v == NULL )
{ printf("\nImpossivel alocar memória.\n");
return; //interrompe a execução
}
printf("\n\n");
free(v); //liberação
}
© 1999 – 2020 Prof. Dr. Adriano Caminha e Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – ICEx/UFF – Volta Redonda-RJ 25
Introdução à Programação – Introdução à Linguagem C –
#include <stdio.h>
#include <stdlib.h>
for (i=0;i<tam;i++)
{ printf("\n\nv[%d]: ", i);
scanf("%f", v+i); //leitura
}
printf("\n\nVetor: ");
for (i=0;i<tam;i++)
printf("%.2f\t", *(v+i));
}
return maior;
}
int main()
{ float *v, maior;
int tam, vezes;
printf("Digite o tamanho do vetor: ");
scanf("%d", &tam);
v=(float*)malloc(tam*sizeof(float));
if( v != NULL )
{ leImprime(v, tam);
maior = buscaMaior(v, tam, &vezes);
printf("\nMaior: %.2f e aparece %d vezes no
vetor.\n", maior, vezes);
free(v);
© 1999 – 2020 Prof. Dr. Adriano Caminha e Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – ICEx/UFF – Volta Redonda-RJ 26
Introdução à Programação – Introdução à Linguagem C –
}
else
printf("\nImpossivel alocar memória.\n");
}
© 1999 – 2020 Prof. Dr. Adriano Caminha e Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – ICEx/UFF – Volta Redonda-RJ 27
Introdução à Programação – Introdução à Linguagem C –
© 1999 – 2020 Prof. Dr. Adriano Caminha e Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – ICEx/UFF – Volta Redonda-RJ 28
Introdução à Programação – Introdução à Linguagem C –
Exercícios
→ Faça os exercícios da Lista 4.
© 1999 – 2020 Prof. Dr. Adriano Caminha e Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – ICEx/UFF – Volta Redonda-RJ 29
Introdução à Programação – Introdução à Linguagem C –
Registros
Forma Geral:
struct nomedoregistro {
elementos (variáveis separadas por “;”)
};
→ Este código cria o tipo registro chamado data que contém três
elementos: dia, mês e ano.
Exemplo:
hoje.dia = 10;
hoje.mes = “junho”;
hoje.ano = 2015;
printf(“%d de %s de %d\n”, hoje.dia, hoje.mes,
hoje.ano);
© 1999 – 2020 Prof. Dr. Adriano Caminha e Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – ICEx/UFF – Volta Redonda-RJ 30
Introdução à Programação – Introdução à Linguagem C –
Exemplo 1:
#include <stdio.h>
struct pessoa //cria tipo registro pessoa
{
char *nome;
int idade;
float altura;
};
int main()
{ struct pessoa p1; //declara variável
p1.nome="Maria de Souza";
p1.idade=32;
p1.altura=1.69;
printf("\nNome: %s\nIdade: %d\nAltura: %f\n\n",
p1.nome, p1.idade, p1.altura);
}
Exemplo:
struct data {
int dia;
char mes[10];
int ano;
};
struct pessoa {
char nome[60];
char end[80];
char fone[20];
struct data nascimento;
};
struct pessoa p;
p.nome = “José da Silva”;
p.end = “Rua A, 300”;
p.fone = “3333-2222”;
p.nascimento.dia = 20;
© 1999 – 2020 Prof. Dr. Adriano Caminha e Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – ICEx/UFF – Volta Redonda-RJ 31
Introdução à Programação – Introdução à Linguagem C –
p.nascimento.mes = “maio”;
p.nascimento.ano = 1985;
Exercício 2: Escrever um programa utilizando um registro dentro de
um registro. Dada a tabela abaixo, ler os dados do registro para uma pessoa
(nome, endereço, fone, altura, peso e nascimento) e calcular seu IMC.
Imprimir os dados lidos, o IMC e uma das mensagens de acordo com a
tabela.
#include <stdio.h>
//cria tipo registro
struct livro {
char *titulo;
int codigo;
float preco;
};
//prototipo da funcao
void imprime(struct livro b);
main()
{ //declara variável registro
struct livro book;
//define valores dos campos
book.titulo="Programando em C";
book.codigo=1452;
book.preco=99.99;
//chamada da funcao
imprime(book);
}
//funcao que recebe registro por valor/copia
void imprime(struct livro b)
{
© 1999 – 2020 Prof. Dr. Adriano Caminha e Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – ICEx/UFF – Volta Redonda-RJ 32
Introdução à Programação – Introdução à Linguagem C –
© 1999 – 2020 Prof. Dr. Adriano Caminha e Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – ICEx/UFF – Volta Redonda-RJ 33
Introdução à Programação – Introdução à Linguagem C –
Vetores e Registros
Exemplo 3:
-Programa que lê os dados de 3 livros.
-Considere a estrutura do exemplo anterior modificando o campo título para
vetor de char.
#include <stdio.h>
#define MAX 3
//cria tipo registro
struct livro {
char titulo[30]; //ja aloca espaço na memoria
int codigo;
float preco;
};
//prototipo da funcao
void imprime(struct livro v[]);
int main()
{ //declara vetor de registros
struct livro vb[MAX];
//leitura dos valores dos campos
int i;
printf("\n\nCadastro de livros\n\n");
for(i=0; i<MAX; i++)
{ printf("Titulo %d: ", i);
gets( vb[i].titulo);
printf("Codigo %d: ", i);
scanf("%d", &vb[i].codigo);
printf("Preco %d: ", i);
scanf("%f", &vb[i].preco);
fgetc(stdin); //limpa buffer
printf("\n");
}
printf("\n");
//chamada da funcao
imprime(vb);
}
//funcao que recebe vetor (por referencia)
void imprime(struct livro v[])
{ int i;
printf("Livros Cadastrados:\n");
© 1999 – 2020 Prof. Dr. Adriano Caminha e Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – ICEx/UFF – Volta Redonda-RJ 34
Introdução à Programação – Introdução à Linguagem C –
printf("--------------------------\n");
Registros e Ponteiros
© 1999 – 2020 Prof. Dr. Adriano Caminha e Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – ICEx/UFF – Volta Redonda-RJ 35
Introdução à Programação – Introdução à Linguagem C –
Exemplo 4:
#include <stdio.h>
#define MAX 5
struct livro {
char titulo[30];
int codigo; //4 bytes
float preco; //4 bytes
};
© 1999 – 2020 Prof. Dr. Adriano Caminha e Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – ICEx/UFF – Volta Redonda-RJ 36
Introdução à Programação – Introdução à Linguagem C –
int main()
{ struct livro vb[MAX];
//leitura
printf("\nCadastre os %d livros:\n\n", MAX);
leitura(vb);
//impressao
printf("Livros Cadastrados:\n");
printf("----------------------\n\n");
impressao(vb);
printf("----------------------\n\n");
}
Exercícios
→ Faça os exercícios da Lista 4.
Arquivos
© 1999 – 2020 Prof. Dr. Adriano Caminha e Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – ICEx/UFF – Volta Redonda-RJ 37
Introdução à Programação – Introdução à Linguagem C –
Acessando Arquivos em C
Exemplos:
r+ → leitura e escrita
rb → leitura modo binário
wb → escrita modo binário
rt → leitura modo texto
wt → escrita modo texto
Arquivo Texto
© 1999 – 2020 Prof. Dr. Adriano Caminha e Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – ICEx/UFF – Volta Redonda-RJ 39
Introdução à Programação – Introdução à Linguagem C –
Sintaxe:
int putc (int ch, FILE *fp);
Onde:
fp é um ponteiro de arquivo retornado por fopen.
ch é definido como int (2 bytes) mas apenas o byte menos significativo é
levado em conta.
Sintaxe:
int getc (FILE *fp);
Sintaxe:
char * fgets (char *s, int n, FILE *arq);
onde:
s é uma string a ser preenchida com os caracteres lidos, n é o número
máximo de caracteres (contando o ‘\0’) que podem ser lidos e arq é um
ponteiro para um arquivo já aberto (aberto para leitura).
© 1999 – 2020 Prof. Dr. Adriano Caminha e Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – ICEx/UFF – Volta Redonda-RJ 40
Introdução à Programação – Introdução à Linguagem C –
onde:
s é a string a ser escrita no arquivo e arq é um ponteiro para um arquivo já
aberto (aberto para escrita ou para append).
A função fputs() não acrescenta o caracter ‘\n’ após a string. Caso seja
necessário o uso do ‘\n’ como separador, ele deve ser estar presente na
string a ser escrita.
onde:
arq é um ponteiro para um arquivo já aberto,
formato é uma string representando o tipo das variáveis a serem escritas
(como no printf) e
<lista de variáveis> representa a lista de variáveis a serem escritas no
arquivo.
© 1999 – 2020 Prof. Dr. Adriano Caminha e Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – ICEx/UFF – Volta Redonda-RJ 41
Introdução à Programação – Introdução à Linguagem C –
onde:
arq é um ponteiro para um arquivo já aberto,
formato é uma string representando o tipo das variáveis a serem lidas
(como no scanf) e
<lista de variáveis> representa o nome das variáveis que receberão os
valores a serem lidos (como no scanf).
#include <stdio.h>
int main()
{
char ch;
FILE *in, *out; //ponteiros para arquivos
//fecha os arquivos
fclose(in);
© 1999 – 2020 Prof. Dr. Adriano Caminha e Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – ICEx/UFF – Volta Redonda-RJ 42
Introdução à Programação – Introdução à Linguagem C –
fclose(out);
}
© 1999 – 2020 Prof. Dr. Adriano Caminha e Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – ICEx/UFF – Volta Redonda-RJ 43
Introdução à Programação – Introdução à Linguagem C –
#include <stdio.h>
#include <stdlib.h>
int main()
{ FILE *fp;
char nome[50], c;
Arquivo binário
© 1999 – 2020 Prof. Dr. Adriano Caminha e Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – ICEx/UFF – Volta Redonda-RJ 44
Introdução à Programação – Introdução à Linguagem C –
Sintaxe:
int fwrite (<tipo> *item, int tam_item, int num_itens,
FILE *arq);
Onde:
<tipo> - qualquer um dos tipos conhecidos: int, char, float.
item - elemento a ser armazenado. Pode ser tanto um único valor passado
por referência quanto um vetor.
tam_item - número de bytes do item a ser armazenado.
num_itens - número de elementos de item. Se item for um ponteiro para
um único valor, este parâmetro será 1, em caso contrário, será o número de
elementos do vetor.
arq - Ponteiro para a estrutura FILE. Este valor é retornado pela chamada
fopen.
Sintaxe:
int fread (<tipo> *item, int tam_item, int num_itens,
FILE *arq);
Onde:
<tipo> - qualquer um dos tipos conhecidos: int, char, float.
item - elemento a ser lido. Ponteiro para a área de memória onde os
elementos serão armazenados. Pode ser um tanto um endereço de uma
variável quanto o nome de um vetor.
tam_item - número de bytes do item a ser lido.
© 1999 – 2020 Prof. Dr. Adriano Caminha e Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – ICEx/UFF – Volta Redonda-RJ 45
Introdução à Programação – Introdução à Linguagem C –
#include <stdio.h>
#include <stdlib.h>
int main()
{
int i;
char ch[20] = "Arquivo Binário";
int valor[20] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
12, 13, 14, 15, 16, 17, 18, 19, 20};
FILE *in;
in = fopen("binario.bin", "wb");
if( in == NULL )
{ printf("Impossivel abrir o arquivo");
return;
}
fwrite(ch, sizeof(char), 20, in);
fwrite(valor, sizeof(int), 20, in);
}
in = fopen("binario.bin", "rb");
if(in == NULL)
{ printf("Impossivel abrir O arquivo");
return;
}
© 1999 – 2020 Prof. Dr. Adriano Caminha e Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – ICEx/UFF – Volta Redonda-RJ 46
Introdução à Programação – Introdução à Linguagem C –
printf("\n");
printf("\n");
fclose(in);
}
#include <stdio.h>
#include <stdlib.h>
#define MAX 2
struct pessoa{
char nome[40];
int dia;
char mes[20];
int ano;
};
int main()
{ int i;
FILE *pa;
char arquivo[40];
struct pessoa dados[MAX], dadosarq[MAX];
© 1999 – 2020 Prof. Dr. Adriano Caminha e Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – ICEx/UFF – Volta Redonda-RJ 47
Introdução à Programação – Introdução à Linguagem C –
puts("Imprimindo\n");
for(i=0; i<MAX; i++)
{
printf("Dia = %d \n", dados[i].dia);
printf("Mes = %s \n", dados[i].mes);
printf("Ano = %d \n\n", dados[i].ano);
}
puts("Gravando \n\n");
if((pa = fopen(arquivo, "w+b")) == NULL)
{
puts("Arquivo nao pode ser aberto");
exit(1); //saida com codigo 1 (erro)
}
//gravacao
for(i=0; i<MAX; i++)
if(fwrite(&dados[i], sizeof(struct pessoa), 1, pa)!= 1)
{
puts("Erro na escrita");
}
//leitura
rewind(pa); //aponta para o inicio do arquivo
for(i=0; i<MAX; i++) {
if(fread(&dadosarq[i], sizeof(struct pessoa), 1, pa)!=1)
{
puts("Erro na leitura");
}
if( feof(pa) ) //se fim, erro
{
puts("Erro na leitura");
break;
}
}
© 1999 – 2020 Prof. Dr. Adriano Caminha e Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – ICEx/UFF – Volta Redonda-RJ 48
Introdução à Programação – Introdução à Linguagem C –
Exercícios
© 1999 – 2020 Prof. Dr. Adriano Caminha e Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – ICEx/UFF – Volta Redonda-RJ 49