Introdução C Linguagem Programação

CURSO DE PÓS-GRADUAÇÃO
“LATO SENSU” (ESPECIALIZAÇÃO) A DISTÂNCIA

ADMINISTRAÇÃO EM REDES LINUX
INTRODUÇÃO À LINGUAGEM C
2 Edição
João Carlos Giacomin
UFLA - Universidade Federal de Lavras

FAEPE - Fundação de Apoio ao Ensino, Pesquisa e Extensão
Lavras – MG
PARCERIA
UFLA – Universidade Federal de Lavras
FAEPE – Fundação de Apoio ao Ensino, Pesquisa e Extensão
REITOR
Fabiano Ribeiro do Vale
VICE-REITOR
Antônio Nazareno Guimarães Mendes
DIRETOR DA EDITORA
Marco Antônio Rezende Alvarenga
PRÓ-REITOR DE PÓS-GRADUAÇÃO
Luiz Edson Mota de Oliveira
PRÓ-REITOR ADJUNTO DE PÓS-GRADUAÇÃO “LATO SENSU”
Antônio Ricardo Evangelista
COORDENADOR DO CURSO
Joaquim Quinteiro Uchôa
PRESIDENTE DO CONSELHO DELIBERATIVO DA FAEPE
Antônio Eduardo Furtini Neto
EDITORAÇÃO
Grupo Ginux (http://ginux.comp.ufla.br/)
IMPRESSÃO
Gráfica Universitária/UFLA
Ficha Catalográfica preparada pela Divisão de Processos Técnicos

da Biblioteca Central da UFLA
Giacomin, João Carlos
Introdução à Linguagem C / João Carlos Giacomin. – 2. ed. Lavras:

UFLA/FAEPE, 2002.
105 p.: il. - Curso de Pós-Graduação “Lato Sensu” (Especialização) a
Distância: Administração em Redes Linux
Bibliografia.
1. Programa de Computador. 2. Linguagem de Programação. 3.

Linguagem C. 4. Informática. I. Giacomin, J.C. II Universidade Federal de
Lavras. III. Fundação de Apoio ao Ensino, Pesquisa e Extensão. IV. Título.
CDD 005.133
Nenhuma parte desta publicação pode ser reproduzida, por qualquer

meio ou forma , sem a prévia autorização.
SUMÁRIO
1 Introdução 11
1.1 Linguagens de Máquina, Linguagens de Montagem, e Linguagens de Alto-
Nível . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.2 A História do C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
1.3 A Biblioteca padrão C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
1.4 Características de C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
1.5 C e C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
1.6 O Compilador GCC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2 Estrutura de um Programa em C 17
2.1 Visão Geral de um Programa C . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.2 Um Programa Utilizando uma Função . . . . . . . . . . . . . . . . . . . . . 19
3 Sintaxe 21
3.1 Identificadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
3.2 Tipos de Variáveis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
3.2.1 Tipos Básicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
3.3 Declaração e Inicialização de Variáveis . . . . . . . . . . . . . . . . . . . . 23
3.4 Operadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
3.4.1 Operador de Atribuição . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
3.4.2 Operadores Aritméticos . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
3.4.3 Operadores Relacionais e Lógicos . . . . . . . . . . . . . . . . . . . . . 27
3.4.4 Precedência . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
3.4.5 Operador cast (Modelador) . . . . . . . . . . . . . . . . . . . . . . . . . 29
3.4.6 Operador sizeof . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
4 Funções Básicas da Biblioteca C 33

4.1 Função printf( ) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
4.2 Função scanf( ) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
4.3 Função getchar() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
4.4 Função putchar() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
5 Estruturas de Controle de Fluxo 39

5.1 If . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
5.2 If-else-if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
5.3 Operador Ternário . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
5.4 Switch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
5.5 Loop for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
5.6 While . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
5.7 Do-while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
5.8 Break . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
5.9 Continue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
6 Matrizes 53
6.1 Matriz Unidimensional . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
6.2 Matriz Multidimensional . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
6.3 Matrizes Estáticas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
6.4 Limites das Matrizes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
7 Manipulação de Strings 57
7.1 Função gets() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
7.2 Função puts() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
7.3 Função strcpy() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
7.4 Função strcat() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
7.5 Função strcmp() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
8 Ponteiros 61
8.1 Declarando Ponteiros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
8.2 Manipulação de Ponteiros . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
8.3 Expressões com Ponteiros . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
8.4 Ponteiros para Ponteiros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
8.5 Problemas com Ponteiros . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
9 Ponteiros e Matrizes 67
9.1 Manipulando Matrizes através de Ponteiros . . . . . . . . . . . . . . . . . . 68
9.2 String e Ponteiros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
9.3 Matrizes de Ponteiros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
10 Funções 71
10.1 Função sem Retorno . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
10.2 Função com Retorno . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
10.3 Parâmetros Formais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
10.3.1 Chamada por Valor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
10.3.2 Chamada por Referência . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
10.4 Classes de Variáveis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
10.4.1 Variáveis Locais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
10.4.2 Variáveis Globais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
10.4.3 Variáveis Estáticas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
10.5 Funções com Matrizes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
10.5.1 Passando Parâmetros Formais . . . . . . . . . . . . . . . . . . . . . . . 78
10.5.2 Alterando os Valores da Matriz . . . . . . . . . . . . . . . . . . . . . . . 80
11 Argumentos da Linha de Comando 81
12 Tipos de Dados Definidos Pelo Usuário 83

12.1 Estruturas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
12.1.1 Trabalhando com Estruturas . . . . . . . . . . . . . . . . . . . . . . . . . 85
12.2 Uniões . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
12.3 Enumerações . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
12.4 Typedef . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
12.5 Campos-de-Bits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
13 Noções de Manipulação de Arquivos 97

13.1 Abrindo e Fechando um Arquivo . . . . . . . . . . . . . . . . . . . . . . . . 97
13.1.1 A Função fopen() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
13.1.2 A Função exit() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
13.1.3 A Função fclose() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
13.2 Lendo e Escrevendo Caracteres em Arquivos . . . . . . . . . . . . . . . . . 100
13.2.1 putc() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
13.2.2 getc() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
13.2.3 feof() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
14 Noções de Alocação Dinâmica 103
15 Exercícios 105
15.1 Capítulo 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
15.2 Capítulo 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
15.3 Capítulo 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
15.4 Capítulo 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
15.5 Capítulo 5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
15.6 Capítulo 6 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
15.7 Capítulo 7 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
15.8 Capítulos 8 e 9 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
15.9 Capítulo 10 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
15.10 Capítulo 11 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
15.11 Capítulo 12 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
15.12 Capítulo 13 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
15.13 Capítulo 14 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
Referências Bibliográficas 113
A Bibliotecas do C 115
A.1 assert.h . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
A.2 conio.h . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
A.3 ctype.h . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
A.4 errno.h . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
A.5 limits.h . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
A.6 locale.h . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
A.7 math.h . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
A.8 signal.h . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
A.9 stdarg.h . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
A.10 stdio.h . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
A.10.1 Algumas funções em detalhe . . . . . . . . . . . . . . . . . . . . . . . . 124
A.10.2 Entradas e saídas formatadas . . . . . . . . . . . . . . . . . . . . . . . 125
A.10.3 Funções (x)scanf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
A.10.4 Funções de entrada e saída de caracteres . . . . . . . . . . . . . . . . . 127
A.11 stdlib.h . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
A.11.1 Funções de manipução de Strings . . . . . . . . . . . . . . . . . . . . . 129
A.11.2 Funções de manipulação de Memória . . . . . . . . . . . . . . . . . . . 129
A.11.3 Funções de Ambiente (Environment) . . . . . . . . . . . . . . . . . . . . 130
A.11.4 Funções de busca e ordenação (Searching and Sorting) . . . . . . . . . 130
A.11.5 Funções matemáticas . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
A.11.6 Funções Multibyte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
A.12 string.h . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
A.13 time.h . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
LISTA DE FIGURAS
1.1 Trecho de programa em linguagem de máquina . . . . . . . . . . . . . . . . 11

1.2 Trecho de programa em linguagem de montagem . . . . . . . . . . . . . . . 12
1.3 Trecho de programa em linguagem de alto nível . . . . . . . . . . . . . . . . 12
2.1 Estrutura de um programa em C . . . . . . . . . . . . . . . . . . . . . . . . 17

2.2 Um programa simples em C . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.3 Ambiente de programação do C . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.4 Um programa que utiliza uma função . . . . . . . . . . . . . . . . . . . . . . 20
3.1 Programa com instruções básicas . . . . . . . . . . . . . . . . . . . . . . . 22

3.2 Inicialização de variáveis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3.3 Programa com diferentes tipos de variáveis. . . . . . . . . . . . . . . . . . . 25
3.4 Programa com operadores aritméticos . . . . . . . . . . . . . . . . . . . . . 28
3.5 Programa para conversão de pés para metros . . . . . . . . . . . . . . . . . 28
3.6 Programa com operadores relacionais e lógicos . . . . . . . . . . . . . . . . 29
3.7 Programa Maior_de_dois . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
3.8 Programa com exemplo de utilização de operador cast . . . . . . . . . . . 30
4.1 Exemplo de utilização da função printf . . . . . . . . . . . . . . . . . . . . . 34

4.2 Tamanho de campos na impressão . . . . . . . . . . . . . . . . . . . . . . . 34
4.3 Arredondamento de números em ponto flutuante . . . . . . . . . . . . . . . 34
4.4 Alinhamento de campos numéricos . . . . . . . . . . . . . . . . . . . . . . . 34
4.5 Complementando com zeros à esquerda . . . . . . . . . . . . . . . . . . . . 35
4.6 Formas para imprimir caracteres utilizando a função printf . . . . . . . . . 35
4.7 Exemplo de programa que utiliza a função scanf . . . . . . . . . . . . . . . 36
4.8 Exemplo de programa que utiliza a função getchar . . . . . . . . . . . . . . 36
4.9 Exemplo de programa que utiliza a função putchar . . . . . . . . . . . . . . 37
5.1 Exemplo de programa que utiliza o comando de decisão if . . . . . . . . . . 39

5.2 O comando de decisão if com um bloco de instruções . . . . . . . . . . . . 40
5.3 Exemplo de um programa que utiliza o comando if-else-if . . . . . . . . . . 41
5.4 Exemplo de programa que utiliza o operador ternário . . . . . . . . . . . . . 42
5.5 Exemplo de programa que utiliza o comando switch . . . . . . . . . . . . . 43
5.6 Exemplo de for com apenas um comando . . . . . . . . . . . . . . . . . . . 44
5.7 Exemplo de for com um bloco de instruções . . . . . . . . . . . . . . . . . . 44
5.8 Programa para calcular o valor de . . . . . . . . . . . . . . . . . . . . . . 45
5.9 Laço de for com duas variáveis de controle . . . . . . . . . . . . . . . . . . 46
5.10 Loop infinito . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
5.11 Laços de for aninhados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
5.12 Programa que exibe uma tabela das quatro primeiras potências dos núme-
ros de 1 a 9 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
5.13 Exemplo simples de while . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
5.14 Geração de uma tabela de quadrados de inteiros utilizando while . . . . . 48
5.15 Geração de uma tabela de quadrados de inteiros utilizando do-while . . . 49
5.16 Exemplo de utilização do laço do-while . . . . . . . . . . . . . . . . . . . . 50
5.17 Exemplo simples de utilização do comando break . . . . . . . . . . . . . . 50
5.18 Exemplo de utilização do comando continue . . . . . . . . . . . . . . . . . 51
6.1 Exemplo simples de utilização de matriz . . . . . . . . . . . . . . . . . . . . 54

6.2 Exemplo de armazenamento de dados em matriz unidimensional . . . . . . 55
6.3 Operações com matriz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
6.4 Exemplo simples de utilização de matriz multidimensional . . . . . . . . . . 56
6.5 Exemplo de utilização de matriz estática . . . . . . . . . . . . . . . . . . . . 56
6.6 Erro na utilização de matriz . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
7.1 Exemplo simples de operação com strings . . . . . . . . . . . . . . . . . . . 57

7.2 Programa simples que utiliza a função gets . . . . . . . . . . . . . . . . . . 58
7.3 Exemplo simples de utilização da função puts . . . . . . . . . . . . . . . . 58
7.4 Utilização da função strcpy da biblioteca string.h . . . . . . . . . . . . . . . 59
7.5 Utilização da função strcat da biblioteca string.h . . . . . . . . . . . . . . . 59
7.6 Utilização da função strcmp da biblioteca string.h . . . . . . . . . . . . . . 60
8.1 Exemplos de declarações de ponteiros . . . . . . . . . . . . . . . . . . . . . 61

8.2 Atribuição de valor a um ponteiro . . . . . . . . . . . . . . . . . . . . . . . . 62
8.3 Utilização de ponteiros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
8.4 Operações com Ponteiros . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
8.5 Ponteiros para ponteiros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
8.6 Exemplo do erro de ponteiro perdido . . . . . . . . . . . . . . . . . . . . . . 65
9.1 Cópia de uma string (versão matriz) . . . . . . . . . . . . . . . . . . . . . . 68

9.2 Cópia de uma string (versão ponteiro) . . . . . . . . . . . . . . . . . . . . . 69
9.3 Uso de um ponteiro no lugar de uma string . . . . . . . . . . . . . . . . . . 69
9.4 Utilização de matrizes de ponteiros para mensagens de erro . . . . . . . . 70
10.1 Inversão de uma string usando uma função que recebe um ponteiro . . . . 72
10.2 Um codificador simples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
10.3 Função com retorno de inteiro . . . . . . . . . . . . . . . . . . . . . . . . . . 74
10.4 Parâmetros formais de uma função . . . . . . . . . . . . . . . . . . . . . . . 74
10.5 Passagem de valor de uma variável para uma função . . . . . . . . . . . . 75
10.6 Função que utiliza passagem por referência . . . . . . . . . . . . . . . . . . 75
10.7 Variáveis locais em uma função . . . . . . . . . . . . . . . . . . . . . . . . . 76
10.8 Variáveis globais em um programa . . . . . . . . . . . . . . . . . . . . . . . 77
10.9 Variáveis locais em uma função . . . . . . . . . . . . . . . . . . . . . . . . . 77
10.10 Função que utiliza uma matriz . . . . . . . . . . . . . . . . . . . . . . . . . . 78
10.11 Função que opera sobre uma matriz utilizando um ponteiro . . . . . . . . . 79
10.12 Função que procura uma substring dentro de uma string . . . . . . . . . . . 79
10.13 Alterando valores de uma matriz . . . . . . . . . . . . . . . . . . . . . . . . 80
11.1 Programa que recebe uma string na linha de comando . . . . . . . . . . . . 81

11.2 Programa que recebe argumentos na linha de comando . . . . . . . . . . . 82
12.1 Forma geral de declaração de uma estrutura . . . . . . . . . . . . . . . . . 84
12.2 Declaração de uma estrutura para clientes de um banco . . . . . . . . . . . 84
12.3 Exemplos de acesso a membros de variáveis do tipo estrutura . . . . . . . 86
12.4 Exemplos de passagens de elementos de estruturas para funções . . . . . 87
12.5 Exemplo de passagem de uma estrutura inteira para uma função . . . . . . 88
12.6 Exemplo de ponteiro para estrutura . . . . . . . . . . . . . . . . . . . . . . . 89
12.7 Exemplo de passagem de uma estrutura inteira para uma função . . . . . . 89
12.8 Forma geral de declaração de uma união . . . . . . . . . . . . . . . . . . . 90
12.9 Declarações de uniões e formas de utilização . . . . . . . . . . . . . . . . . 93
12.10 Exemplo de enumeração . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
12.11 Exemplo de utilização de uma enumeração . . . . . . . . . . . . . . . . . . 94
12.12 Utilizando typedef . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
12.13 Forma geral de campos-de-bits . . . . . . . . . . . . . . . . . . . . . . . . . 95
12.14 Exemplo de estrutura de campos-de-bits . . . . . . . . . . . . . . . . . . . . 96
13.1 Escrevendo e lendo em arquivo . . . . . . . . . . . . . . . . . . . . . . . . . 98

13.2 Uso da função exit na abertura de arquivos . . . . . . . . . . . . . . . . . . 100
14.1 Primeiro exemplo de alocação dinâmica de memória . . . . . . . . . . . . . 103

14.2 Segundo exemplo de alocação dinâmica de memória . . . . . . . . . . . . 104
15.1 Capítulo 2: Programa para o exercício 1 . . . . . . . . . . . . . . . . . . . . 105

15.2 Capítulo 3: programa para o exercício 1 . . . . . . . . . . . . . . . . . . . . 106
15.5 Capítulo 5: Algoritmo para o exercício 3 . . . . . . . . . . . . . . . . . . . . 109
15.6 Capítulo 7: programa para o exercício 1 . . . . . . . . . . . . . . . . . . . . 110
15.7 Capítulo 10: Programa para o exercício 2 . . . . . . . . . . . . . . . . . . . 111
LISTA DE TABELAS
3.1 Palavras reservadas do C . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

3.2 Tipos de dados do C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
3.3 Operadores aritméticos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
3.4 Comandos de atribuição reduzidos . . . . . . . . . . . . . . . . . . . . . . . 27
3.5 Operadores relacionais e lógicos . . . . . . . . . . . . . . . . . . . . . . . . 28
3.6 Nível de precedência dos operadores . . . . . . . . . . . . . . . . . . . . . 30
4.1 Caracteres de controle da função printf . . . . . . . . . . . . . . . . . . . . 33
13.1 Modos válidos de abertura de arquivos . . . . . . . . . . . . . . . . . . . . . 99

1
INTRODUÇÃO
1.1 LINGUAGENS DE MÁQUINA, LINGUAGENS DE MONTAGEM, E LINGUAGENS DE

ALTO-NÍVEL
Programadores escrevem instruções em várias linguagens de programação, algumas

diretamente inteligíveis pelo computador e outras que requerem passos intermediários de
tradução. Centenas de linguagens de computador são usadas atualmente. Estas podem
ser divididas em três grandes grupos:
Linguagens de máquina,
Linguagens de montagem,
Linguagens de alto nível.
Qualquer computador pode entender diretamente apenas sua própria linguagem de

máquina. A linguagem de máquina é a “linguagem natural” de um computador em particular.
Ela é relacionada diretamente ao projeto do hardware daquele computador. Linguagens
de máquina geralmente consistem de cadeias de números (que se reduzem a 1s e 0s)
que instruem o computador a realizar suas operações mais elementares, uma de cada
vez. Linguagens de máquina são dependentes da máquina (machine-dependent), isto é,
uma linguagem de máquina particular pode ser usada apenas em um tipo de computador.
Linguagens de máquina são desajeitadas para humanos, como poderá ser visto a seguir no
trecho de um programa, na Figura 1.1, que soma pagamento de hora-extra ao pagamento
básico e armazena o resultado no pagamento total.
+1300042774
+1400593419
+1200274027
Figura 1.1: Trecho de programa em linguagem de máquina

12 EDITORA - UFLA/FAEPE - Introdução à Linguagem C
Quando os computadores se tornaram mais populares, tornou-se claro que a progra-

mação em linguagens de máquina era muito lenta e tediosa para a maioria dos programa-
dores. Em vez de usar as cadeias de números que computadores podiam entender direta-
mente, os programadores começaram a usar abreviações derivadas da língua inglesa para
representar as operações elementares do computador. Estas abreviações do Inglês forma-
ram a base das linguagens de montagem (assembly languages). Tradutores de programas,
chamados assemblers, foram desenvolvidos para converter programas em linguagem de
montagem (assembly ) para linguagem de máquina na velocidade dos computadores. A Fi-
gura 1.2 mostra um trecho de um programa em linguagem de montagem que também soma
o pagamento de hora-extra ao pagamento básico e armazena o resultado no pagamento
total, mas mais claramente que seu equivalente em linguagem de máquina:
LOAD BASEPAY
ADD OVERPAY
STORE GROSSPAY
Figura 1.2: Trecho de programa em linguagem de montagem
A utilização do computador cresceu rapidamente com o advento das linguagens de

montagem, mas estas ainda requeriam muitas instruções para realizar mesmo as tarefas
mais simples. Para acelerar o processo de programação, linguagens de alto nível foram
desenvolvidas nas quais declarações simples poderiam ser escritas para realizar tarefas
substanciais. Os programas tradutores que convertem programas de linguagens de alto
nível em programas de linguagem de máquina são chamados compiladores. Linguagens
de alto nível permitem aos programadores escreverem instruções que se parecem proxi-
mamente com o Inglês diário e contêm notações matemáticas comumente usadas. Um
programa de folha de pagamento escrito em linguagem de alto nível poderia conter uma
declaração tal como mostrada na Figura 1.3
grossPay = basePay + overTimePay
Figura 1.3: Trecho de programa em linguagem de alto nível
Obviamente, linguagens de alto nível são muito mais desejáveis do ponto de vista dos
programadores que linguagens de máquina ou linguagens de montagem. C e C++ estão
entre as mais poderosas e mais largamente usadas linguagens de alto nível.
Introdução 13
1.2 A HISTÓRIA DO C
C evoluiu das linguagens anteriores, BCPL e B. BCPL foi desenvolvida em 1967

por Martin Richards como a linguagem para escrever softwares de sistemas operacio-
nais e compiladores. Ken Thompsom modelou muitas características de sua linguagem
B, baseando-se BCPL, e usou B para criar as primeiras versões do sistema operacional
UNIX no Bell Laboratories em 1970 em um computador DEC PDP-7. Tanto BCPL quanto B
eram linguagens não “tipadas” — todos os itens de dados ocupavam uma palavra na me-
mória e o fardo de tratar um dado como um número inteiro ou um número real, por exemplo,
ficava a cargo do programador.
A linguagem C foi uma evolução da B, feita por Dennis Ritchie no Bell Laboratories e
foi originalmente implementada em um computador DEC PDP-11 em 1972. C inicialmente
tornou-se largamente conhecida como a linguagem de desenvolvimento do sistema opera-
cional UNIX. Atualmente, a maioria dos novos sistemas operacionais maiores são escritos
em C e/ou C++. C está disponível para a maioria dos computadores atuais. C é indepen-
dente de Hardware. Com um projeto cuidadoso, é possível escrever programas em C que
são portáveis para a maioria dos computadores. C usa muitos dos importantes conceitos
do BCPL e do B enquanto soma a tipagem de dados e outras características poderosas.
No final da década de 70, C havia evoluído para o que agora é conhecido como o
tradicional “C”. A publicação, em 1978, do livro de Kernighan e Ritchie, The C Programming
Language, trouxe uma grande atenção à linguagem. Esta publicação tornou-se um dos
livros de ciência da computação de maior sucesso de todos os tempos.
A rápida expansão do C sobre vários tipos de computadores (algumas vezes cha-
mados plataformas de Hardware) conduziu a muitas variações. Estas eram similares mas
sempre incompatíveis. Isto era um problema sério para desenvolvedores de programas que
precisavam desenvolver código que rodasse sobre várias plataformas. Tornou-se claro que
uma versão padrão de C era necessária. Em 1983, o comitê técnico X3J11 foi criado sob
a American National Standards Committee on Computers and Information Processing (X3),
para “fornecer uma definição de linguagem não ambígua e independente de máquina”. Em
1989, o padrão foi aprovado. O documento é conhecido como ANSI/ISO 9899: 1990. Có-
pias deste documento podem ser requisitadas ao Americam National Institute. A Segunda
edição de Kernighan e Ritchie, publicada em 1988, reflete esta versão chamada ANSI C,
agora usada em todo o mundo.
1.3 A BIBLIOTECA PADRÃO C
Programas em C consistem de módulos ou pedaços, chamados funções. Você pode

programar todas as funções que você precisa para formar um programa em C, mas a maio-
ria dos programadores em C aproveitam uma rica coleção de funções existentes, chamada
C Standard Library. Portanto, há realmente duas etapas para aprender o “mundo” C. A
primeira é aprender a própria linguagem C, e a segunda aprender como usar as funções da
biblioteca padrão C.
Neste curso, você será levado a usar a abordagem de construção de blocos (Building
block approach) para criar programas. Evite reinventar a roda. Use pedaços existentes –
isto é chamado reutilização de software e é a chave para o campo de desenvolvimento de
programas orientados ao objeto como veremos. Quando programando em C você usará
tipicamente os seguintes blocos de construção:
Funções da biblioteca padrão C,

Funções que você mesmo criou,
Funções que outras pessoas criaram e disponibilizaram para você.
A vantagem de criar suas próprias funções é que você vai saber exatamente como
elas funcionam. Você poderá examinar o código C. A desvantagem é o tempo consumido
em esforço que leva do projeto ao desenvolvimento de novas funções.
Usar funções existentes evita reinventar a roda. No caso de funções padrão ANSI,
você sabe que elas são cuidadosamente escritas, e você sabe que por estar usando fun-
ções que são disponíveis em virtualmente todas as implementações ANSI C, seu programa
terá uma chance muito maior de ser portável.
1.4 CARACTERÍSTICAS DE C
C é uma linguagem altamente portável e bastante eficiente em termos de desem-

penho. É uma linguagem de propósito geral, sendo utilizada para desenvolver os mais
diversos tipos de software.
Entre as principais características da linguagem C, podem ser citadas:
portabilidade
modularidade
recursos de baixo nível
geração de código eficiente
simplicidade
facilidade de uso
possibilidade de ser usada para os mais variados propósitos
indicada para escrever compiladores, editores de textos, bancos de dados, etc.
Introdução 15
Como resultado, tem-se que C e C++ podem ser consideradas “padrões de indústria”
pelas empresas de desenvolvimento de software. Várias dessas empresas adotam estas
linguagens na maioria de seus projetos. Para o programador, o conhecimento da linguagem
C é de grande valor.
1.5 C E C++
Algumas vezes os iniciantes confundem o que é C++ e como difere de C. C++ é uma
versão estendida e melhorada de C que foi projetada para suportar programação orien-
tada a objetos (OOP). C++ contém e suporta toda a linguagem C e mais um conjunto de
extensões orientadas a objetos.
Por muitos anos ainda os programadores escreverão, manterão e utilizarão progra-
mas escritos em C, sem se preocuparem em utilizar os benefícios da orientação a objetos
proporcionados por C++, por isso o código escrito em C estará em uso por muitos anos
ainda.
1.6 O COMPILADOR GCC
Todos os programas utilizados como exemplo neste curso utilizam apenas funções da
linguagem C padrão ANSI (ANSI C), portanto recomendamos a utilização de um compilador
de C que funcione bem para programas que seguem este padrão. O compilador GCC é o
compilador de C do projeto GNU (http//:www.gnu.org), é gratuito e de código aberto.
O projeto GNU (Gnu’s Not Unix) foi proposto por Richard Stallman em 1983. Richard
Stallman é pesquisador do MIT e inventor do editor EMACS. O projeto teve início em 1984,
e a proposta era desenvolver um sistema operacional completo e livre, similar ao Unix: o
sistema GNU (GNU é um acrônimo recursivo que se pronuncia “guh-NEW” ou “guniw”).
Variações do sistema GNU, que utilizam o núcleo Linux, são hoje largamente utilizadas;
apesar desses sistemas serem normalmente chamados de “Linux”, eles são mais precisa-
mente chamados Sistemas GNU/Linux.
O desenvolvimento do GCC é uma parte do Projeto GNU, com o objetivo de melhorar
o compilador usado no sistema GNU incluindo a variante GNU/Linux. O trabalho de desen-
volvimento do GCC usa um ambiente aberto de desenvolvimento e suporta muitas outras
plataformas com o propósito de promover um compilador de primeira linha (world-class) que
seja otimizado continuamente, de reunir um grande time de desenvolvedores, de assegurar
que o GCC e o sistema GNU trabalhem em múltiplas arquiteturas e diversos ambientes, e
de atender a muitos outros testes e mais características de GCC.
Em Abril de 1999, o Egcs Steering Committee foi indicado pelo FSF como o mantene-
dor oficial GNU para GCC. Naquele tempo GCC foi renomeado para “GNU C Compiler” e
para “GNU Compiler Collection” e recebeu uma nova missão.
Atualmente GCC contém aplicações para C, C++, Objective C, Chill, Fortran, e Java
bem como bibliotecas para estas linguagens (libstdc++, libgcj,...).
Uma versão do compilador GCC pode ser obtida no ftp do curso de Ciência da Com-
putação da UFLA1 . Obtenha uma cópia do compilador e instale em seu computador.
De posse do GCC instalado e configurado (independente de sua portagem ou ambi-
ente), para compilar um programa denominado nome.c, execute a seguinte linha de co-
mando:
gcc nome.c -o nome.exe
onde nome é o nome dado ao programa. Com isso, o arquivo nome.c será compilado
gerado um executável nome.exe (em ambientes Linux, a extensão ‘.exe’ é desnecessá-
ria).
1
ftp://ftp.comp.ufla.br/pub/
2
ESTRUTURA DE UM PROGRAMA EM C
Um programa em C é estruturado sobre funções. O programa possui uma ou várias

funções, sendo que a principal, que dá início ao programa e chama todas as outras, é
sempre chamada main. Além dessas, existem outras pré-programadas, que são incluídas
nos programas como arquivos de cabeçalho, ou arquivos de inclusão. Todas as funções
começam com { e terminam com } , como indicado na Figura 2.1.
/* Estrutura de um programa em C */
# include <arquivo_cabecalho.h>
int main ( )
{
declaração de variáveis
instrução_1;
instrução_2;
função_1(variáveis);
instrução_3;
-
-
}
int função_1 (variáveis)
{
declaração de variáveis
instrução_1;
instrução_2;
-
-
return (INT);
}
Figura 2.1: Estrutura de um programa em C

A primeira linha compreende apenas comentários. Todos os comentários iniciam com

/* e terminam com */. A segunda linha indica a inclusão de um arquivo de cabeçalho.
A terceira linha, inicia a função main. Após a função main, foi programada outra função
chamada função_1. Excetuando a main, todas as outras funções podem ter qualquer
nome que o programador desejar.
A declaração de funções segue sempre o padrão: tipo nome (parâmetros). Nesse
caso, tipo refere-se ao tipo de valor que a função pode retornar (inteiro, decimal, letra, etc),
nome é o nome dado à função, e parâmetros são os valores passados pelo programa para
a função. Quando não for especificado, o tipo da função será int (inteiro). Não é obrigatório
o uso de parâmetros, como pode ser visto no exemplo, na função main.
A Figura 2.2 apresenta um programa simples escrito em linguagem C.
/* programa exemplo 01 */
# include <stdio.h>
main ( )
{
printf("Alo, Mundo!");
}
Figura 2.2: Um programa simples em C
Edite este programa com o nome exemp_01.c e compile-o utilizando o compilador

GCC, ou outro de sua preferência. Escreva na linha de comando do computador:
gcc exemp_01.c -o exemp_01
Isto indica ao computador para utilizar o compilador GCC para compilar o programa
exemp_01.c escrito em C e dar ao arquivo executável gerado o nome de exemp_01. Ao
final, rode o programa.
A função printf já está programada dentro de stdio.h, e é utilizada para escrever
mensagens na tela do computador. As funções pré-programadas devem ser escritas em
letras minúsculas.
Modifique este programa para escrever outra mensagem além de “Alo, Mundo!”.
2.1 VISÃO GERAL DE UM PROGRAMA C
A geração do programa executável a partir do programa fonte obedece a uma seqüên-

cia de operações antes de tornar-se um executável, conforme descrito na Figura 2.3. Depois
de escrever o módulo fonte em um editor de textos, o programador aciona o compilador que
Estrutura de um Programa em C 19
no nosso exemplo é chamado pelo comando gcc. Essa ação desencadeia uma seqüência
de etapas, cada qual traduzindo a codificação do usuário para uma forma de linguagem de
nível inferior, que termina com o executável criado pelo lincador.
Edição
(módulo fonte em C)
Pré−Processamento
(novo fonte expandido)
Compilação
(arquivo objeto)
Lincagem
(executável)
Execução
Figura 2.3: Ambiente de programação do C
2.2 UM PROGRAMA UTILIZANDO UMA FUNÇÃO
Para que fique entendida a estrutura de um programa em C, façamos um segundo

exemplo (Figura 2.4), o qual utiliza uma função que retorna um valor do tipo inteiro.
A função quadrado é chamada pela main na sua quarta linha e retorna para a função
main o quadrado do número passado como argumento. Na função main, o valor retornado
é atribuído à variável quad. Ao final, o número lido pela função scanf e o seu quadrado são
escritos na tela, utilizando-se a função printf.
A função scanf também pertence a stdio.h e é utilizada para ler valores enviados pelo
teclado. Edite este programa com o nome exemp_02.c e compile-o utilizando o compilador
GCC. Escreva na linha de comando do computador:
gcc exemp_02.c -o exemp_02
/* programa exemplo 02 */
# include <stdio.h>
int quadrado (int num)

{
return (num*num);
}
main ( )
{
int num, quad;
printf("Envie um numero inteiro: ");
scanf("%d",&num);
quad = quadrado(num);
printf("\n Quadrado de %d é : %d", num, quad);
Figura 2.4: Um programa que utiliza uma função
Modifique este programa para que ele calcule o cubo do número: crie uma função
cubo.
3
SINTAXE
Sintaxe são regras detalhadas para cada construção válida na linguagem C. Estas
regras estão relacionadas com os tipos, as declarações, as funções e as expressões.
Os tipos definem as propriedades dos dados manipulados em um programa.
As declarações expressam as partes do programa, podendo dar significado a um
identificador, alocar memória, definir conteúdo inicial, definir funções.
As funções especificam as ações que um programa executa quando roda. A deter-
minação e alteração de valores, e a chamada de funções de I/O são definidas nas expres-
sões.
As funções são as entidades operacionais básicas dos programas em C, que por
sua vez são a união de uma ou mais funções executando cada qual o seu trabalho. Há
funções básicas que estão definidas na biblioteca C. As funções printf( ) e scanf( ) por
exemplo, permitem respectivamente escrever na tela e ler os dados a partir do teclado. O
programador também pode definir novas funções em seus programas, como rotinas para
cálculos, impressão, etc.
Todo programa C inicia sua execução chamando a função main( ), sendo obrigatória
a sua declaração no programa principal.
Comentários no programa são colocados entre /* e */ não sendo considerados na
compilação. Os comentários podem também ser colocados em uma linha, após o sinal //.
Cada instrução encerra com ; (ponto e vírgula) que faz parte do comando.
A Figura 3.1 mostra um exemplo de programa que utiliza estes conceitos básicos.
3.1 IDENTIFICADORES
São nomes usados para se fazer referência a variáveis, funções, rótulos e vários ou-
tros objetos definidos pelo usuário. O primeiro caracter deve ser uma letra ou um subli-
nhado. Os 32 primeiros caracteres de um identificador são significativos.
O C é “Case Sensitive”, isto é, os compiladores C entendem as letras maiúsculas e
minúsculas como sendo diferentes. Portando uma variável declarada como X1 será dife-
# include <stdio.h>
main( ) /* função obrigatória */
{
char Nome[20];
printf("\n Alô! Qual é o seu nome ? ");
scanf("%s",Nome);
printf("\n Bom dia, %s ! \n",Nome);
}
Figura 3.1: Programa com instruções básicas
rente de uma variável declarada com x1, uma variável chamada Tempo será diferente de
TEMPO, tempo e TeMPo. Os comandos básicos do C devem ser escritos sempre com
minúsculas (if, for, switch, etc.), caso contrário, o compilador não irá interpretá-los como
sendo comandos, mas como variáveis. O C possui outros comandos e palavras reservadas
que são todos escritos em letras minúsculas. A Tabela 3.1 apresentada uma lista com as
palavras reservadas do padrão ANSI C.
Tabela 3.1: Palavras reservadas do C
auto double int struct

break else long switch
case enum register typedef
char extern return union
const float short unsigned
continue for signed void
default goto sizeof volatile
do if static while
3.2 TIPOS DE VARIÁVEIS
Quando você declara um identificador, dá a ele um tipo. Os tipos principais podem

ser colocados dentro da classe do tipo de objeto de dado. Um tipo de objeto de dados
determina como valores de dados são representados, que valores pode expressar, e que
tipo de operações você pode executar com estes valores. As variáveis, identificadores, no C
podem ter qualquer nome se duas condições forem satisfeitas: o nome deve começar com
uma letra ou sublinhado (_) e os caracteres subsequentes devem ser letras, números ou
Sintaxe 23
sublinhado (_). Há apenas mais duas restrições: o nome de uma variável não pode ser igual
a uma palavra reservada, nem igual ao nome de uma função declarada pelo programador,
ou pelas bibliotecas do C. Variáveis de até 32 caracteres são aceitas.
3.2.1 Tipos Básicos

Há cinco tipos básicos de dados em C: caractere (char), inteiro (int), ponto flutuante
(float), ponto flutuante de precisão dupla (double) e vazio (void). Todos os outros tipos de
dados em C são baseados nestes 5 tipos básicos. O tamanho e a faixa de representação
de cada um destes tipos de dados depende do processador utilizado e da implementação
do compilador C. O padrão ANSI determina apenas a faixa mínima de cada tipo, não o seu
tamanho em bytes.
Exceto void, os tipos básicos de C podem ter vários modificadores precedendo-os.
Um modificador é usado para alterar o significado de um tipo básico, modificando o seu
tamanho ou sua forma de representação. Os modificadores são: signed, unsigned, long
e short. Os tipos básicos do C juntamente com suas formas modificadas são apresentados
na Tabela 3.2.
Uma implementação do compilador pode mostrar um faixa maior do que a mostrada
na Tabela 3.2, mas não uma faixa menor. As potências de 2 usadas significam:

! " # #
#
3.3 DECLARAÇÃO E INICIALIZAÇÃO DE VARIÁVEIS
As variáveis no C devem ser declaradas antes de serem usadas. A forma geral da

declaração de variáveis é:
tipo_da_variável lista_de_variáveis;
As variáveis da lista de variáveis terão todas o mesmo tipo e deverão ser separadas
por vírgula. Como o tipo default do C é o int, quando vamos declarar variáveis int com
algum dos modificadores de tipo, basta colocar o nome do modificador de tipo. Assim um
long basta para declarar um long int.
Há três lugares nos quais podemos declarar variáveis. O primeiro é fora de todas as
funções do programa. Estas variáveis são chamadas variáveis globais e podem ser usadas
Tabela 3.2: Tipos de dados do C
Inteiros

char igual a signed char ou unsigned char

signed char inteiro de pelo menos 8 bits

unsigned char mesmo que signed char sem negativos

short
inteiro de pelo menos 16 bits; tamanho pelo
menos igual a char

unsigned short mesmo tamanho que short sem negativos

int
inteiro de pelo menos 16 bits; tamanho pelo
menos igual a short

unsigned int mesmo tamanho que int sem negativos

long
inteiro com sinal de pelo menos 32 bits; tama-
nho pelo menos igual a int
!
unsigned long mesmo tamanho que long sem valores nega-
tivos
Ponto Flutuante

float pelo menos 6 dígitos de precisão decimal

double
pelo menos 10 dígitos decimais e precisão

maior que do float

!

long double
pelo menos 10 dígitos decimais e precisão
!
maior que do double
a partir de qualquer lugar no programa. Pode-se dizer que, como elas estão fora de todas
as funções, todas as funções as vêem. O segundo lugar no qual se pode declarar variáveis
é no início de um bloco de código de uma função. Estas variáveis são chamadas locais e só
têm validade dentro do bloco no qual são declaradas, isto é, só a função à qual ela pertence
sabe da existência desta variável. O terceiro lugar onde se pode declarar variáveis é na lista
de parâmetros de uma função. Mais uma vez, apesar de estas variáveis receberem valores
externos, são conhecidas apenas pela função onde são declaradas.
As regras que regem onde uma variável é válida chamam-se regras de escopo da
variável. Há mais dois detalhes que devem ser ressaltados. Duas variáveis globais não
podem ter o mesmo nome. O mesmo vale para duas variáveis locais de uma mesma função.
Já duas variáveis locais, de funções diferentes, podem ter o mesmo nome sem perigo algum
de conflito.
Sintaxe 25
Podemos inicializar variáveis no momento de sua declaração. Para fazer isto podemos
usar a forma geral
tipo_da_variável nome_da_variável = constante;
Isto é importante pois quando o C cria uma variável ele não a inicializa. Isto significa
que até que um primeiro valor seja atribuído à nova variável ela tem um valor indefinido e
que não pode ser utilizado para nada. Nunca presuma que uma variável declarada vale
zero ou qualquer outro valor. Exemplos de inicialização podem ser vistos na Figura 3.2.
char ch=’D’;
int count=0;
float pi=3.1416;
Figura 3.2: Inicialização de variáveis
A Figura 3.3 apresenta um programa que identifica o tamanho de variáveis de diferen-

tes tipos.
# include <stdio.h>
main()
{
char c;
unsigned char uc;
int i;
unsigned int ui;
float f;
double d;
printf("char %d",sizeof(c));
printf("unsigned char %d",sizeof(uc));
printf("int %d",sizeof(i));
printf("unsigned int %d",sizeof(ui));
printf("float %d",sizeof(f));
printf("double %d",sizeof(d));
}
Figura 3.3: Programa com diferentes tipos de variáveis.

3.4 OPERADORES
3.4.1 Operador de Atribuição

O operador de atribuição em C é o sinal de igual “=”. Ao contrário de outras linguagens,
o operador de atribuição pode ser utilizado em expressões que também envolvem outros
operadores. O operador de atribuição “=” atribui à variável à sua esquerda o valor calculado
à direita. O C permite que se façam atribuições encadeadas, como:
x = y = z = 2.45;
Nesta linha, o valor 2.45 será atribuído a z, depois a y, depois a x.
3.4.2 Operadores Aritméticos

Os operadores aritméticos são usados para desenvolver operações matemáticas. A
Tabela 3.3 apresenta a lista dos operadores aritméticos do C.
Tabela 3.3: Operadores aritméticos
Operador Ação
+ Soma (inteira e ponto flutuante)
- Subtração ou Troca de sinal (inteira e ponto flutuante)
* Multiplicação (inteira e ponto flutuante)
/ Divisão (inteira e ponto flutuante)
% Resto de divisão (de inteiros)
++ Incremento (inteiro e ponto flutuante)
-- Decremento (inteiro e ponto flutuante)
O C possui operadores unários e binários. Os unários agem sobre uma variável ape-
nas, modificando ou não o seu valor, e retornam o valor final da variável. Os binários usam
duas variáveis e retornam um terceiro valor, sem alterar as variáveis originais. A soma é
um operador binário pois pega duas variáveis, soma seus valores, sem alterar as variáveis,
e retorna esta soma. Outros operadores binários são os operadores - (subtração), *, / e
%. O operador - como troca de sinal é um operador unário que não altera a variável sobre
a qual é aplicado, pois ele retorna o valor da variável multiplicado por -1.
Os operadores de incremento e decremento são unários que alteram a variável sobre
a qual estão aplicados. O que eles fazem é incrementar ou decrementar de um a variável
sobre a qual estão aplicados. Então
x++;
x--;
Sintaxe 27
são operações equivalentes a
x = x+1;
x = x-1;
Estes operadores podem ser pré-fixados ou pós-fixados. A diferença é que quando

são pré-fixados eles incrementam e retornam o valor da variável já incrementada. Quando
são pós-fixados eles retornam o valor da variável sem o incremento e depois incrementam
a variável. Então, em
x = 23;
y = x++;
teremos, no final, y = 23 e x = 24. Em
x = 23;
y = ++x;
teremos, no final, y = 24 e x = 24.

Uma curiosidade: a linguagem de programação C++ tem este nome pois ela seria um
“incremento” da linguagem C padrão.
Os operadores *, /, + e - funcionam como na maioria das linguagens, o operador %
indica o resto de uma divisão inteira. Quando efetuados sobre um mesmo operando, podem
ser utilizados em forma reduzida, como ilustra a Tabela 3.4.
Tabela 3.4: Comandos de atribuição reduzidos
i += 2;
i = i+2;
x *= y+1;
x = x*(y+1);
d -= 3;
d = d - 3;
A Figura 3.4 apresenta um programa simples que utiliza operadores aritméticos sobre
números inteiros, e a Figura 3.5 apresenta um programa para fazer a conversão de medidas
em pés para metros, utilizando operações sobre números em ponto flutuante.
A função scanf() é utilizada para ler um valor numérico do teclado do computador.
3.4.3 Operadores Relacionais e Lógicos

O termo relacional refere-se às relações que os valores podem ter um com o outro e
o termo lógico se refere às maneiras como essas relações podem ser conectadas. Em C,
entende-se como verdadeiro qualquer valor que não seja 0, enquanto que o valor 0 indica
# include <stdio.h>
main()
{
int x, y;
x =10; y = 3;
printf("%d\n", x/y);
printf("%d\n", x%y);
}
Figura 3.4: Programa com operadores aritméticos
#include <stdio.h>
/* Conversão de pés para metros. */
main()
{
float pes, metros;
printf("Informe o número de pés: ");
scanf("%f", &pes); /* lê um float */
metros = pes * 0.3048; /* conversão de pés para metros */
printf("%f pes é %f metros\n", pes, metros);
}
Figura 3.5: Programa para conversão de pés para metros
condição falsa. As expressões que usam operadores de relação e lógicos retornarão 0

para falso e 1 para verdadeiro. Tanto os operadores de relação como os lógicos têm a
precedência menor que os operadores aritméticos. As operações de avaliação produzem
um resultado 0 ou 1.
Tabela 3.5: Operadores relacionais e lógicos
relacionais lógicos
> maior que && and (E)
>= maior ou igual || or (OU)
< menor ! not (NÃO)
<= menor ou igual
== igual
!= não igual
Sintaxe 29
As Figuras 3.6 e 3.7 apresentam programas com exemplos de utilização de operado-

res relacionais e lógicos.
# include <stdio.h>
main()
{
int i,j;
printf("digite dois números: ");
scanf("%d%d", &i, &j);
printf("%d == %d é %d\n", i, j, i==j);
printf("%d != %d é %d\n", i, j, i!=j);
printf("%d <= %d é %d\n", i, j, i<=j);
printf("%d >= %d é %d\n", i, j, i>=j);
printf("%d < %d é %d\n", i, j, i<j);
printf("%d > %d é %d\n", i, j, i> j);
}
Figura 3.6: Programa com operadores relacionais e lógicos
/* Maior de Dois */
# include <stdio.h>
main( )
{
int x=2, y=3, produto;
if ((produto = x*y) > 0) printf("é maior");
}
Figura 3.7: Programa Maior_de_dois
3.4.4 Precedência
O nível de precedência dos operadores é avaliado da esquerda para a direita. Os

parênteses podem ser utilizados para alterar a ordem da avaliação.
3.4.5 Operador cast (Modelador)
Sintaxe: (tipo)expressão
Podemos forçar uma expressão a ser de um determinado tipo usando o operador
cast. Um exemplo pode ser visto na Figura 3.8. Nesse exemplo, se não fosse utilizado o
Tabela 3.6: Nível de precedência dos operadores
Mais alta ! ++ -- -(unário)

*/%
+-
<>
<= >=
== !=
&&
||
Mais baixa =
modelador (float) sobre a variável i, o programa imprimiria “1/3 = 0”, pois, ele faria primeiro
a divisão de inteiros (1/3) resultando 0, e depois a conversão do resultado para float.
# include <stdio.h>
main( )
{
int i=1;
printf(" %d/3 é: %f ", i, (float) i/3);
}
Figura 3.8: Programa com exemplo de utilização de operador cast
3.4.6 Operador sizeof
O operador sizeof retorna o tamanho em bytes da variável, ou seja, do tipo que está
em seu operando. É utilizado para assegurar a portabilidade do programa. O operador
sizeof é usado para se saber o tamanho de variáveis ou de tipos. Ele retorna o tamanho
do tipo ou variável em bytes. Mas porque usá-lo se sabemos, por exemplo, que um inteiro
ocupa 2 bytes? Devemos usá-lo para garantir portabilidade. O tamanho de um inteiro pode
depender do sistema para o qual se está compilando. O sizeof é chamado um operador
porque ele é substituído pelo tamanho do tipo ou variável no momento da compilação. Ele
não é uma função. O sizeof admite duas formas:
sizeof nome_da_variável
sizeof (nome_do_tipo)
Sintaxe 31
Se quisermos então saber o tamanho de um float fazemos sizeof(float). Se decla-

rarmos a variável f como float e quisermos saber o seu tamanho faremos sizeof(f). O
operador sizeof também funciona com estruturas, campos bit, uniões e enumerações.
4
FUNÇÕES BÁSICAS DA BIBLIOTECA C
Existem algumas funções muito usadas em programas feitos em linguagem C. Estas

são utilizadas principalmente para estabelecer a comunicação entre o usuário e o compu-
tador. Aqui serão citadas apenas algumas mais comuns.
4.1 FUNÇÃO PRINTF( )
Sintaxe: printf("expressão de controle",argumentos);

É uma função de I/O1 , que permite escrever no dispositivo padrão (tela). A expressão
de controle pode conter caracteres que serão exibidos na tela e os códigos de formatação
que indicam o formato em que os argumentos devem ser impressos. Cada argumento deve
ser separado por vírgula.
Tabela 4.1: Caracteres de controle da função printf
\n nova linha %c caractere simples

\t tabulação %d decimal
\b retrocesso %e notação científica
\" aspas %f ponto flutuante
\\ barra invertida %o octal
\f salta formulário %s cadeia de caracteres
\0 nulo %u decimal sem sinal
%x hexadecimal
As Figuras 4.1, 4.2, 4.3, 4.4, 4.5 e 4.6 apresentam vários exemplos de utilização da
função printf em programas simples.
1
Input/Output: entrada/saída
#include <stdio.h>
main( )
{
printf("Este é o numero dois: %d", 2);
printf("%s está a %d milhões de milhas \n do sol", "Vênus", 67);
}
Figura 4.1: Exemplo de utilização da função printf
#include <stdio.h>
main( )
{
printf("\n%2d",350);
}
Figura 4.2: Tamanho de campos na impressão
#include <stdio.h>
main( )
{
printf("\n%4.2f", 3456.78);
printf("\n%3.2f", 3456.78);
printf("\n%3.1f", 3456.78);
printf("\n%10.3f", 3456.78);
}
Figura 4.3: Arredondamento de números em ponto flutuante
#include <stdio.h>
main( )
{
printf("\n%10.2f %10.2f %10.2f", 8.0, 15.3, 584.13);
printf("\n%10.2f %10.2f %10.2f", 834.0, 1500.55, 4890.21);
}
Figura 4.4: Alinhamento de campos numéricos

Funções Básicas da Biblioteca C 35
#include <stdio.h>
main( )
{
printf("\n%04d", 21);
printf("\n%06d", 21);
printf("\n%6.4d", 21);
printf("\n%6.0d", 21);
}
Figura 4.5: Complementando com zeros à esquerda
#include <stdio.h>
main( )
{
printf("%d %c %x %o\n", ’A’, ’A’, ’A’, ’A’);
printf("%c %c %c %c\n", ’A’, 65, 0x41, 0101);
}
Figura 4.6: Formas para imprimir caracteres utilizando a função printf
A tabela ASCII possui 256 códigos de 0 a 255, se imprimirmos em formato caractere

um número maior que 255, será impresso o resto da divisão do número por 256; se o
número for 3393 será impresso A, pois o resto de 3393 por 256 é 65.
4.2 FUNÇÃO SCANF( )
Também é uma função de I/O implementada em todos os compiladores C. Ela é o

complemento de printf() e nos permite ler dados formatados da entrada padrão (teclado).
Sua sintaxe é similar a printf().
scanf("expressão de controle", argumentos);
A lista de argumentos deve consistir nos endereços das variáveis. C oferece um ope-
rador para tipos básicos chamado operador de endereço e referenciado pelo símbolo & que
retorna o endereço do operando. Um exemplo de programa que utiliza a função scanf é
visto na Figura 4.7.
Operador de endereço &:
A memória do computador é dividida em bytes, e são numerados de 0 até o limite
da memória. Estas posições são chamadas de endereços. Toda variável ocupa uma certa
localização na memória, e seu endereço é o primeiro byte ocupado por ela.
#include <stdio.h>
main( )
{
int num;
printf("Digite um número: ");
scanf("%d",&num);
printf("\no número é %d",num);
printf("\no endereço e %u",&num);
}
Figura 4.7: Exemplo de programa que utiliza a função scanf
4.3 FUNÇÃO GETCHAR()
É a função original de entrada de caractere dos sistemas baseados em UNIX. A função

getchar() armazena a entrada até que a tecla ENTER seja pressionada. Veja um exemplo
na Figura 4.8.
#include <stdio.h>
main( )
{
char ch;
ch = getchar();
printf("%c \n",ch);
}
Figura 4.8: Exemplo de programa que utiliza a função getchar
4.4 FUNÇÃO PUTCHAR()
Essa função escreve na tela o argumento de seu caractere na posição corrente. Veja
um exemplo na Figura 4.9.
Há inúmeras outras funções de manipulação de char complementares às que foram
vistas, como isalpha(), isupper(), islower(), isdigit(), isspace(), toupper(), tolower().
Funções Básicas da Biblioteca C 37
# include <stdio.h>
main( )
{
char ch;
printf("digite uma letra minúscula : ");
ch = getchar( );
putchar(toupper(ch));
putchar(’\n’);
}
Figura 4.9: Exemplo de programa que utiliza a função putchar

5
ESTRUTURAS DE CONTROLE DE FLUXO
Os comandos de controle de fluxo são a essência de qualquer linguagem, porque

governam o fluxo da execução do programa. São poderosos e ajudam a explicar a popula-
ridade da linguagem. Podemos dividir em três categorias. A primeira consiste em instruções
condicionais if e switch. A segunda são os comandos de controle de loop, o while, o for e
o do-while. A terceira contém instruções de desvio incondicional goto.
5.1 IF
Sintaxe:
if (condição) comando;
else comando;
Se a condição avaliar em verdadeiro (qualquer valor diferente de 0), o computador

executará o comando ou o bloco, de outro modo, se a cláusula else existir, o computador
executará o comando ou o bloco que é seu objetivo. Veja os exemplos das Figuras 5.1 e
5.2.
#include <stdio.h>
main( )
{
int a,b;
printf("digite dois números:");
scanf("%d%d",&a,&b);
if (b) printf("%d\n",a/b);
else printf("divisão por zero\n");
}
Figura 5.1: Exemplo de programa que utiliza o comando de decisão if

No exemplo da Figura 5.1, são pedidos dois números inteiros, a e b, e depois será
impresso o valor a/b somente se b for diferente de zero. Se b for igual a zero, será indicada
condição falsa para o comando if, e será executado o comando alternativo (else), sendo
impressa a mensagem de erro.
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
main( )
{
int num,segredo;
srand(time(NULL));
segredo = rand( )/100;
printf("Qual e o numero: ");
scanf("%d",&num);
if (segredo == num)
{
printf("Acertou!");
printf("\nO numero e %d\n", segredo);
}
else printf ("Errou, tente outra vez! \n");
}
Figura 5.2: O comando de decisão if com um bloco de instruções
Na Figura 5.1, havia apenas uma instrução a ser executada após a verificação do
comando if, portanto, não era necessário utilizar-se chaves. Na Figura 5.2, havia um bloco
de dois comandos a serem executados após o if, portanto, este conjunto de instruções deve
ser escrito dentro de um bloco que inicia com abre-chaves e finaliza com fecha-chaves.
5.2 IF-ELSE-IF
Sintaxe:
if (condição) comando;
else if (condição) comando;
Uma variável é testada sucessivamente contra uma lista de variáveis inteiras ou de

caracteres. Depois de encontrar uma coincidência, o comando ou o bloco de comandos é
executado.
Estruturas de Controle de Fluxo 41
Em uma estrutura if-else-if são colocadas várias opções que serão testadas uma de
cada vez, começando pela 1 e continuando a testar até que seja encontrada uma expressão
cujo resultado seja diferente de zero. Neste caso o programa executa a declaração corres-
pondente. Só uma declaração será executada, ou seja, só será executada a declaração
equivalente à primeira condição que for diferente de zero. A última declaração (default) é a
que será executada no caso de todas as condições serem falsas e é opcional.
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
main( )
{
int num,segredo;
srand(time(NULL));
segredo = rand( )/100;
printf("Qual e o numero: ");
scanf("%d", &num);
if (segredo == num)
{
printf("Acertou!");
printf("\nO numero e %d\n", segredo);
}
else if (segredo < num) printf ("Errado, muito alto!\n");
else printf ("Errado, muito baixo!\n");
}
Figura 5.3: Exemplo de um programa que utiliza o comando if-else-if
5.3 OPERADOR TERNÁRIO
Sintaxe: condição ? expressão1 : expressão2

É uma maneira compacta de expressar if-else. A operação ? funciona da seguinte
forma: a condição é testada, se for verdadeira será calculada a expressão1, se for falsa,
calcula-se a expressão2.
No exemplo apresentado na Figura 5.4, a variável max terá o valor de x se x for maior
que y, caso contrário, max assumirá o valor de y.
#include <stdio.h>
main( )
{
int x, y, max;
printf("Entre com dois números: ");
scanf("%d, %d", &x, &y);
max = (x>y) ? x : y;
printf("max = %d\n", max);
}
Figura 5.4: Exemplo de programa que utiliza o operador ternário
5.4 SWITCH
Sintaxe:
switch(variável){
case constante1:
seqüência de comandos;
break;
case constante2:
break;
default:
}
Uma variável é testada sucessivamente contra uma lista de variáveis inteiras ou de

caracteres. Depois de encontrar uma coincidência, o comando ou o bloco de comandos é
executado.
Se nenhuma coincidência for encontrada o comando default será executado. O de-
fault é opcional. A seqüência de comandos é executada até que o comando break seja
encontrado. A Figura 5.5 apresenta um exemplo de uso do switch.
5.5 LOOP FOR
Sintaxe: for (inicialização; condição; incremento) comando;
O comando for é de alguma maneira encontrado em todas linguagens procedurais

de programação. Este comando é normalmente utilizado para executar repetidamente um
#include <stdio.h>
main ( )
{
char x;
printf("1. Inclusão \n");
printf("2. Alteração \n");
printf("3. Exclusão \n");
printf(" Digite sua opção: ");
x = getchar( );
switch(x) {
case ’1’:
printf("escolheu inclusão\n");
break;
case ’2’:
printf("escolheu alteração\n");
break;
case ’3’:
printf("escolheu exclusão\n");
break;
default:
printf("opção inválida\n");
}
}
Figura 5.5: Exemplo de programa que utiliza o comando switch
conjunto de comandos por um número pré determinado de vezes. As Figuras 5.6 e 5.7
apresentam dois exemplos simples de utilização do comando de repetição for.
O for é o primeiro de uma série de três comandos para se trabalhar com loops (laços
de repetição). Os outros são o while e o do-while. Os três compõem a segunda família
de comandos de controle de fluxo. Podemos pensar nesta família como sendo a dos
comandos de repetição controlada.
Em sua forma mais simples, a incialização é um comando de atribuição que o compi-
lador usa para estabelecer a variável de controle do loop. A condição é uma expressão de
relação que testa a variável de controle do loop contra algum valor para determinar quando
o loop terminará. O incremento define a maneira como a variável de controle do loop será
alterada cada vez que o computador repetir a seqüência de comandos.
O comando for executa a inicialização incondicionalmente e testa a condição. Se
a condição for falsa ele não faz mais nada. Se a condição for verdadeira ele executa a
#include <stdio.h>
main( )
{
int x;
for(x=1; x<100; x++) printf("%d\n",x);
}
Figura 5.6: Exemplo de for com apenas um comando
#include <stdio.h>
main()
{
int x, xq;
printf ("\n\t Numero Quadrado \n\n");
for(x=1; x<100; x++)
{
xq = x*x;
printf("\t %d %d \n", x, xq);
}
}
Figura 5.7: Exemplo de for com um bloco de instruções
instrução (no primeiro exemplo printf) ou um bloco de instruções, faz o incremento e volta
a testar a condição. Ele fica repetindo estas operações até que a condição seja falsa.
O primeiro exemplo mostra um loop for que executa apenas um comando, e o se-
gundo exemplo executa um bloco com dois comandos, tendo, portanto, que ser escrito
entre chaves.
Uma aplicação muito utilizada para laços de repetição é para o cálculo de séries nu-
méricas. Por exemplo, o número pode ser calculado utilizando-se a série abaixo.

Esta série é calculada para os N primeiros inteiros, sendo N um número determinado

pelo usuário. Quanto maior N, melhor a precisão obtida. Depois de calcular o valor de S,
calcula-se :

O programa da Figura 5.8 apresenta uma forma de se calcular o valor de para um

número N de termos1 .
#include <stdio.h>
#include <math.h>
main( )
{
int N, n, sinal;
float S, x;
printf(" \n Envie o numero de termos ");
scanf(" %d ",&N);
S = 1;
x = 1;
sinal = 1;
for (n = 1; n < N; n++)
{
x +=2;
sinal = sinal;
S = S + (float)sinal/(x*x*x);
}
S = exp((1./3)*log(32*S));
printf("\n\n O valor de PI eh %f, para os %d", S, N);
printf("primeiros termos \n");
}
Figura 5.8: Programa para calcular o valor de
No exemplo apresentado na Figura 5.8, as funções exp() e log() fazem parte da bi-

blioteca math.h e são utilizadas para se calcular uma exponencial . Neste caso b = 32*S
e e = 1./3. Observe que é necessário colocar-se o ponto depois de 1, na fração, para que
o resultado seja um número em ponto flutuante, caso contrário será calculado o quociente
inteiro de 1/3 que resulta no valor zero.
A linguagem C permite que se utilize mais de uma variável no controle do laço de
repetição for. É permitido também omitir-se qualquer um dos elementos do for, isto é, se
não quisermos uma inicialização, por exemplo, poderemos omiti-la. Vejamos os exemplos
das Figuras 5.9 e 5.10.
1
Versões recentes do GCC requerem que o parâmetro -lm seja passado quando o programa utiliza a
biblioteca math.h: gcc -lm pi.c -o pi
#include <stdio.h>
main( )
{
int x,y;
for (x = 0, y = 0; x+y<100; ++x,++y) printf("%d ", x+y);
}
Figura 5.9: Laço de for com duas variáveis de controle
Um uso interessante para o for é o loop infinito, como nenhuma das três definições
são obrigatórias, podemos deixar a condição em aberto, como visto na Figura 5.10. Outra
forma usual do for é o for aninhado, ou seja, um for dentro de outro, como visto nas
Figuras 5.11 e 5.12.
#include <stdio.h>
main( )
{
for ( ; ; ) printf ("loop infinito\n");
}
Figura 5.10: Loop infinito
#include <stdio.h>
main( )
{
int linha,coluna;
for(linha=1; linha<=24; linha++)
{
for(coluna=1; coluna<40; coluna++) printf("-");
putchar(’\n’);
}
}
Figura 5.11: Laços de for aninhados

#include<stdio.h>
main( )
{
int i, j, k, temp;
printf("\t i i^2 i^3 i^4 \n");
for ( i=1;i<10; i++) /* laço externo: define o numero base */
{
for ( j=1; j<5; j++) /* primeiro nível do aninhamento */
{
temp = 1;
for ( k=0; k<j; k++) /* laço mais interno: eleva a j */
{
temp = temp*i;
}
printf("%9d",temp);
}
printf("\n");
}
}
Figura 5.12: Programa que exibe uma tabela das quatro primeiras potências dos números de 1 a 9
5.6 WHILE
Sintaxe: while(condição) comando;

Uma maneira possível de executar um laço é utilizando o comando while. Ele permite
que o código fique sendo executado numa mesma parte do programa de acordo com uma
determinada condição.
o comando pode ser vazio, simples ou bloco

ele é executado desde que a condição seja verdadeira
testa a condição antes de executar o laço
As Figuras 5.13 e 5.14 apresentam exemplos de utilização do laço de repetição while.

# include <stdio.h>
main( )
{
char ch;
while (ch != ’a’) ch = getchar( );
}
Figura 5.13: Exemplo simples de while
#include <stdio.h>
main( )
{
int x, xq;
x = 1;
while (x < 100)
{
xq = x*x;
x++;
}
}
Figura 5.14: Geração de uma tabela de quadrados de inteiros utilizando while
5.7 DO-WHILE
Sintaxe:
do
{comando; }
while(condição);
Também executa comandos repetitivos, mas neste caso, a condição só será testada
depois que o conjunto de instruções tiver sido executado pelo menos uma vez. As Figu-
ras 5.15 e 5.16 apresentam exemplos de utilização do laço do-while.
A principal diferença entre os comandos while e do-while é que no segundo o con-
junto de instruções do bloco deverá ser executado pelo menos uma vez, obrigatoriamente,
enquanto no primeiro (while) pode acontecer do bloco de instruções não ser executado
nenhuma vez.
#include <stdio.h>
main( )
{
int x, xq;
x = 1;
do {
xq = x*x;
x++;
}
while (x <100);
}
Figura 5.15: Geração de uma tabela de quadrados de inteiros utilizando do-while
5.8 BREAK
Quando o comando break é encontrado em qualquer lugar do corpo do for, ele causa
seu término imediato. O controle do programa passará então imediatamente para o código
que segue o loop. Veja o exemplo da Figura 5.17.
5.9 CONTINUE
Algumas vezes torna-se necessário “saltar” uma parte do programa, para isso utiliza-
mos o continue. O comando continue força a próxima iteração do loop — pula o código
que estiver em seguida. Um exemplo é apresentado na Figura 5.18.
# include <stdio.h>
main( )
{
char ch;
printf("1. inclusão\n");
printf("2. alteração\n");
printf("3. exclusão\n");
printf("4. sair\n");
printf(" Digite sua opção:");
do {
ch=getchar();
switch(ch)
{
case ’1’: printf("escolheu inclusao\n"); break;
case ’2’: printf("escolheu alteracao\n"); break;
case ’3’: printf("escolheu exclusao\n"); break;
case ’4’: printf("sair\n");
}
}
while(ch != ’1’ && ch != ’2’ && ch != ’3’ && ch != ’4’);
}
Figura 5.16: Exemplo de utilização do laço do-while
main( )
{
char ch;
for( ; ; )
{
ch = getchar( );
if (ch == ’a’) break;
}
}
Figura 5.17: Exemplo simples de utilização do comando break

# include <stdio.h>
main( )
{
int x;
for(x = 0; x<100; x++)
{
if (x%2) continue;
printf ("%d\n", x);
}
}
Figura 5.18: Exemplo de utilização do comando continue

6
MATRIZES
A matriz é um tipo de dado usado para representar uma certa quantidade de variáveis
que são referenciadas pelo mesmo nome. Consiste em locações contíguas de memória. O
endereço mais baixo corresponde ao primeiro elemento. A matriz é um conjunto ordenado
de dados que possuem o mesmo tipo.
6.1 MATRIZ UNIDIMENSIONAL
Sintaxe: tipo nome[tamanho];

As matrizes têm 0 como índice do primeiro elemento, portanto sendo declarada uma
matriz de inteiros de 10 elementos, o índice varia de 0 a 9.
Quando o compilador C encontra uma declaração de matriz ele reserva um espaço
na memória do computador suficientemente grande para armazenar o número de células
especificadas em tamanho. Por exemplo, se declararmos:
float exemplo[20];

o C irá reservar bytes. Estes bytes são reservados de maneira contígua. Neste
exemplo, os dados serão indexados de 0 a 19. Para acessá-los escrevemos:
exemplo[0]
exemplo[1]
.
.
exemplo[19]
Mas ninguém o impede de escrever:
exemplo[30]
exemplo[103]
Por quê? Porque o C não verifica se o índice que você usou está dentro dos limites
válidos. Este é um cuidado que o programador deve tomar. Se o programador não tiver
atenção com os limites de validade para os índices ele corre o risco de ter dados sobres-
critos ou de ver o computador travar. Vários erros sérios (bugs) terríveis podem surgir. As
Figuras 6.1, 6.2 e 6.3 apresentam programas que utilizam matrizes unidimensionais.
#include <stdio.h>
main( )
{
int x[10];
int t;
for(t=0;t<10;t++)
{
x[t] = t*2;
printf ("%d\n", x[t]);
}
}
Figura 6.1: Exemplo simples de utilização de matriz
6.2 MATRIZ MULTIDIMENSIONAL
Sintaxe: tipo nome[tamanho][tamanho] ...;

A matriz multidimensional funciona como a matriz de uma dimensão (vetor), mas tem
mais de um índice. As dimensões são declaradas em seqüência entre colchetes. Veja um
exemplo na Figura 6.4.
6.3 MATRIZES ESTÁTICAS
Os vetores de dados podem ser inicializados como os dados de tipos simples, mas
somente como variáveis globais. Quando for inicializar uma matriz local sua classe deve
ser static. Veja um exemplo na Figura 6.5.
6.4 LIMITES DAS MATRIZES
A verificação de limites não é feita pela linguagem, nem mensagem de erros são
enviadas, o programa tem que testar os limites das matrizes. Na Figura 6.6 é apresentado
Matrizes 55
#include <stdio.h>
main ( )
{
int num[100];
int count=0;
int totalnums;
do
{
printf ("\nEntre com um numero (-999 p/ terminar): ");
scanf ("%d",&num[count]);
count++;
}
while (num[count-1] != -999);
/* verifica quantos números foram digitados */
totalnums = count -1;
/* retira a contagem do número 999 */
printf ("\n\n\n\t Os números que você digitou foram:\n\n");
for (count = 0; count < totalnums; count++)
printf (" %d", num[count]);
}
Figura 6.2: Exemplo de armazenamento de dados em matriz unidimensional
#include <stdio.h>
main( )
{
int notas[5], i, soma;
for (i = 0; i<5; i++)
{
printf("Digite a nota do aluno %d: ", i );
scanf("%d", &notas[i] );
}
soma = 0;
for( i = 0; i<5; i++) soma = soma + notas[i];
printf("Media das notas: %d.", soma/5);
}
Figura 6.3: Operações com matriz

# include <stdio.h>
main ( )
{
int x[10][10];
int t, p=0;
for( t = 0; t<10; t++,p++)
{
x[t][p] = t*p;
printf("%d\n", x[t][p] );
}
}
Figura 6.4: Exemplo simples de utilização de matriz multidimensional
#include <stdio.h>
main( )
{
int i;
static int x[10] ={0,1,2,3,4,5,6,7,8,9};
for(i=0; i<10; i++) printf("%d\n", x[i] );
}
Figura 6.5: Exemplo de utilização de matriz estática
um programa que causará problemas ao computador durante sua execução porque o índice
da matriz erro, dentro do laço de for, excederá o tamanho da matriz (que é 10).
# include <stdio.h>
main( )
{
int erro[10], i;
for( i = 0; i<100; i++)
{
erro[i]=1;
printf (" %d\n ", erro[i] );
}
}
Figura 6.6: Erro na utilização de matriz

7
MANIPULAÇÃO DE STRINGS
Em C não existe um tipo de dado string, no seu lugar é utilizado uma matriz de
caracteres. Uma string é uma matriz tipo char que termina com ’\0’. Por essa razão uma
string deve conter uma posição a mais do que o número de caracteres que se deseja. O
caractere ’\0’ tem o código numérico 00, portanto pode-se verificar o final de uma string
procurando o valor numérico zero armazenado na matriz de caracteres. Constantes strings
são uma lista de caracteres que aparecem entre aspas, não sendo necessário colocar o ’\0’,
que é colocado pelo compilador. A Figura 7.1 mostra um programa simples para operação
com strings.
#include <stdio.h>
#include <string.h>
main( )
{
static char re[] = "lagarto";
// um vetor de caracteres de 8 posições
puts(re);
puts(&re[0]);
// uma variável do tipo matriz (ou vetor ) é referenciada
putchar(’\n’);
// como o endereço de sua primeira posição.
}
Figura 7.1: Exemplo simples de operação com strings
7.1 FUNÇÃO GETS()
Sintaxe: gets(nome_matriz);
É utilizada para leitura de uma string através do dispositivo padrão, até que a tecla
<ENTER> seja pressionada. A função gets() não testa limites na matriz em que é chamada.
A Figura 7.2 apresenta um programa simples que utiliza a função gets.
# include <stdio.h>
main()
{
char str[80];
gets(str);
printf("%s",str);
}
Figura 7.2: Programa simples que utiliza a função gets
7.2 FUNÇÃO PUTS()
Sintaxe: puts(nome_do_vetor_de_caracteres);
Escreve o seu argumento no dispositivo padrão de saída (vídeo), coloca um ’\n’ no fi-
nal. Reconhece os códigos de barra invertida. A Figura 7.3 apresenta um programa simples
que utiliza a função puts.
# include <stdio.h>
# include <string.h>
main()
{
puts("mensagem");
}
Figura 7.3: Exemplo simples de utilização da função puts
7.3 FUNÇÃO STRCPY()
Sintaxe: strcpy(destino, origem);

Esta função faz parte da biblioteca string.h. A função strcpy() copia o conteúdo de
uma string para uma variável tipo string (um vetor de char). No programa da Figura 7.4, a
string “alo” será copiada para a variável (matriz de caracteres) str.
Manipulação de Strings 59
# include <stdio.h>
# include <string.h>
main()
{
char str[20];
strcpy(str,"alo");
puts(str);
}
Figura 7.4: Utilização da função strcpy da biblioteca string.h
7.4 FUNÇÃO STRCAT()
Sintaxe: strcat(string1, string2);

Concatena duas strings. Não verifica tamanho. Um exemplo é visto na Figura 7.5.
#include <string.h>
#include <stdio.h>
main()
{
char um[20], dois[10];
strcpy (um, "bom");
strcpy (dois," dia");
strcat (um, dois); // une a string dois à string um
printf ("%s\n", um);
}
Figura 7.5: Utilização da função strcat da biblioteca string.h
7.5 FUNÇÃO STRCMP()
Sintaxe: strcmp(s1, s2);

Essa função compara duas strings, se forem iguais devolve 0. A Figura 7.6 mostra um
exemplo da função strcmp().
main( )
{
char s[80];
printf("Digite a senha:");
gets(s);
if (strcmp(s,"laranja")) printf("senha inválida\n");
else printf("senha ok!\n") ;
}
Figura 7.6: Utilização da função strcmp da biblioteca string.h

8
PONTEIROS
Sintaxe: tipo *nomevar;

Para ser um bom programador em linguagem C é fundamental que se tenha um bom
domínio de ponteiros. Por isto, o leitor deve acompanhar com atenção esta parte do curso
que trata deles. Ponteiros são tão importantes na linguagem C que você já os viu e nem
percebeu, quando falamos da função scanf. Em scanf("%d", &num); o operador & indica
o endereço de memória onde o compilador alocou a variável num ao ler a sua declaração
no início do programa.
O ponteiro é um dos aspectos mais fortes e poderosos e perigosos da linguagem C.
É comum, o programador utilizar o ponteiro incorretamente, ocasionando erros que são
muito difíceis de encontrar.
Ponteiro é uma variável que contém o endereço de outra variável. Os ponteiros são
utilizados para alocação dinâmica, podendo substituir matrizes com mais eficiência. Tam-
bém fornecem a maneira pelas quais funções podem modificar os argumentos chamados,
como veremos no capítulo de funções.
8.1 DECLARANDO PONTEIROS
Para declarar um ponteiro temos a seguinte forma geral:
tipo_do_ponteiro *nome_da_variável;
É o asterisco (*) que faz o compilador saber que aquela variável não vai guardar um
valor mas sim um endereço para aquele tipo especificado. A Figura 8.1 mostra exemplos
de declarações.
int *pt;
char *temp, *pt2;
Figura 8.1: Exemplos de declarações de ponteiros

O primeiro exemplo declara um ponteiro para um inteiro. O segundo declara dois

ponteiros para caracteres. Eles ainda não foram inicializados (como toda variável do C
que é apenas declarada). Isto significa que eles apontam para um lugar indefinido. Este
lugar pode estar, por exemplo, na porção da memória reservada ao sistema operacional do
computador. Usar o ponteiro nestas circunstâncias pode levar a um travamento do micro, ou
a algo pior. O ponteiro deve ser inicializado (apontado para algum lugar conhecido) antes
de ser usado! Isto é de suma importância!
Para atribuir um valor a um ponteiro recém-criado poderíamos igualá-lo a um valor de
memória. Mas, como saber a posição na memória de uma variável do nosso programa?
Seria muito difícil saber o endereço de cada variável que usamos, mesmo porque estes
endereços são determinados pelo compilador na hora da compilação e relocados na exe-
cução. Podemos então deixar que o compilador faça este trabalho por nós. Para saber o
endereço de uma variável basta usar o operador &. Veja o exemplo da Figura 8.2.
int count;
int *pt;
pt = &count;
Figura 8.2: Atribuição de valor a um ponteiro
Declaramos a variável count como sendo do tipo inteiro e um declaramos um pon-

teiro para um inteiro, pt. A expressão &count nos dá o endereço de count, o qual arma-
zenamos em pt. O valor de count não é alterado quando se inicializa o valor de pt.
Como nós colocamos um endereço em pt, ele está agora “liberado” para ser usado.
Podemos, por exemplo, alterar o valor de count usando pt. Para tanto vamos usar o ope-
rador “inverso” do operador &. É o operador *. No exemplo acima, uma vez que fizemos
pt=&count a expressão *pt é equivalente ao próprio count. Após a inicialização da variável
ponteiro com o endereço da variável inteira, esta variável pode ser referenciada pelo seu
nome ou pelo ponteiro que contém seu endereço. Isto significa que, se quisermos atribuir
um valor para count podemos fazer de duas formas:
count = 5;
ou
*pt = 5;
As duas formas são equivalentes e têm o mesmo resultado. Qualquer modificação
feita utilizando-se *pt, causará uma modificação na variável count.
Ponteiros 63
8.2 MANIPULAÇÃO DE PONTEIROS
Desde que os ponteiros são variáveis, eles podem ser manipulados tal como as variá-
veis. Se py e px são ponteiros para inteiros, então podemos fazer a declaração:
py = px;
A Figura 8.3 apresenta um programa que exemplifica a utilização de ponteiros para

acessar um variável x.
#include <stdio.h>
main( )
{
int x,*px,*py;
x = 9;
px = &x;
py = px;
printf("x= %d\n",x);
// imprime o valor de x
printf("&x= %d\n",&x);
// endereço da variável x, que é igual ao conteúdo de px
printf("px= %d\n",px);
// valor de px, que é o endereço de x
printf("*px= %d\n",*px);
// conteúdo da variável apontada por px, isto é, valor de x
printf("*py= %d\n",*py);
// imprime valor de x, pois py = px
}
Figura 8.3: Utilização de ponteiros
8.3 EXPRESSÕES COM PONTEIROS
Os ponteiros podem aparecer em expressões, se px aponta para um inteiro x, então

*px pode ser utilizado em qualquer lugar que x o seria.
O operador * tem maior precedência que as operações aritméticas, assim a expressão
abaixo pega o conteúdo do endereço que px aponta e soma 1.
y = *px+1; // y é uma variável do tipo de x

No próximo caso somente o ponteiro será incrementado e o conteúdo da próxima

posição da memória será atribuído a y.
y = *(px+1); // y é um ponteiro do tipo de px
Os incrementos e decrementos dos endereços podem ser realizados com os operado-

res ++ e --, que possuem precedência sobre o * e operações matemáticas e são avaliados
da direita para a esquerda:
*px++; /* sobe uma posição na memória*/

*(px--); /* mesma coisa de *px-- */
No exemplo da Figura 8.4, os parênteses são necessários, pois sem eles px seria
incrementado em vez do conteúdo que é apontado, porque os operadores * e ++ são avali-
ados da direita para esquerda.
(*px)++ /* equivale a x=x+1; ou *px+=1 */
8.4 PONTEIROS PARA PONTEIROS
Um ponteiro para um ponteiro é uma forma de indicação múltipla. Num ponteiro nor-
mal, seu valor é o endereço da variável desejada. Quando se trata de ponteiros para pon-
teiros, o primeiro ponteiro contém o endereço do segundo, que aponta para a variável de-
sejada. A Figura 8.5 apresenta um programa exemplo.
float **balanço; // balanço é um ponteiro para um ponteiro float.
8.5 PROBLEMAS COM PONTEIROS
O erro chamado de ponteiro perdido é um dos mais difíceis de se encontrar, pois a

cada vez que a operação com o ponteiro é utilizada, poderá estar sendo lido ou gravado
em posições desconhecidas da memória. Isso pode acarretar sobreposições em áreas de
dados ou mesmo área do programa na memória.
No trecho de programa da Figura 8.6, o ponteiro p não foi inicializado, não recebeu ne-
nhum endereço, portanto o valor 10 foi colocado em uma posição aleatória e desconhecida
de memória. A conseqüência desta atribuição é imprevisível.
Ponteiros 65
# include <stdio.h>
main()
{
int x, *px;
x = 1;
px = &x;
printf("x= %d\n", x);
printf("px= %u\n", px);
printf("*px+1= %d\n", *px+1);
printf("px=%u\n", px);
printf("*px= %d\n", *px);
printf("*px+=1= %d\n", *px+=1);
printf("px= %u\n",px);
printf("(*px)++=%d\n", (*px)++);
printf("*(px++)= %d\n", *(px++));
printf("*px++-=%d\n", *px++);
printf("px= %u\n", px);
}
Figura 8.4: Operações com Ponteiros
# include <stdio.h>
main( )
{
int x,*p,**q;
x=10;
p=&x;
q=&p;
printf("%d",**q);
}
Figura 8.5: Ponteiros para ponteiros
int *p;
x = 10;
*p = x;
Figura 8.6: Exemplo do erro de ponteiro perdido

9
PONTEIROS E MATRIZES
Em C existe um grande relacionamento entre ponteiros e matrizes, sendo que eles

podem ser tratados da mesma maneira. As versões com ponteiros geralmente são mais
rápidas.
Quando uma matriz é declarada da seguinte forma:
tipo_da_variável nome_da_variável [tam1][tam2] ... [tamN];
o compilador C calcula o tamanho, em bytes, necessário para armazenar esta matriz.

Este tamanho é:
tam1 x tam2 x tam3 x ... x tamN x tamanho_do_tipo
O compilador então aloca este número de bytes em um espaço livre de memória. O

nome da variável que você declarou é na verdade um ponteiro para o tipo da variável da
matriz. Este conceito é fundamental. Eis porque: tendo alocado na memória o espaço
para a matriz, ele toma o nome da variável (que é um ponteiro) e aponta para o primeiro
elemento da matriz.
Mas aí surge a pergunta: então como é que podemos usar a seguinte notação?
nome_da_variável[índice]
Isto pode ser facilmente explicado desde que você entenda que a notação acima é
absolutamente equivalente a se fazer:
*(nome_da_variável+índice)
É preciso lembrar que a memória de um computador não tem arranjos multidimensio-

nais, isto é, ela pode ser descrita como uma extensa lista de posições de memória enfilei-
radas, cada uma com um endereço específico. Portanto, quando for declarada uma matriz
de dimensão múltipla, o compilador colocará no programa executável uma rotina para o cál-
culo da posição de memória correspondente aos elementos da matriz referenciados pelos
múltiplos índices.
Em C, a indexação de uma matriz começa com o valor zero. É porque, ao pegarmos

o valor do primeiro elemento de uma matriz, queremos, de fato, *nome_da_matriz e então
devemos ter um índice igual a zero, resultando (*nome_da_matriz+0). Então sabemos que:
*nome_da_matriz é equivalente a nome_da_matriz[0]
9.1 MANIPULANDO MATRIZES ATRAVÉS DE PONTEIROS
Considerando a declaração da matriz int a[10]; Sendo pa um ponteiro para inteiro

então:
pa = &a[0];
/*passa o endereço inicial do vetor a para o ponteiro pa */
pa = a;
/* é a mesma coisa de pa=&a[0];*/
x = *pa;
/*passa o conteúdo de a[0] para x */
Se pa aponta para um elemento particular de um vetor a, então por definição pa+1

aponta para o próximo elemento, e em geral pa-i aponta para i elementos antes de pa e
pa+i para i elementos depois.
Se pa aponta para a[0] então: *(pa+1) aponta para a[1]; pa+i é o endereço de a[i] e
*(pa+i) é o conteúdo.
É possível fazer cópia de caracteres utilizando matrizes e ponteiros, conforme mos-
trado no programa da Figura 9.1.
# include <stdio.h>
main( )
{
int i = 0;
char t[10];
static char s[ ] = "abobora";
while (t[i] = s[i]) i++;
printf("%s\n",t);
}
Figura 9.1: Cópia de uma string (versão matriz)
No laço while, é feita a cópia de cada elemento de s para cada posição de t e é

incrementado o índice i até que o caractere ’\0’ finalizador de string, ou seja o valor 00
(NULL), seja encontrado em s.
Ponteiros e Matrizes 69
O mesmo exemplo pode ser resolvido utilizando-se ponteiros, conforme mostrado na

Figura 9.2.
# include <stdio.h>
main( )
{
char *ps,*pt, t[10], s[10];
strcpy (s,"abobora");
ps = s;
pt = &t[0];
while(*ps) *pt++ = *ps++;
printf("%s", t );
}
Figura 9.2: Cópia de uma string (versão ponteiro)
9.2 STRING E PONTEIROS
Sendo um ponteiro para caractere char *texto, podemos atribuir uma constante string
para texto, que não é uma cópia de caracteres, somente ponteiros são envolvidos. Neste
caso a string é armazenada como parte da função em que aparecem, ou seja, como cons-
tante. Um exemplo é visto na Figura 9.3.
char *texto = "composto";

/* funciona como static char texto[ ] = "composto"; */
#include <stdio.h>
main( )
{
char *al = "conjunto";
char re[ ] = "simples";
puts (al);
puts (&re[0]); /* ou puts(re); */
for( ; al; al++) putchar(*al);
putchar(’\n’);
}
Figura 9.3: Uso de um ponteiro no lugar de uma string

9.3 MATRIZES DE PONTEIROS
A declaração de matrizes de ponteiros é semelhante a qualquer outro tipo de matrizes:
int *x[10];
Para atribuir o endereço de uma variável inteira chamada var ao terceiro elemento da
matriz de ponteiros pode-se fazer um comando de atribuição simples:
x[2] = &var;
Neste caso, a matriz x contém ponteiros para variáveis inteiras, e o endereço da va-
riável var foi armazenado na posição 2 da matriz de ponteiros (x). Para verificar o conteúdo
de var pode-se utilizar o ponteiro armazenado em x:
*x[2];
As matrizes de ponteiros são tradicionalmente utilizadas para mensagens de erro, que

são constantes :
char *erro[ ] = {"arquivo não encontrado\n","erro de leitura\n"};

printf("%s", erro[0]);
printf("%s", erro[1]);
Um exemplo é mostrado na Figura 9.4.
#include <stdio.h>
main( )
{
char *erro[2];
erro[0] = "arquivo nao encontrado\n";
erro[1] = "erro da leitura\n";
for( ;*erro[0]; ) printf("%c", *erro[0]++);
}
Figura 9.4: Utilização de matrizes de ponteiros para mensagens de erro

10
FUNÇÕES
Uma função é uma unidade autônoma de código do programa e é projetada para cum-
prir uma tarefa particular. Geralmente os programas em C consistem em várias pequenas
funções. A declaração do tipo da função é obrigatória no GCC. Os parâmetros de recepção
de valores devem ser separados por vírgulas.
Sintaxe: tipo nome(parâmetros){ comandos}
Uma função pode retornar apenas um valor para o programa que a chamou, e este
valor deve ser do tipo especificado no cabeçalho da função, é o tipo da função. O nome
da função deverá sempre iniciar com uma letra, e normalmente é escrito em minúsculas. Às
vezes, os programadores iniciantes usam nomes com letras maiúsculas para não correrem
o risco de usar nome igual ao de alguma função já definida em alguma biblioteca existente
no compilador que está sendo usado. Por exemplo, pode-se definir uma função com o nome
Printf, escrita com P maiúsculo, para diferenciar da função printf da biblioteca stdio.h. Os
parâmetros são valores de variáveis que serão passados pelo programa para a função.
Além da variável de retorno nenhum outro valor pode ser retornado pela função para o
programa que a chamou.
10.1 FUNÇÃO SEM RETORNO
Quando uma função não retorna um valor para a função que a chamou ela é declarada
como void. No exemplo da Figura 10.1 a função inverso escreve a string vet em ordem
reversa (do último para o primeiro caracter).
Quando o código da função é escrito após a linha de comando que a chamará pela
primeira vez, deve-se escrever uma linha de anúncio da existência desta função, antes do
início da função main. Este anúncio de função é chamado de protótipo. Na verdade o
protótipo pode ser colocado em outro lugar, desde que seja antes da primeira chamada à
função.
A Figura 10.2 apresenta um outro exemplo de função sem retorno.
#include <stdio.h>
void inverso(char *s ); /* protótipo de função */
main( )
{
char *vet = "abcde";
inverso(vet);
}
void inverso(char *s) /* o parâmetro passado é um ponteiro */

{
int t = 0;
for( ; *s ; s++) t++;
/* t conta quantos caracteres tem o vetor s */
s--;
for( ; t-- ; ) printf("%c",*s--);
putchar(’\n’);
}
Figura 10.1: Inversão de uma string usando uma função que recebe um ponteiro
10.2 FUNÇÃO COM RETORNO
Quando o programador quiser que a função envie um valor para o programa que
a chamou, ele deverá declarar um tipo diferente de void para a função. A Figura 10.3
apresenta um exemplo de programa que utiliza uma função que recebe dois valores inteiros
(base, expoente) e retorna um inteiro (i) que é igual à base elevada ao expoente.
Observe que no loop for da função elevado não foi feita a inicialização da variável de
controle, mas esta variável é o expoente que já foi passado como parâmetro. O loop vai
parar de ser executado quando a variável expoente atingir o valor zero, que funciona como
o valor lógico falso.
A função elevado da Figura 10.3 modifica o valor da variável expoente que lhe foi
passada pela função main, mas esta modificação não afeta a variável e da função main,
pois expoente é apenas uma cópia de e, e as variáveis de uma função só existem dentro
desta, não sendo reconhecidas por outra função.
10.3 PARÂMETROS FORMAIS
Quando uma função utiliza argumentos, então ela deve declarar as variáveis que acei-
taram os valores dos argumentos, sendo essas variáveis os parâmetros formais. Veja um
Funções 73
#include<stdio.h>
void code (char *s);
main( )
{
char letras[26];
printf("\n\n Insira uma frase a ser codificada ");
printf("(máximo de 25 caracteres). \n");
scanf("%s", letras);
code( letras );
}
void code( char *s ) /* Codifica as letras */
{
char ch;
do
{
ch = *s++;
printf("%c", ch+1); /* desloca o alfabeto uma posição */
} while(ch);
}
Figura 10.2: Um codificador simples
exemplo na Figura 10.4, onde são declarados os parâmetros formais string, um ponteiro
que contém o endereço do início de uma string, e caractere, uma variável do tipo char.
A função pertence neste exemplo vai procurar um certo caractere dentro de uma
string. Se for encontrado, retorna o valor 1, senão, retorna 0.
10.3.1 Chamada por Valor
O valor de um argumento é copiado para o parâmetro formal da função, portanto

as alterações no processamento não alteram as variáveis. No exemplo da Figura 10.5, a
variável x recebe uma cópia da variável t, e a modificação de seu valor dentro da função
Sqr não altera o valor da variável t na função main.
10.3.2 Chamada por Referência
Quando se deseja que uma função modifique valores das variáveis do programa que
a chamou, deve-se passar para a função não a variável, mas o seu endereço na memória
do computador. Isto é feito utilizando-se ponteiros. No exemplo da Figura 10.6 a função
#include <stdio.h>
int elevado(int base, int expoente );
main( )
{
int b,e;
printf("Digite a base e expoente x, y : ");
scanf("%d,%d", &b, &e);
printf("valor = %d\n", elevado(b,e));
}
int elevado(int base, int expoente)
// são passados dois inteiros como parâmetros
{
int i;
if ((expoente<0) || (!base)) return 0;
i =1;
for( ; expoente; expoente--) i = base*i;
return i; // retorna o inteiro i para a função main
}
Figura 10.3: Função com retorno de inteiro
int pertence(char *string, char caracter)

{
while (*string) if (*string == caracter) return 1;
else string++;
return 0;
}
Figura 10.4: Parâmetros formais de uma função
troca troca os valores contidos nas variáveis x e y de main, utilizando os ponteiros a e b

que recebem os endereços de x e y respectivamente.
10.4 CLASSES DE VARIÁVEIS
Uma função pode chamar outras funções, mas o código que compreende o corpo de
uma função (bloco entre { }) está escondido do resto do programa, ele não pode afetar nem
ser afetado por outras partes do programa, a não ser que o código use variáveis globais.
Existem três classes básicas de variáveis: locais, estáticas e globais.
Funções 75
#include <stdio.h>
int Sqr( int x );
main( )
{
int t =10;
printf("%d eh o quadrado de %d", Sqr(t),t);
}
int Sqr(int x)
{
x = x*x; /* Modificação no valor de x não altera t */
return(x);
}
Figura 10.5: Passagem de valor de uma variável para uma função
#include <stdio.h>
void troca (int *a, int *b );
main( )
{
int x=10, y=20;
troca(&x,&y);
printf("x=%d y=%d\n", x, y);
}
void troca (int *a, int *b)
// *a e *b são ponteiros que recebem os endereços de x e y
{
int temp;
temp = *a;
*a = *b;
*b = temp;
}
Figura 10.6: Função que utiliza passagem por referência
10.4.1 Variáveis Locais
As variáveis que são declaradas dentro de uma função são chamadas de locais. Na
realidade todas as variáveis declaradas dentro de um bloco { } podem ser referenciadas
apenas dentro deste bloco. Elas existem apenas durante a execução do bloco de código
no qual estão declaradas. O armazenamento de variáveis locais por default é feito na pilha,
assim sendo uma região dinâmica. A Figura 10.7 apresenta um exemplo de função que
utiliza variáveis locais.
#include <stdio.h>
void linha (int x);
main( )
{
int tamanho;
printf ("Digite o tamanho: ");
scanf ("%d", &tamanho);
linha (tamanho);
}
void linha(int x)
{
int i;
for( i = 0; i <= x; i++) putchar(95);
/* A variável i na função linha
não é reconhecida pela função main.*/
}
Figura 10.7: Variáveis locais em uma função
10.4.2 Variáveis Globais
São conhecidas por todo programa e podem ser usadas em qualquer parte do código.
Permanecem com seu valor durante toda execução do programa. Deve ser declarada fora
de qualquer função e até mesmo antes da declaração da função main. Fica numa região
fixa da memória própria para esse fim. Um exemplo é visto na Figura 10.8.
Sendo a variável cont declarada fora de qualquer função do programa, ela será uma
variável global, sendo, portanto reconhecida pelos três blocos de programa (main, func1,
func2). A modificação do valor de cont em func2, resulta na modificação do mesmo cont
em func1. Logo, func1 irá escrever o valor 109 (e não 100) para cont.
10.4.3 Variáveis Estáticas
Funcionam de forma parecida com as variáveis globais, conservando o valor durante

a execução de diferentes funções do programa. No entanto só são reconhecidas na função
onde estão declaradas. São muito utilizadas para inicializar vetores, conforme pode ser
visto no programa da Figura 10.9.
Funções 77
# include <stdio.h>
void func1( ), func2( );
int cont;
main( )
{
cont = 100;
func1( );
}
void func1( )
{
int temp;
temp = cont;
func2( );
printf ("temp é = %d", temp);
printf ("cont é = %d", cont);
}
void func2( )
{
int cont;
for(cont =1; cont<10; cont++) printf(" . ");
}
Figura 10.8: Variáveis globais em um programa
#include <stdio.h>
main( )
{
int i;
static int x[10] = {0,1,2,3,4,5,6,7,8,9};
for(i=0; i<10; i++) printf (" %d \n ", x[i]);
}
Figura 10.9: Variáveis locais em uma função

10.5 FUNÇÕES COM MATRIZES
10.5.1 Passando Parâmetros Formais

Para passar uma matriz para uma função é necessário passar somente o endereço
e não uma cópia da matriz. Quando vamos passar uma matriz como argumento de uma
função, podemos declarar a função de três maneiras equivalentes. Digamos que temos a
seguinte matriz:
int matrx [50];
e que queiramos passá-la como argumento de uma função func(). Podemos declarar
func() das três maneiras seguintes:
void func (int matrx[50]);

void func (int matrx[]);
void func (int *matrx);
Veja que, nos três casos, teremos dentro de func() um int* chamado matrx. Note que,
no caso de estarmos passando uma matriz para uma função, teremos de passá-la através
de um ponteiro. Isto faz com que possamos alterar o valor desta matriz dentro da função.
A Figura 10.10 apresenta um exemplo de função que trabalha com uma matriz.
#include <stdio.h>
void mostra (int num[ ] );
main( )
{
int t[10], i;
for ( i = 0; i < 10; i++) t[i] = i;
mostra(t);
}
void mostra ( int num[ ] )
{
int i;
for( i = 0; i < 10; i++ ) printf ("%d", num[i]);
}
Figura 10.10: Função que utiliza uma matriz
A função mostra, da Figura 10.10, poderia ter sido escrita utilizando-se um ponteiro
na passagem de parâmetros, conforme se vê na Figura 10.11.
Funções 79
void mostra ( int *num )

{
int i;
for( i = 0; i < 10; i++) printf ("%d", *(num+i));
}
Figura 10.11: Função que opera sobre uma matriz utilizando um ponteiro
A Figura 10.12 apresenta um exemplo de função que recebe dois ponteiros como
argumentos e retorna um inteiro. Ela retorna o índice de início de uma substring dentro de
uma string ou -1, se nenhuma correspondência for encontrada. Verifique que existem duas
declarações return, o que é perfeitamente possível em C, visto que a função terminará
quando passar pela primeira linha contendo return. Sem o uso da segunda declaração
return, uma variável temporária e código extra precisariam ser usados.
encontra_substr(char *sub, char *str)

{
register int t;
char *p, *p2;
for (t = 0; str[t] ; t++)

{
p = &str[t]; /* pega o ponto de início de str */
p2 = sub;
while(*p2 && (*p2==*p))
/* enquanto nao for final de sub e for */
{
p++; /* verificado igualdade entre os caracteres */
p2++; /* de sub e str, avança. */
}
if (!*p2) return t;
/* se está no final de sub, foi encontrada a substring */
}
return -1;
}
Figura 10.12: Função que procura uma substring dentro de uma string
10.5.2 Alterando os Valores da Matriz

Existem várias formas de se alterar os valores de uma matriz utilizando-se uma função.
A Figura 10.13 mostra um exemplo de como fazê-lo utilizando um ponteiro que aponta para
o primeiro elemento da matriz s.
#include <stdio.h>
void maiusc (char *string );
main( )
{
char s[80];
gets(s);
maiusc(s);
}
void maiusc (char *string)
{
register int t;
for( t = 0; string[t]; t++)
{
string[t] = toupper ( string[t] );
printf ("%c", string[t] );
}
}
Figura 10.13: Alterando valores de uma matriz

11
ARGUMENTOS DA LINHA DE COMANDO
No ambiente C existe uma maneira de passar argumentos através da linha de coman-

dos para um programa quando ele inicia. O primeiro argumento (argc) é a quantidade de
argumentos que foram passados quando o programa foi chamado; o segundo argumento
(argv) é um ponteiro de vetores de caracteres que contém os argumentos, um para cada
string. Por convenção argv[0] é o nome do programa que foi chamado, portanto argc é
pelo menos igual a 1. Cada argumento da linha de comando deve ser separado por um es-
paço ou tabulação. A Figura 11.1 apresenta um programa simples que utiliza argumentos
na linha de comando.
#include <stdio.h>
int main( int argc, char *argv[ ] )
{
if (argc != 2)
{
printf("falta digitar o nome\n");
exit(0);
}
printf("alo %s", argv[1]);
}
Figura 11.1: Programa que recebe uma string na linha de comando
Este programa, depois de compilado, deverá ser chamado na linha de comando como
NomePrograma NomeUsuário. Então ele escreverá na tela do computador a mensagem:
“alo NomeUsuário”.
O programa da Figura 11.2 deve ser chamado na linha de comando como NomePro-
grama 3 display, para que seja apresentada na tela a contagem 3, 2, 1, e seja emitido um
sinal sonoro (o correspondente ASCII do número 7). Se não for digitado o número 3 e a
palavra display, a contagem não será apresentada.
#include <stdio.h>
int main( int argc, char *argv[ ] )
{
int disp, cont;
if (argc<2)
{
printf("falta digitar o valor para contagem\n");
exit(0);
}
if (argc==3 && !strcmp(argv[2],"display")) disp = 1;
else disp = 0;
for(cont = atoi( argv[1] ); cont; --cont)
if(disp) printf("%d", cont);
printf("%c", 7);
}
Figura 11.2: Programa que recebe argumentos na linha de comando

12
TIPOS DE DADOS DEFINIDOS PELO
USUÁRIO
A linguagem C permite ao programador criar seus próprios tipos de dados de cinco

formas diferentes: Estruturas, Campo-bit, União, Enumeração e Tipo-definido. A Estrutura
(structure) é um agrupamento de variáveis sob um mesmo nome, o Campo-bit é um tipo
de Estrutura que permite acesso individualizado aos bits de uma variável, a União (union)
permite que duas ou mais variáveis de tipos diferentes utilizem a mesma posição de me-
mória alternadamente, a Enumeração (enum) é uma lista de símbolos, e o Tipo-definido
seria melhor chamado como Tipo-redefinido, porque utiliza o comando typedef para dar
um outro nome a um tipo de dado já existente.
12.1 ESTRUTURAS
Ao manusearmos dados, muitas vezes nos deparamos com informações que não são
fáceis de armazenar em variáveis escalares como são os tipos inteiro e ponto flutuante,
mas na verdade são conjuntos de coisas. Estes tipos de dados são compostos por vários
tipos básicos do C.
Uma estrutura é uma coleção de variáveis referenciadas por um único nome, provendo
um meio conveniente de manter informações relacionadas agrupadas. Uma declaração
de estrutura forma um modelo que pode ser usado para criar variáveis de estruturas. As
variáveis que compreendem a estrutura são chamadas de membros da estrutura ou campos
da estrutura. A palavra reservada struct usada para definir uma estrutura, como indicado
na formulação geral da Figura reffig:estrutura.txt.
O identificador dá nome ao novo tipo de variável estrutura criado, no exemplo,
variáveis_estrutura é uma lista de variáveis do tipo identificador, este item é
opcional na declaração da estrutura. A figura 2 apresenta um exemplo simples de uma es-
trutura que poderia ser usada para o banco de dados de clientes de uma agência bancária.
As variáveis estrutura são declaradas de duas formas diferentes, primeiro imediatamente
após a declaração da estrutura, depois, de forma separada.
struct identificador {
tipo nome_de_elemento_1;
tipo nome_de_elemento_2;
...
tipo nome_de_elemento_N;
} variáveis_estrutura;
Figura 12.1: Forma geral de declaração de uma estrutura
struct Conta_Banco {
int Num_conta;
unsigned long int CPF;
int Digitos_CPF;
char nome[30];
char Sexo;
float Saldo;
int Data_Abertura [8];
} Gerente, Cliente_padrao[1000], Cliente_especial[100];
int Num_conta;
int Digitos_CPF;
char nome[30];
char Sexo;
float Saldo;
};
struct Conta_Banco Gerente, Cliente_padrao[1000],

Cliente_especial[100];
Figura 12.2: Declaração de uma estrutura para clientes de um banco
No exemplo da Figura 12.2, a estrutura Conta_Banco possue 7 campos, sendo o

primeiro, um inteiro que armazena o número da conta, que podemos dizer que deve ter
no máximo 4 dígitos. O segundo e o terceiro campos são um número inteiro que deverá
comportar os 9 algarismos do CPF e um inteiro para guardar o par de digitos verificadores
do CPF. Depois é utilizada uma string para armazenar o nome e sobrenome do cliente, e
Tipos de Dados Definidos Pelo Usuário 85
um char para idientificar o sexo (’M’ ou ’F’). Um float armazena o saldo do cliente e
um vetor de inteiros indica a data da abertura da conta.
Os membros de uma estrutura podem ser qualquer tipo de dados conhecidos da lin-
guagem C, inclusive ponteiros, ou podem ser outros tipos de dados criados pelo programa-
dor, inclusive outras estruturas.
12.1.1 Trabalhando com Estruturas
Após criar o novo tipo de variável, no caso uma estrutura, temos que criar algumas
variáveis deste tipo, e depois utilizá-las no programa. É como criar uma variável de qualquer
outro tipo, int, char, etc.
Na Figura 12.2 foram mostradas duas formas de criar variáveis do tipo estrutura, uma
forma é declarar a variável logo após a declaração da estrutura e a outra forma é declarar a
variável como outra qualquer na lista declaração de variáveis. Vamos utilizar o exemplo da
segunda forma.
Foram criadas três variáveis. A primeira é uma variável simples, Gerente. A segunda
e a terceira são vetores (matrizes unidimensionais) que armazenam várias variáveis do tipo
Conta_Banco. Matrizes de estruturas são muito usadas, para declará-la primeiro define-se
a estrutura e então declara uma variável matriz daquele tipo. Para acessar uma estrutura
específica, o nome da estrutura é indexado.
Como acessar os campos individuais dentro de cada variável estrutura ? Membros
individuais da estrutura são referenciados pelo uso do operador de seleção de membro: o
ponto. A Figura 12.3 apresenta um trecho de código com várias referências aos membros
das variáveis declaradas na Figura 12.2. A primeira atribui um saldo à conta do gerente
(variável Gerente).
Se duas variáveis são do mesmo tipo, pode-se atribuir uma a outra. Neste caso todos
os elementos do lado esquerdo da atribuição receberão os valores dos elementos corres-
pondentes da estrutura do lado direito.
Passando elementos da estrutura para funções
A passagem de elementos de estruturas para funções não tem segredos, é feita como
a passagem de qualquer parâmetro, podendo ser por valor ou por referência. A única coisa
que o programador deve observar é que o tipo da variável que receberá o valor na função
tem que ser o mesmo tipo do parâmetro da estrutura que está sendo passado. A Figura 12.4
mostra alguns exemplos de passagens, e um exemplo incorreto.
int main (void) {

int i, j;
float recebe;
char Nome[30]
...
Gerente.Saldo = 12947.51;
...
i = 12;
Nome = Cliente_especial[i].Nome;
...
Cliente_especial[10].Sexo = ’F’;
...
for (j = 500; j <510; j++)
printf("\n\n Nome do cliente %d = %s ", j,
Cliente_padrão[j].Nome);
...
} /* Fim do Programa */
Figura 12.3: Exemplos de acesso a membros de variáveis do tipo estrutura
Passsando estruturas inteiras para funções
Quando uma estrutura é usada como argumento para uma função, a estrutura inteira
é passada usando o método padrão de chamada por valor. Qualquer modificação feita na
variável estrutura dentro da função não afetará a variável usada para chamar a função.
Quando usar uma estrutura como um parâmetro, lembre-se de que o tipo de argu-
mento deve coincidir com o tipo de parâmetro. No exemplo da Figura 12.5, tanto a variável
de chamada, arg, quanto o parâmetro que a recebe na função, param, são do tipo struct
exemplo.
int Num_conta;
int Digtos_CPF;
char nome[30];
char Sexo;
float Saldo;
};
/* função para atualizar saldo de uma conta cujo número está sendo passado */
int Atualiza_Saldo( int Numero, float Saldo_Novo) {
procedimentos da função;
return 0; /* se a função teve sucesso, retorna zero */
}
/* função para atualizar Nome de cliente, por exemplo,

de Joao Giacomin para: Joao C. Giacomin */
int Atualiza_Nome( char Velho[30], Novo[30]) {
strcpy(Velho,Novo];
return 0;
}
main( ) {
int Numero;
float Saldo;
char Nome[30], Nome_Novo[30];
/* Inicializar programa e variáveis */

...
Atualiza_Saldo(Numero, 1893.20); /* passagem por valor */
...
Saldo = 34587.9;
Atualiza_Saldo(Gerente.Num_conta, Saldo); /* passagem por valor */
...
Saldo = 187.09;
Atualiza_Saldo(Cliente_padrao[273].Num_conta, Saldo); /* passagem por valor */
...
scanf("%s",Nome_Novo);
Atualiza_Nome(Cliente_especial[12].nome, &Nome_Novo[0]);
/* passagem por referência */
...
Atualiza_Saldo(Gerente.Sexo, 1893.20) ;
/* Erro - atribuição de um char a um int */
...
}
Figura 12.4: Exemplos de passagens de elementos de estruturas para funções
Ponteiros para estruturas
A linguagem C permite ponteiros para estruturas da mesma maneira que aceita pon-
teiros para qualquer outro tipo de variável.
struct exemplo {
int a,b;
char ch;
};
void func_1(struct exemplo); /* protótipo */
int main( ) {
struct exemplo arg;
arg.a=arg.b=1000;
ch=’a’;
func_1(arg);
return 0;
}
void func_1(struct exemplo parm) {

printf("%d\n%d\n%c",parm.a,parm.b,parm.ch);
}
Figura 12.5: Exemplo de passagem de uma estrutura inteira para uma função
Para declarar um ponteiro para estrutura coloca-se o operador * na frente do nome da

variável. Exemplo: struct Conta_Banco *inf_cliente;
Pode-se passar toda a estrutura para uma função, mas isto se torna inviável enquanto
as estruturas se tornam cada vez maiores. O grande problema quando se trabalha com
estrutruras grandes é o tempo gasto para passar todos os parâmetros pela pilha, isto passa
a demandar muito tempo de execução. A solução para esse problema é passar somente
um ponteiro para a função (Figura 12.6).
Para encontrar o endereço de uma variável estrutura, o operador & é colocado antes
do nome da variável estrutura.
O operador * é raramente utilizado quando trabalhamos com ponteiros para estrutu-

ras. Para o acesso a um membro de uma estrutura, existe um operador especial definido
pela linguagem C, é o operador seta, que é composto pelo sinal negativo seguido pelo si-
nal de maior: “->”. A Figura 12.7 apresenta a utilização deste operador no exemplo da
Figura 12.6
/* a mesma estrutura da figura 12.4 */
};
int main( ) {
struct Conta_Banco Gerente, *p_Conta;
/* declara um ponteiro para uma estrutura Conta_Banco */
p_Conta = &Gerente;
/* coloca o endereço de Gerente no ponteiro */
printf(" \n Saldo do Gerente = %f ", (*p_Conta).saldo);
return 0;
}
Figura 12.6: Exemplo de ponteiro para estrutura
int main( ) {
struct Conta_Banco Gerente, *p_Conta;
p_Conta = &Gerente;
printf(" \n Saldo do Gerente = %f ", p_Conta->saldo);
return 0;
}
Figura 12.7: Exemplo de passagem de uma estrutura inteira para uma função
12.2 UNIÕES
Uma declaração union determina uma única localização de memória onde podem
estar armazenadas várias variáveis diferentes. A declaração de uma união é semelhante à
declaração de uma estrutura, como mostrado na Figura 12.8.
As variáveis_union não precisam ser declaradas imediatamente após a declara-
ção da union, elas podem ser declaradas posteriormente como se declaram as variáveis
inteiras e de ponto flutuante.
Quando uma variável union é declarada, o compilador cria automaticamente uma

variável grande o bastante para armazenar o tipo da variável de maior tamanho na union.
union nome_da_union {
tipo_1 nome_1;
tipo_2 nome_2;
...
tipo_n nome_n;
} variáveis_union;
Figura 12.8: Forma geral de declaração de uma união
A Figura 12.9 apresenta dois exemplos de uniões, a primeira possui elementos do

mesmo tipo, float, e a segunda de tipos diferentes. São mostradas também formas dife-
rentes de se acessar os elementos das uniões. Uniões podem ser feitas com variáveis de
diferentes tipos. Neste caso, a memória alocada corresponde ao tamanho da maior variável
na union.
No exemplo da Figura 12.9, ao se colocar o valor 54.14 na variável Temp_1.Faren,
este valor foi atribuido também a Temp_1.Celcius, porque Faren e Celcius ocupam a
mesma posição de memória da variável Temp_1. Por isso não foi mais possível recuperar
o valor 12.3.
A união Identificador abriga três tipos de variáveis diferentes, portanto, muito
cuidado deve ser tomado na sua utilização. Edite e execute o programa da Figura 12.9 e
verifique alguns possíveis erros que poderão ocorrer na execução da função printf. Evite
armazenar uma variável de um tipo em uma union e acessá-la como variável de outro tipo.
Finalmente, verifique no exemplo da Figura 12.9 que o acesso a um elemento union
utiliza a mesma sintaxe das estruturas: os operadores ponto e seta. Quando se opera
diretamente na union, usa-se o operador ponto. Se a variável union é acessada por meio
de um ponteiro, usa-se o operador seta. As formas de passar variáveis tipo union para
funções são as mesmas da passagem de variáveis struct.
12.3 ENUMERAÇÕES
Uma enumeração é uma extensão da linguagem C acrescentada pelo padrão ANSI.

Uma enumeração é um conjunto de constantes inteiras que especifica todos os valores le-
gais que uma variável de um tipo específico pode ter. São definidas de modo semelhante às
estruturas com a palavra reservada enum usada para indicar o início de um tipo enumerado.
As enumerações são definidas como as estruturas, coloca-se a palavra chave enum,
depois uma lista de palavras entre chaves e em seguida os nomes das variáveis que terão
este tipo de enumeração. Tal como nas estruturas e uniões, os nomes das variáveis não
precisam vir imediatamente após a declaração da enumeração.
A Figura 12.10 apresenta um exemplo de enumeração que um aluno utiliza para or-
ganizar seu horário de aulas semanais. A variável semana é uma enumeração dos dias da
semana.
O ponto-chave para o entendimento das enumerações é que cada símbolo representa
um valor inteiro. Dessa forma, eles podem ser usados em qualquer lugar em que um inteiro
possa ser usado. Se não for atribuido nenhum valor aos símbolos, como no exemplo, seus
valores estarão em seqüência iniciando de zero. Portanto, neste exemplo, Dom = 0, Seg
= 1, e Sab = 6.
Se quiséssemos mudar esta seqüência, poderíamos atribuir alguns valores, por exem-
plo, se atribuíssemos o valor 5 ao símbolo Seg, na declaração da enumeração (Seg = 5),
então teríamos: Dom = 0, Seg = 5, Ter = 6, . . . , Sab = 10.
Se o usuário tivesse a intenção de utilizar esta enumeração em uma chave, comando
switch, e gostaria que cada dia da semana correspondesse ao seu número de ordem.
Portanto, atribuiria apenas o primeiro símbolo, Dom=1, e os outros viriam na seqüência,
como pode ser visto na Figura 12.11.
Verifique, neste exemplo, que poderiam ser colocados os valores inteiros de 1 a 7 no
lugar dos símbolos de Seg a Dom, mas da forma como foi feito o programa ficou bem mais
legível.
Para finalizar, eu vou chamar a atenção para um fato curioso. Se cada símbolo cor-
responde a um inteiro, então pode-se atribuir os símbolos a variáveis inteiras. Por exemplo,
se o programador quisesse saber as aulas de amanhã, poderia ter somado 1 ao valor da
variável Dia, ou poderia ter feito no programa a seguinte atribuição: Dia = Qui. Assim
poderia pesquisar o horário de quinta-feira, que é o dia correspondente ao número inteiro
5.
12.4 TYPEDEF
A linguagem C permite definir explicitamente novos nomes de tipos de dados conhe-

cidos, usando-se a palavra reservada typedef. Não se cria um novo tipo de dado, mas,
ao contrário, define-se um novo nome para um tipo existente.
Forma geral: typedef tipo nome;
Onde tipo é qualquer tipo de dado permitido e nome é o novo nome para esse tipo.
O typedef poderia se utilizado para chamar de Real qualquer variável do tipo float.
A vantagem de se fazer isto é que a palavra Real nos traduz melhor o sentido dos números
em ponto flutuante que a palavra float.
Mas não há problema em se fazer isto? Não, o compilador vai ler todas as decla-
rações de variáveis tipo Real, vai traduzir a palavra Real para float e depois compilar
normalmente.
O typedef torna-se especialmente útil quando deseja-se utilizar um identificador
único para um tipo novo de variável que foi criada, como uma struct, ou uma union,
ou uma enum. Dois exemplos de utilização de typedef podem ser vistos na Figura 12.12,
que é uma forma diferente do exemplo da Figura 12.9
Verifique que a única diferença agora é que é preciso escrever apenas um identifica-
dor, u_graus, para declarar uma variável deste tipo de união, e não escrever dois identifi-
cadores, union graus. Isto traz mais legibilidade ao programa.
12.5 CAMPOS-DE-BITS
Campos bit são uma extensão da estrutura simples que permite que os bits individuais
de uma determinada estrutura sejam acessados.
A linguagem C tem um modo próprio de acessar um ou mais bits dentro de um byte
ou palavra. Isso pode ser útil por diversas razões: primeiro, se o espaço é limitado, pode-se
armazenar muitas variáveis booleanas (true/false) em um byte; segundo, certas interfaces
de dispositivos transmitem informações codificadas em bits dentro de um byte; e terceiro,
certas rotinas de codificação de dados necessitam acessar os bits dentro de um byte.
Um método que a linguagem C utiliza para acessar os bits baseia-se na estrutura
chamada campos-bit. Um campo-bit é somente um tipo de membro de estrutura que define
o quão grande, em bits, cada elemento deve ser. A Figura 12.13 apresenta a forma geral de
uma estrutura tipo campos-de-bits. Verifique que se trata de uma estrutura, mas o tamanho
de cada elemento, ou campo, é definido em bits. Os tamanhos indicados acima são dados
em números de bits. Vamos, por exemplo, declarar uma estrutura de campos bit que nos
permite acesso a um byte pedaço por pedaço.
A Figura 12.14 apresenta um exemplo de estrutura de campos-de-bits.
As variáveis campos-de-bits possuem certas restrições: não se pode obter seu ende-
reço; não podem ser colocadas em matrizes; não se pode sobrepor o limite dos inteiros.
No entanto é válido misturar membros normais de estrutura com elementos compos-bit. Os
membros, ou campos, das variáveis deste tipo podem ser acessados tal como são acessa-
dos os membros de uma estrutura comum.
union graus {
float Celcius;
float Faren;
};
union Identificador {
char Letra;
int Inteiro;
float Real;
}
int main ( ) {
union graus Temp_1, Temp_2, *p_T;
/ * p_T é um ponteiro tipo union graus */
union Ientificador Id_1, Id_2;
Temp_1.Celcius = 12.3;
Temp_2.Faren = (Temp_1.Celcius + 40) * 9 / 5 - 40;
p_T = &Temp_1;
p_T->Faren = Temp_2.Faren;
/* Aqui o número 12.3 de Temp_1 foi substituído por

54.14 calculado acima */
/* Se for feita uma tentativa de ler o valor 12.3,
só se conseguirá 54.14 */
printf ("\n Temperatura = %f ", Temp_1.Celcius);

/* Será impresso o valor 54.14 */
Identificador.Letra = ’A’ ;
printf ("\n Letra = %c \n Inteiro = %d \n Real = %f ",
Identificador.Letra, Identificador.Inteiro,
Identificador.Real);
return 0;
}
Figura 12.9: Declarações de uniões e formas de utilização

enum Semana {Dom, Seg, Ter, Qua, Qui, Sex, Sab} Escola;
Figura 12.10: Exemplo de enumeração
enum Semana {Dom = 1, Seg, Ter, Qua, Qui, Sex, Sab};
int main ( ) {
int Dia ;
enum Semana Escola;
scanf("%d", Dia);
switch(Dia) {
case Seg: printf ("\n Portugues\n Matematica\n Geografia\n");
break;
case Ter: printf ("\n Ingles\n História\n Matematica\n");
break;
case Qua: printf ("\n Geografia\n Matemática\n Portugues\n");
break;
case Qui: printf ("\n Matematica\n Geografia\n Ingles\n");
break;
case Sex: printf ("\n História\n Portugues\n Geografia\n");
break;
case Sab:
case Dom: printf ("\n Fim de semana\n");
break;
default: printf ("\n Dia errado\n");
}
return 0;
}
Figura 12.11: Exemplo de utilização de uma enumeração

union graus {
float Celcius;
float Faren;
};
typedef union graus u_graus;
int main ( ) {
u_graus Temp_1
u_graus Temp_2;
u_graus *p_T; /* p_T é um ponteiro tipo union graus */
Temp_1.Celcius = 12.3;
Temp_2.Faren = (Temp_1.Celcius + 40) * 9 / 5 - 40;
p_T = &Temp_1;
p_T -> Faren = Temp_2.Faren;
printf ( "\n Temperatura = %f ", Temp_1.Celcius );
return 0;
}
Figura 12.12: Utilizando typedef
struct nome_do_tipo_estrutura {
tipo nome_1: tamanho_1;
...
tipo nome_N: tamanho_N;
}
Figura 12.13: Forma geral de campos-de-bits

struct nome_do_tipo_estrutura {
...
tipo nome_N: tamanho_N;
}
Figura 12.14: Exemplo de estrutura de campos-de-bits

13
NOÇÕES DE MANIPULAÇÃO DE
ARQUIVOS
Para tratar de arquivos a linguagem C fornece um nível de abstração entre o progra-

mador e o dispositivo que estiver sendo usado. Esta abstração é chamada fila de bytes e o
dispositivo normalmente é o arquivo. Existe um sistema bufferizado de acesso ao arquivo,
onde um ponteiro de arquivo define vários aspectos do arquivo, como nome, status e
posição corrente, além de ter a fila associada a ele. A Figura 13.1 mostra um programa
exemplo que escreve uma seqüência de números em um arquivo (teste.dat) e depois lê os
valores contidos no arquivo.
13.1 ABRINDO E FECHANDO UM ARQUIVO
No sistema de entrada e saída ANSI é definido o tipo “ponteiro de arquivo”. Este não
é um tipo propriamente dito, mas uma definição usando o comando typedef. Esta definição
está no arquivo cabeçalho stdio.h ou stdlib.h dependendo do seu compilador. Podemos
declarar um ponteiro de arquivo da seguinte maneira:
FILE *p;
p será então um ponteiro para um arquivo. É usando este tipo de ponteiro que vamos
poder manipular arquivos no C.
13.1.1 A Função fopen()

Esta é a função de abertura de arquivos. Seu protótipo é:
FILE *fopen (char *nome_do_arquivo, char *modo);
O nome_do_arquivo determina qual arquivo deverá ser aberto. Este nome deve ser
válido no sistema operacional que estiver sendo utilizado. O modo de abertura diz à função
fopen() que tipo de uso você vai fazer do arquivo. A Tabela 13.1 mostra os valores de modo
válidos.
#include <stdio.h>
main ( )
{
FILE *fp;
char ch;
int nu, *pn;
pn = ν
fp = fopen("teste.dat", "w");
printf("Entre com os numeros para gravar e 0 para sair: ");
scanf("%d", &nu);
while(nu)
{
fprintf (fp,"%d ", nu);
scanf("%d", &nu);
}
fclose(fp);
fp = fopen("teste.dat", "r");
while(!feof(fp))
{
fscanf( fp,"%d ", &nu);
printf( "%d", nu);
}
}
Figura 13.1: Escrevendo e lendo em arquivo
Poderíamos então, para abrir um arquivo binário, escrever:
FILE *fp;
fp = fopen ("exemplo.bin","wb");
if (!fp)
printf ("Erro na abertura do arquivo.");
A condição !fp testa se o arquivo foi aberto com sucesso porque no caso de um erro
a função fopen() retorna um ponteiro nulo (NULL).
13.1.2 A Função exit()

Aqui abrimos um parêntesis para explicar a função exit() cujo protótipo é:
Noções de Manipulação de Arquivos 99
Tabela 13.1: Modos válidos de abertura de arquivos
Modo Significado
"r" Abre um arquivo para leitura
"w" Cria um arquivo para escrita
"a" Acrescenta dados no fim do arquivo (“append”)
"rb" Abre um arquivo binário para leitura
"wb" Cria um arquivo binário para escrita
"ab" Acrescenta dados binários no fim do arquivo
"r+" Abre um arquivo para leitura e escrita
"w+" Cria um arquivo para leitura e escrita
"a+" Acrescenta dados ou cria uma arquivo para leitura e escrita
"r+b" Abre um arquivo binário para leitura e escrita
"w+b" Cria um arquivo binário para leitura e escrita
"a+b" Acrescenta dados ou cria uma arquivo binário para leitura e es-
crita
"rt" Abre um arquivo texto para leitura
"wt" Cria um arquivo texto para escrita
"at" Acrescenta dados no fim do arquivo texto
"r+t" Abre um arquivo texto para leitura e escrita
"w+t" Cria um arquivo texto para leitura e escrita
"a+t" Acrescenta dados ou cria uma arquivo texto para leitura e escrita
void exit (int codigo_de_retorno);
Esta função aborta a execução do programa. Pode ser chamada de qualquer ponto
no programa e faz com que o programa termine e retorne, para o sistema operacional, o
código_de_retorno. A convenção mais usada é que um programa retorne zero no caso de
um término normal e retorne um número não nulo no caso de ter ocorrido um problema. A
função exit() se torna importante em casos como alocação dinâmica e abertura de arquivos
pois pode ser essencial que uma determinada memória seja alocada ou que um arquivo
seja aberto. Poderíamos reescrever o exemplo da seção anterior usando agora o exit() para
garantir que o programa não deixará de abrir o arquivo, como é mostrado na Figura 13.2.
13.1.3 A Função fclose()
Quando abrimos um arquivo devemos fechá-lo. Para tanto devemos usar a função
fclose():
#include <stdio.h>
main (void)
{
FILE *fp;
/* Comandos... */
fp = fopen ("exemplo.bin", "wb");

if (!fp)
{
printf ("Erro na abertura do arquivo. Fim de programa.");
exit (1);
}
/* Comandos ... */
return 0;
}
Figura 13.2: Uso da função exit na abertura de arquivos
int fclose (FILE *fp);
É importante que se perceba que se deve tomar o maior cuidado para não se “perder”
o ponteiro do arquivo. “Perder” neste caso seria se atribuir um valor de um outro ponteiro
qualquer ao ponteiro de arquivo (perdendo assim o valor original). É utilizando este ponteiro
que vamos poder trabalhar com o arquivo. Se perdermos o ponteiro de um determinado
arquivo não poderemos nem fechá-lo. O ponteiro fp passado à função fclose() determina
o arquivo a ser fechado. A função retorna zero no caso de sucesso.
13.2 LENDO E ESCREVENDO CARACTERES EM ARQUIVOS
Além das funções fprintf e fscanf vista no exemplo inicial, outras funções existem
no padrão ANSI para se escrever e se ler em arquivos. Aqui serão citadas brevemente as
funções putc, getc, e a função feof que verifica o se o arquivo chegou ao final.
13.2.1 putc()
Toda vez que estamos trabalhando com arquivos, há uma espécie de posição atual no
arquivo. Esta posição, gerenciada pelo compilador, é a posição de onde será lido ou escrito
Noções de Manipulação de Arquivos 101
o próximo caracter. Normalmente, num acesso seqüencial a um arquivo, não temos que
mexer nesta posição pois quando lemos um caractere a posição no arquivo é automatica-
mente atualizada. Num acesso randômico teremos que mexer nesta posição (ver fseek()).
Protótipo:
int putc (int ch,FILE *fp);
Escreve um caracter no arquivo.
13.2.2 getc()
Retorna um caracter lido do arquivo. Protótipo:
int getc (FILE *fp);
13.2.3 feof()
EOF (“End of file”) indica o fim de um arquivo. Às vezes, é necessário verificar se um
arquivo chegou ao fim. Para isto podemos usar a função feof(). Ela retorna não-zero se o
arquivo chegou ao EOF, caso contrário retorna zero. Seu protótipo é:
int feof (FILE *fp);

14
NOÇÕES DE ALOCAÇÃO DINÂMICA
Há duas maneiras de armazenar variáveis na memória do computador. Primeiro por

variáveis globais e static locais, segundo através de alocação dinâmica, quando o C
armazena a informação em uma área de memória livre, de acordo com a necessidade.
No caso do C standard, a alocação dinâmica fica disponível com a inclusão de stdio.h.
A alocação dinâmica de memória é muito útil quando se tem que trabalhar com várias
matrizes de grandes dimensões. Para cada matriz a ser utilizada pelo programa destina-se
uma área de memória suficiente, e após o seu uso, esta área é liberada para que possa
ser utilizada por outras matrizes. As Figuras 14.1 e 14.2 mostram exemplos de alocação
dinâmica de memória.
#include <stdio.h>
main( )
{
int *p, t;
p=(int *) malloc(40*sizeof(int));
if (!p) printf("memoria insuficiente\n");
else
{
for(t=0; t<40; ++t) *(p+t) = t;
for(t=0; t<40; ++t) printf("%d ", *(p+t));
free(p);
}
}
Figura 14.1: Primeiro exemplo de alocação dinâmica de memória

#include <stdio.h>
main( )
{
int i,quant;
float max,min,*p;
printf ("quantidade de numeros:\n");
scanf("%d", &quant);
if ( !( p = (float*) malloc((quant+1)*sizeof(float))) )
{
printf ("sem memoria\n");
exit(1);
}
printf ("digite %d numeros:\n", quant);
for ( i = 1; i <= quant; i++) scanf ("%f", (p+i));
max = *(p+1);
for ( i = 2; i <= quant; i++)
{
if (*(p+i) >= max) max = *(p+i);
}
printf("O maior e :%f \n", max);
free(p);
}
Figura 14.2: Segundo exemplo de alocação dinâmica de memória

15
EXERCÍCIOS
15.1 CAPÍTULO 1
1. Procurar em livros e/ou guias de referência da Linguagem C quais são as funções das
seguintes bibliotecas: string.h e math.h. Anotar o nome de todas as funções com seus
respectivos tipos de retorno e seus argumentos.
2. Dizer o que fazem as seguintes funções da biblioteca stdio.h: getchar, putc, puts.
15.2 CAPÍTULO 2
1. Editar o programa da Figura 15.1 e fazer sua compilação. Executar o programa e dizer
o que ele faz.
/* programa do Exercicio_1 capitulo_2 */

# include <stdio.h>
int main ( )
{
int x, y;
float X, Y;
printf (" \n\t Envie dois numeros inteiros \n\t ");
scanf (" %d %d ", &x, &y );
X = x;
Y = y;
printf ( "\n\t Divisão X/Y \n");
printf ( "\n\t %f \n\t %d \n\t %d \n", X/Y, x/y, x%y);
}
Figura 15.1: Capítulo 2: Programa para o exercício 1

Para escrever os dois números pedidos pelo programa, pode-se digitar o primeiro, um
espaço, digitar o segundo, e pressionar <ENTER>. Pode-se também digitar <ENTER>
após cada número.
15.3 CAPÍTULO 3
1. Editar, compilar e executar o programa da Figura 15.2.

# include <stdio.h>
int main ( )
{
int Dias;
float Anos;
printf ("\n\t Entre com o número de dias: ");
scanf ("%d", &Dias);
Anos = Dias/365.25;
printf ("\n\n\t %d dias equivalem a %f anos.\n",Dias,Anos);
}
Figura 15.2: Capítulo 3: programa para o exercício 1
Dizer o que o programa faz. Explicar (comentar) o que faz cada linha. Explique porque
a variável Dias é inteira e Anos é float.
2. Modifique o programa anterior para que sejam requisitados o dia, o mês e o ano atuais,
o dia, o mês e o ano de nascimento do usuário, e então seja calculado e anunciado o
número de dias vivido pelo usuário.
15.4 CAPÍTULO 4
1. Editar, compilar e executar o programa da Figura 15.2.
2. Modifique o programa para que todos os números sejam impressos com quatro alga-
rismos antes do ponto decimal e três algarismos após.
15.5 CAPÍTULO 5
1. Dizer o que faz o programa da Figura 15.4.

Exercícios 107

# include <stdio.h>
int main ( )
{
char Ch;
float x, y;
printf ("\n Envie dois números : ");
scanf ("%f %f ", &x, &y );
printf ( "\n O produto de %f e %f eh %f ", x, y, x*y );
Ch = getchar( );
printf ( "\n O quociente de %f e %f eh %f ", x, y, x/y );
printf ( "\n A tecla pressionada foi %c \n\n", Ch );
printf ( "Fim de Programa\n" );
}
2. Reescrever o programa do item anterior utilizando o comando switch. Editar, compilar

e executar o programa.
3. Fazer um programa em C que identifique triângulos, conforme o algoritmo da Fi-

gura 15.5
4. Modificar o programa de cálculo de PI (Figura 5.8), do Capítulo 5, de forma que ele

calcule a série até que encontre um termo cujo valor absoluto seja menor que 0,00001.
Para isto, deverá ser usado um Loop while ou do-while.
5. O seno de um ângulo qualquer (dado em radianos) pode ser calculado pela série
abaixo.

Os números que aparecem no denominador são os fatoriais dos expoentes de cada
termo.
Fazer um programa em linguagem C que calcule o seno de um ângulo dado utilizando

os N primeiros termos da série. O ângulo A(radianos) e o valor de N deverão ser
requisitados ao usuário do programa.
6. Reescrever o programa anterior para que o seno do ângulo seja calculado até que o
módulo do último termo da série seja menor que 0,00001.
#include<stdio.h>
main( )
{
int opcao;
int valor;
printf("Converter:\n");
printf(" 1: decimal para hexadecimal\n");
printf(" 2: hexadecimal para decimal\n");
printf(" 3: decimal para octal\n");
printf(" 4: octal para decimal\n");
printf("informe a sua opção:");
scanf("%d", &opcao);
if(opcao==1) {
printf("informe um valor em decimal:");
scanf("%d", &valor);
printf("%d em hexadecimal é : %x", valor, valor);
}
if(opcao==2) {
printf("informe um valor em hexadecimal:");
scanf("%x", &valor);
printf("%x em decimal é: %d", valor, valor);
}
if(opcao==3){
printf("informe um valor em decimal:");
scanf("%d", &valor);
printf("%d em octal é: %o", valor, valor);
}
if(opcao==4){
printf("informe um valor em octal:");
scanf("%o", &valor);
printf("%o em decimal é: %d", valor, valor);
}
}

Exercícios 109
/* Identificação de triângulos */
Início
Ler A, B, C (reais, lados do triângulos)
Se A < (B+C) e B < (A+C) e C < (A+B)
/* verifica se é triângulo */
Então
Se A = B e B = C
Então Imprima (Triângulo Equilátero)
Senão
Se A = B ou A = C ou B = C
Então Imprima (Triângulo Isóceles)
Senão Imprima (Triângulo Escaleno)
FimSe
FimSe
FimSe
Fim
Figura 15.5: Capítulo 5: Algoritmo para o exercício 3
15.6 CAPÍTULO 6
1. Fazer um programa em Linguagem C que leia uma matriz de dimensões NxM, e cal-
cule a sua transposta. Ao final o programa apresentará a matriz e sua transposta na
tela do computador.
2. Fazer um programa em Linguagem C que leia os nomes de 10 alunos de uma turma,

e para cada aluno, 4 notas de 0 a 100%. Os nomes dos alunos serão armazenados
em um vetor de strings, as notas serão armazenadas em uma matriz bidimensional.
Serão calculadas as médias dos alunos, (Nota1+Nota2+Nota3+Nota4)/4, e estas se-
rão armazenadas em um vetor. Ao final, será apresentado um relatório contendo 3
colunas: Nome do aluno, Média, Aprovação. Na coluna aprovação será colocada a
letra A (aprovado) para alunos com média igual ou superior a 60, e R (reprovado) para
alunos com média inferior a 60.
15.7 CAPÍTULO 7
1. Editar, compilar, executar e dizer o que faz o programa da Figura 15.6.

#include <stdio.h>
#include <string.h>
main( )
{
char st1[11], st2[11], st3[21], ch ;
int i, j;
printf ("\n Envie uma string de ate 10 caracteres ");
gets(st1);
printf ("\n Envie outra string de ate 10 caracteres ");
gets(st2);
for ( i = 0; st1[i]; i++) st3[i] = st1[i];
for ( j = 0; st2[j]; j++) st3[i+j] = st2[j];
j = j+i;
puts (st3);
for ( i = j; i ; i-- )
{
ch = st3[i-1];
putchar (ch);
putchar (’\n’);
}
puts ("\n");
}
Figura 15.6: Capítulo 7: programa para o exercício 1
Explique porque as strings st1 e st2 devem ter no máximo 10 caracteres se os respec-
tivos vetores foram declarados com 11 posições.
15.8 CAPÍTULOS 8 E 9
1. Fazer um programa em C que leia uma string de até 30 caracteres e armazene-a

em uma variável Stfonte. Utilizando ponteiros, copie o conteúdo de Stfonte para uma
variável Stdestino, de forma que a string fique escrita de forma inversa. Utilizando
ponteiros, apresentar as strings Stfonte e Stdestino em forma de duas colunas.
2. Refazer o programa do cálculo das médias dos alunos, Capítulo 6 (Figura 6.3, utili-
zando ponteiros para o cálculo das médias e para a apresentação dos resultados.
Exercícios 111
15.9 CAPÍTULO 10
1. Fazer uma função em C que concatena duas strings. Utilize o nome StrCat para esta
função, para não confundir com como strcat() da biblioteca string.h.
2. Editar, compilar e executar o programa da Figura 15.7
/* cálculo da área de um círculo */
#include <stdio.h>
#include <math.h>
float area(float raio); /* protótipo*/
main( )
{
float r,res;
printf("Informe o raio: ");
scanf("%f", &r);
res=area(r);
printf("A área é: %f\n", res);
}
float area(float raio)

{
return 3.1415926 * pow(raio,2);
}
3. Modificar o programa anterior para calcular a área e o perímetro do círculo, e calcular

o volume e a área de uma esfera de mesmo raio. Deverão ser feitas 4 funções.
4. Modifique o programa anterior para que ele repita os cálculo para diferentes raios
enviados pelo usuário. Deverá ser utilizado um loop do-while onde, ao final será per-
guntado ao usuário se deseja novo cálculo. O loop será repetido até que o usuário
responda N (não).
5. Fazer uma função em C que calcule o fatorial de um número passado como parâmetro.
6. Fazer uma função em C que calcule o produto de duas matrizes A e B e retorne o

resultado em outra matriz P.
15.10 CAPÍTULO 11
1. Fazer um programa em C que receba em sua linha de comando o nome do usuário

e escreva a mensagem: “Bom dia <usuário>”. Onde se lê <usuário> deverá estar
escrito o nome completo do usuário. O programa deverá identificar quantos nomes
foram escritos.
2. Fazer um programa em C que calcule as raízes de uma equação de segundo grau. Os

valores A, B, C da equação serão passados na linha de comando.

.
15.11 CAPÍTULO 12
1. Fazer um programa em C para ler e armazenar em uma estrutura, os dados de uma

pessoa. Os campos da estrutura DADOS serão: nome, idade, telefone, sexo (M/F).
15.12 CAPÍTULO 13
1. Usar a estrutura do exercício 1 do Capítulo 12 para armazenar em um vetor os dados

de um conjunto de 20 pessoas, que poderiam ser por exemplo os candidatos a vagas
em uma empresa.
15.13 CAPÍTULO 14
1. Modificar o programa do exercício 1 do Capítulo 13 para armazenar os dados em

arquivo. O programa deverá ter um menu de opções para trabalhar com os dados
(usar o comando switch). No menu será previsto inclusão de dados, exclusão de
dados, e consulta. Para cada opção deverá ser feita uma função específica. Na opção
consulta, deverá ter um menu de opções: por nome, idade, sexo. Quando for pedida
uma consulta por nome, por exemplo, deverão ser apresentados todos os dados das
pessoas que possuem aquele nome.
REFERÊNCIAS BIBLIOGRÁFICAS
[1] GACLI-UNICAMP, Introdução à Linguagem C, UNICAMP, Campinas, 2001.
[2] CPDEE-UFMG, Curso de C, UFMG, Belo Horizonte, 2000.
[3] KERNIGHAN, Brian W. e RITCHIE, Dennis M., C: A Linguagem de Programação,

Rio de Janeiro, Campus, 1986.
[4] PLAUGER, P.J. e BRODIE J. Standart C: guia de referência básica, São Paulo,
Mcgraw-Hill, 1991. 306p.
[5] HANCOCK, Les e KRIEGER, Morris. Manual de Linguagem C, Rio de Janeiro, Cam-
pus,1985. 182p.
[6] MIZRAHI, Viviane V. Treinamento em Linguagem C — módulo 1 e 2, São Paulo,

McGraw-Hill, 1990, 241p.
[7] CHILDT, Herbert. C Completo e Total, São Paulo, Makron Books, 1996, 830p.
A
BIBLIOTECAS DO C
Será apresentada aqui uma lista de todas as funções do padrão ANSI-C, e algumas
que não pertencem ao grupo ANSI-C, mas que são implementadas em vários compiladores.
As funções que não pertencem ao padrão serão indicadas como tal. A lista seguirá a ordem
alfabética dos nomes das bibliotecas.
A.1 ASSERT.H
Funções
void assert(int test);
A.2 CONIO.H
Embora não seja uma biblioteca do padrão ANSI-C, conio.h é citada aqui por ser
implementada em vários compiladores e ser utilizada por muitos programadores.
Funções
cgets ( ); char *cgets(char *str);

clreol ( ); void clreol(void);
clrscr ( ); void clrscr(void);
cprintf ( ); int cprintf (const char *format [, argument, ...]);
cputs ( ); int cputs(const char *str);
cscanf ( ); int cscanf (char *format [, address, ...]);
delline ( ); void delline(void);
getch ( ); int getch(void);
getche ( ); int getche(void);
getpass ( ); char *getpass(const char *prompt);
gettext ( ); int gettext(int left, int top, int right, int bottom, void*
destin);
gettextinfo ( ); void gettextinfo(struct text_info *r);
gotoxy ( ); void gotoxy(int x, int y);
highvideo ( ); void highvideo(void);
insline ( ); void insline(void);
inp ( ); int inp(unsigned portid);
inpw ( ); unsigned inpw(unsigned portid);
kbhit ( ); int kbhit(void);
lowvideo ( ); void lowvideo(void);
movetext ( ); int movetext(int left, int top, int right, int bottom, int
destleft, int desttop);
normvideo ( ); void normvideo(void);
outp ( ); int outp(unsigned portid, int value);
outpw ( ); unsigned outpw(unsigned portid, unsigned value);
putch ( ); int putch(int ch);
puttext ( ); int puttext(int left, int top, int right, int bottom, void*
source);
_setcursortype ( ); void _setcursortype(int cur_t);
textattr ( ); void textattr(int newattr);
textbackground ( ); void textbackground(int newcolor);
textcolor ( ); void textcolor(int newcolor);
textmode ( ); void textmode(int newmode);
ungetch ( ); int ungetch(int ch);
wherex ( ); int wherex(void);
wherey ( ); int wherey(void);
window ( ); void window(int left, int top, int right, int bottom);
A.3 CTYPE.H
As funções da biblioteca ctype.h são usadas para testar e converter caracteres.

Um caractere de controle refere-se ao caractere que não é parte do conjunto normal de
impressão. No conjunto de caracteres ASCII, os caracteres de controle são os caracteres
de 0 (NUL) até 0x1F (US), e o caractere 0x7F (DEL). Os caracteres imprimíveis são aqueles
que vão de 0x20 (space) até 0x7E (tilde).
Bibliotecas do C 117
Funções
isalnum; int isalnum(int character);

isalpha; int isalpha(int character);
iscntrl; int iscntrl(int character);
isdigit; int isdigit(int character);
isgraph; int isgraph(int character);
islower; int islower(int character);
isprint; int isprint(int character);
ispunct; int ispunct(int character);
isspace; int isspace(int character);
isupper; int isupper(int character);
isxdigit; int isxdigit(int character);
tolower; int tolower(int character);
toupper; int toupper(int character);
A.4 ERRNO.H
Variável
errno int errno;
Macros
EDOM #define EDOM <valor>

ERANGE #define ERANGE <valor>
A.5 LIMITS.H
CHAR_BIT
CHAR_MAX
CHAR_MIN
INT_MAX
INT_MIN
LONG_MAX
LONG_MIN
SCHAR_MAX
SCHAR_MIN
SHRT_MAX
SHRT_MIN
UCHAR_MAX
UINT_MAX
ULONG_MAX
USHRT_MAX
Os valores a seguir são definidos por diretivas #define . Estes valores são depen-
dentes de implementação, mas não podem ser menores do que estas especificações.
CHAR_BIT 8 Número de bits em um byte.

SCHAR_MIN -127 Mínimo valor para um signed char.
SCHAR_MAX +127 Máximo valor para um signed char.
UCHAR_MAX 255 Máximo valor para um unsigned char.
CHAR_MIN Estes definem os valores mínimo e
CHAR_MAX máximo para um char. Se um char estiver sendo representado como um sig-
ned integer, então, seus valores serão os mesmos que do signed char (SCHAR).
Caso contrário, CHAR_MIN é 0 e CHAR_MAX é o mesmo que UCHAR_MAX.
MB_LEN_MAX 1 Máximo número de bytes em um multibyte character.
SHRT_MIN -32767 Mínimo valor para um short int.
SHRT_MAX +32767 Máximo valor para um short int.
USHRT_MAX 65535 Máximo valor para um unsigned short int.
INT_MIN -32767 Mínimo valor para um int.
INT_MAX +32767 Máximo valor para um int.
UINT_MAX 65535 Máximo valor para um unsigned int.
LONG_MIN -2147483647 Mínimo valor para um long int.
LONG_MAX +2147483647 Máximo valor para um long int.
ULONG_MAX 4294967295 Máximo valor para um unsigned long int.
A.6 LOCALE.H
Variáveis
struct lconv
Macros
NULL
LC_ALL
LC_COLLATE
LC_CTYPE
LC_MONETARY
LC_NUMERIC
LC_TIME
Funções
localeconv( );
setlocale( ); char *setlocale(int category, const char *locale);
Variáveis e Definições
A estrutura lconv contém as seguintes variáveis em qualquer ordem:

char *decimal_point;
char *thousands_sep;
char *grouping;
char *int_curr_symbol;
char *currency_symbol;
char *mon_decimal_point;
char *mon_thousands_sep;
char *mon_grouping;
char *positive_sign;
char *negative_sign;
char int_frac_digits;
char frac_digits;
char p_cs_precedes;
char p_sep_by_space;
char n_cs_precedes;
char n_sep_by_space;
char p_sign_posn;
char n_sign_posn;
A.7 MATH.H
Macros
HUGE_VAL
Funções
acos( ); double acos(double x);
asin( ); double asin(double x);
atan( ); double atan(double x);
atan2( ); double atan2(double y ,double x);
ceil( ); double ceil(double x);
cos( ); double cos(double x);
cosh( ); double cosh(double x);
exp( ); double exp(double x);
fabs( ); double fabs(double x);
floor( ); double floor(double x);
fmod( ); double fmod(double x, double y);
frexp( ); double frexp(double value, int *exp);
ldexp( ); double ldexp(double x, int exp);
log( ); double log(double x);
log10( ); double log10(double x);
modf( ); double modf(double value, double *iptr);
pow( ); double pow(double x, double y);
sin( ); double sin(double x);
sinh( ); double sinh(double x);
[sqrt( );] double sqrt(double x);
tan( ); double tan(double x);
tanh( ); double tanh(double x);
A.8 SIGNAL.H
Macros
SIG_DFL
SIG_ERR
SIG_IGN
SIGABRT
SIGFPE
SIGILL
SIGINT
SIGSEGV
SIGTERM
Funções
signal( ) void (*signal(int sig, void (*func)(int)))(int);

raise( ) int raise(int sig);
Variáveis e definições
typedef sig_atomic_t
SIG_ERR Represents a signal error.
SIG_IGN Signal ignore
A.9 STDARG.H
A biblioteca stdarg define algumas macros usadas para obter argumentos em uma
função quando o número de argumentos não é conhecido.
Macros
va_start( ) void va_start(va_list ap, last_arg);

va_arg( ) type va_arg(va_list ap, type);
va_end( ) void va_end(va_list ap);
A.10 STDIO.H
A biblioteca stdio fornece funções para implementar entrada e saída.
Macros
NULL
_IOFBF
_IOLBF
_IONBF
BUFSIZ
EOF
FOPEN_MAX
FILENAME_MAX
L_tmpnam
SEEK_CUR
SEEK_END
SEEK_SET
TMP_MAX
stderr
stdin
stdout
Funções
clearerr( ); void clearerr(FILE *stream);
fclose( ); int fclose(FILE *stream);
feof( ); int feof(FILE *stream);
ferror( ); int ferror(FILE *stream);
fflush( ); int fflush(FILE *stream);
fgetpos( ); int fgetpos(FILE *stream, fpos_t *pos);
fopen( ); FILE *fopen(const char *filename, const char *mode);
fread( ); size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);
freopen( ); FILE *freopen(const char *filename, const char *mode,FILE
*stream);
fseek( ); int fseek(FILE *stream, long int offset, int whence);
fsetpos( ); int fsetpos(FILE *stream, const fpos_t *pos);
ftell( ); long int ftell(FILE *stream);
fwrite( ); size_t fwrite(const void *ptr, size_t size, size_t nmemb,
FILE *stream);
remove( ); int remove(const char *filename);
rename( ); int rename(const char *old_filename, const char *new_filename);
rewind( ); void rewind(FILE *stream);
setbuf( ); void setbuf(FILE *stream, char *buffer);
setvbuf( ); int setvbuf(FILE *stream, char *buffer, int mode, size_t
size);
tmpfile( ); FILE *tmpfile(void);

tmpnam( ); char *tmpnam(char *str);
fprintf( ); int fprintf(FILE *stream, const char *format, ...);
fscanf( ); int fscanf(FILE *stream, const char *format, ...);
printf( ); int printf(const char *format, ...);
scanf( ); int scanf(const char *format, ...);
sprintf( ); int sprintf(char *str, const char *format, ...);
sscanf( ); int sscanf(const char *str, const char *format, ...);
vfprintf( ); int vfprintf(FILE *stream, const char *format, va_list arg);
vprintf( ); int vprintf(const char *format, va_list arg);
vsprintf( ); int vsprintf(char *str, const char *format, va_list arg);
fgetc( ); int fgetc(FILE *stream);
fgets( ); char *fgets(char *str, int N, FILE *stream);
fputc( ); int fputc(int char, FILE *stream);
fputs( ); int fputs(const char *str, FILE *stream);
getc( ); int getc(FILE *stream);
getchar( ); int getchar(void);
gets( ); char *gets(char *str);
putc( ); int putc(int char, FILE *stream);
putchar( ); int putchar(int char);
puts( ); int puts(const char *str);
ungetc( ); int ungetc(int char, FILE *stream);
perror( ); void perror(const char *str);
Variáveis
typedef size_t
typedef FILE
typedef fpos_t
size_t é o resultado inteiro sem sinal do tamanho da palavra-chave (sizeof keyword ).
FILE é um tipo útil para armzenar informações de um arquivo (file stream).
fpos_t é um tipo útil para armazenar qualquer posição em um arquivo.
NULL é o valor ce uma constante ponteiro nulo (null pointer constant).
_IOFBF, _IOLBF, e _IONBF são usadas na função setvbuf.

BUFSIZ é um inteiro que representa o tamanho do buffer usado pela função setbuf.
EOF é um inteiro negativo que indica que o final do arquivo (end-of-file) foi alcançado.
FOPEN_MAX é um inteiro que representa o máximo número de arquivos que o sistema pode
garantir que podem ficar abertos ao mesmo tempo.
FILENAME_MAX é um inteiro que representa o comprimento máximo de um vetor de char
disponível para manter o maior nome de arquivo possível.
L_tmpnam é um inteiro que representa o maior comprimento de um vetor de char dispo-
nível para manter o maior nome de arquivo temporário possível criado pela função
tmpnam.
SEEK_CUR, SEEK_END, e SEEK_SET são usados na função fseek.
TMP_MAX é o máximo número de nomes de arquivos únicos (unique filenames) que a fun-
ção tmpnam pode gerar.
stderr, stdin, e stdout são ponteiros para tipos arquivos (FILE types) os quais cor-
respondem aos standard error, standard input, e standard output streams.
A.10.1 Algumas funções em detalhe

fopen
Declaração: FILE *fopen(const char *filename, const char *mode);

Abre um arquivo apontado por filename. O argumento mode pode ser uma das
seguintes constantes strings:
r modo texto para leitura

w modo texto para escrita (trunca o arquivo para comprimento zero ou cria um novo ar-
quivo)
a modo texto para adicionar escrita – append text mode (abre ou cria um arquivo e aponta
para o final do arquivo – end-of-file)
rb modo binário de leitura – read binary mode
wb modo binário de escrita – write binary mode
ab modo binário para adicionar escrita (abre ou cria um arquivo e aponta para o final do
arquivo – end-of-file)
r+ modo texto para leitura e escrita.
w+ modo texto para leitura e escrita (trunca o arquivo para comprimento zero ou cria um
novo arquivo)
a+ modo texto para leitura e escrita
r+b ou rb+ modo binário para leitura e escrita.
w+b ou wb+ modo binário para leitura e escrita (trunca o arquivo para comprimento zero ou
cria um novo arquivo)
a+b ou ab+ modo binário para leitura e escrita (abre ou cria um arquivo e ajusta o ponteiro
para o final do arquivo – end-of-file)
Se o arquivo não existir e for feita uma operação de abertura no modo read (r), então
a abertura falhará.
Se o arquivo for aberto no modo append (a), então todas as operações de escrita
ocorrerão ao final do arquivo não importando a posição corrente do arquivo.
Se o arquivo for aberto no modo update (+), então a saída não poderá ser seguida
diretamente por uma entrada e uma entrada não poderá ser seguida diretamente por uma
saída sem a intervenção de fseek, fsetpos, rewind, ou fflush.
Tendo sucesso na abertura do arquivo, será retornado um ponteiro para o arquivo (file
stream). Ocorrendo uma falha na abertura, um ponteiro nulo será retornado.
A.10.2 Entradas e saídas formatadas

Funções (x)printf
As funções (x)printf fornecem meios para saída formatada de informações para

um stream.
fprintf envia saída formatada para um stream

printf envia saída formatada para o dispositvo padrão (stdout)
sprintf envia saída formatada para uma string
vfprintf envia saída formatada para um stream usando uma lista de argumentos
vprintf envia saída formatada para stdout usando uma lista de argumentos
vsprintf envia saída formatada para uma string usando uma lista de argumentos
int fprintf (FILE *stream, const char *format, ...);

int printf (const char *format, ...);
int sprintf (char *str, const char *format, ...);
int vfprintf (FILE *stream, const char *format, va_list arg);
int vprintf (const char *format, va_list arg);
int vsprintf (char *str, const char *format, va_list arg);
Tipos de argumentos
%d, %i Inteiros decimais com sinal – signed int.
%u Inteiro decimal sem sinal – unsigned int.
%o unsigned int na base octal.

%x unsigned int em hexadecimal usando minúsculas: a, b, c, d, e, f.
%X unsigned int em hexadecimal usando maiúsculas: A, B, C, D, E, F.
%f Ponto flutuante em decimal – double.
%e, %E double impresso em notação científica, com e (minúsculo) ou E (maiúsculo).
%g , %G] double impresso como %e ou %f, o que tiver menor comprimento. O %G utiliza %E
ou %F.
%c char: será impresso um único caractere.
%s Imprime uma string.
%p Imprime o valor de um ponteiro.
%n o argumento associado é um ponteiro para inteiro no qual o número de caracteres
impressos até este ponto é colocado. Nenhum caractere é impresso.
%% Imprime o sinal %.
Há dois especificadores de formato que permitem que printf( ) mostre inteiros

short e long. Esses especificadores podem ser aplicados aos tipos d, i, o, u, x e X.
O especificador l diz a printf( ) que segue um tipo de dado long. Por exemplo, %ld
significa que um long int será mostrado. O especificador h instrui printf( ) a mostrar
um short int. Portanto, %hu indica que o dado é do tipo short unsigned int.
A.10.3 Funções (x)scanf

As funções (x)scanf são utilizadas para leitura formatada de informações de um
stream.
fscanf lê entrada formatada de um stream

scanf lê entrada formatada do dispositivo padrão (stdin)
sscanf lê entrada formatada de uma string
int fscanf (FILE *stream, const char *format, ...);

int scanf (const char *format, ...);
int sscanf (const char *str, const char *format, ...);
Tipos de argumentos
%c char: lê um único caractere.
%d, %i Inteiros decimais com sinal – signed int.
%u Inteiro decimal sem sinal – unsigned int.
%o unsigned int na base octal.
%x unsigned int em hexadecimal usando minúsculas: a, b, c, d, e, f.

%f Ponto flutuante em decimal - double.
%e Ponto flutuante em notação científica.
%g Ponto flutuante
%s Lê uma String.
%p Lê um ponteiro.
%n Retorna um inteiro igual ao número de caracteres lidos.
%[ ] Procura um conjunto de caracteres.
%% Lê o sinal %.
A.10.4 Funções de entrada e saída de caracteres

fgetc Retorna o próximo caractere da stream de entrada na posição atual e incrementa o
indicador de posição de arquivo. O caractere é lido como um unsigned char, que
é convertido para um inteiro.
fgets Lê N-1 caracteres de stream e coloca-os na matriz de caracteres apontada por str.
fputc Escreve o caractere ch na stream especificada na posição atual do arquivo e avança
o indicador de posição de arquivo.
fputs Escreve na stream especificada o conteúdo da string apontada por str. O terminador
nulo não é escrito.
getc Retorna o próximo caractere (um unsigned char) da stream especificada e avança
o indicador de posição da stream.
getchar Retorna um caractere (um unsigned char) da entrada padrão (stdin).
gets Lê uma linha da entrada padrão e aramazena em uma string apontada por str.
putc Escreve o caractere contido no byte menos significativo de ch na stream de saída
apontada por stream e avança a posição do indicador da stream.
putchar Escreve no dispositivo padrão de saída (stdout) um caractere (um unsigned
char) especificado pelo argumento char.
puts Escreve a string apontada por str no dispositivo padrão de saída, mas não escreve
o terminador nulo. Um caractere de mudança de linha (newline) é adicionado à saída.
A.11 STDLIB.H
A biblioteca stdlib define algumas funções em macros de propósito geral.

Macros
NULL
EXIT_FAILURE
EXIT_SUCCESS
RAND_MAX
MB_CUR_MAX
Variáveis
typedef size_t
typedef wchar_t
struct div_t
struct ldiv_t
size_t é o tamanho em forma unsigned integer resultante da operação sizeof so-

bre uma variável de qualquer tipo.
wchar_t é um tipo inteiro do tamanho de uma constante wide character.
div_t é a estrutura retornada pela função div.
ldiv_t é a estrutura retornada pela função ldiv.
NULL é o valor de uma constante ponteiro nulo.
EXIT_FAILURE e EXIT_SUCCESS são valores retornados pela função exit.
RAND_MAX é o máximo valor retornado pela função rand.
MB_CUR_MAX é o máximo número de bytes em um conjunto de caracteres multibyte o
qual não pode ser maior que MB_LEN_MAX.
Funções
abort( ); void abort(void);
abs( ); int abs(int x);
atexit( ); int atexit(void (*func)(void));
atof( ); double atof(const char *str);
atoi( ); int atoi(const char *str);
atol( ); long int atol(const char *str);
bsearch( ) ; void *bsearch(const void *key, const void *base, size_t
nitems, size_t size, int (*compar)(const void *, const void *));
calloc( ); void *calloc(size_t nitems, size_t size);
div( ); div_t div(int numer, int denom);
exit( ); void exit(int status);

free( ); void free(void *ptr);
getenv( ); char *getenv(const char *name);
labs( ); long int labs(long int x);
ldiv( ); ldiv_t ldiv(long int numer, long int denom);
malloc( ); void *malloc(size_t size);
mblen( ); int mblen(const char *str, size_t n);
mbstowcs( ); size_t mbstowcs(schar_t *pwcs, const char *str, size_t n);
mbtowc( ); int mbtowc(whcar_t *pwc, const char *str, size_t n);
qsort( ); void qsort(void *base, size_t nitems, size_t size, int (*com-
par)(const void *, const void*));
rand( ); int rand(void);
realloc( ); void *realloc(void *ptr, size_t size);
srand( ); void srand(unsigned int seed);
strtod( ); double strtod(const char *str, char **endptr);
strtol( ); long int strtol(const char *str, char **endptr, int base);
strtoul( ); unsigned long int strtoul(const char *str, char **endptr,
int base);
system( ); int system(const char *string);
wcstombs( ); size_t wcstombs(char *str, const wchar_t *pwcs, size_t n);
wctomb( ); int wctomb(char *str, wchar_t wchar);
A.11.1 Funções de manipução de Strings

atoi
atol
strtod
strtol
strtoul
A.11.2 Funções de manipulação de Memória

calloc
free
malloc
realloc
A.11.3 Funções de Ambiente (Environment)

abort
atexit
exit
getenv
system
A.11.4 Funções de busca e ordenação (Searching and Sorting)

bsearch
qsort
A.11.5 Funções matemáticas

abs int abs(int x);
div div_t div(int numer, int denom);
labs long int labs(long int x);
ldiv ldiv_t ldiv(long int numer, long int denom);
rand int rand(void);
srand void srand(unsigned int seed);
Descrição
abs, labs; Retorna o valor absoluto de x.

div; Divide o numer (numerador) por denom (denominador). O resultado é armazenado
em uma estrutura div_t que possue dois membros:
int quot; quociente.
int rem; resto.
ldiv; o mesmo que div, para argumentos do tipo long int. O resultado é armazenado
em uma estrutura ldiv_t.
rand Retorna um número pseudo-randômico entre 0 e RAND_MAX.
srand Inicializador da seqüência de rand. Se não for chamado o srand, rand atuará
como se srand(1) tivesse sido chamado.
A.11.6 Funções Multibyte

O comportamento das funções multibyte é afetado pelos ajustes de LC_CTYPE feitos
localmente.
mblen int mblen(const char *str, size_t n);

mbstowcs size_t mbstowcs(schar_t *pwcs, const char *str, size_t n);

mbtowc int mbtowc(whcar_t *pwc, const char *str, size_t n);
wcstombs size_t wcstombs(char *str, const wchar_t *pwcs, size_t n);
wctomb int wctomb(char *str, wchar_t wchar);
mblen Retorna o comprimento de um character multibyte apontado por um argumento str.
mbstowcs Converte a string de caracteres multibyte apontada pelo argumento str para
um vetor apontado por pwcs
mbtowc Examina um caractere multibyte apontado pelo argumento str.
wcstombs Converte os códigos armazenados na matriz pwcs para caracteres multibyte e
os armazena na string str.
wctomb Examina o código que corresponde ao caractere multibyte dado pelo argumento
wchar.
A.12 STRING.H
A biblioteca string fornece muitas funções úteis para manipulação de strings (vetor
de caracteres).
size_t é o inteiro sem sinal resultante de sizeof keyword.

NULL é o valor da constante ponteiro nulo.
Funções
memchr( ); void *memchr(const void *str, int c, size_t n);

memcmp( ); int memcmp(const void *str1, const void *str2, size_t n);
memcpy( ); void *memcpy(void *str1, const void *str2, size_t n);
memmove( ); void *memmove(void *str1, const void *str2, size_t n);
memset( ); void *memset(void *str, int c, size_t n);
strcat( ); char *strcat(char *str1, const char *str2);
strncat( ); char *strncat(char *str1, const char *str2, size_t n);
strchr( ); char *strchr(const char *str, int c);
strcmp( ); int strcmp(const char *str1, const char *str2);
strncmp( ); int strncmp(const char *str1, const char *str2, size_t n);
strcoll( ); int strcoll(const char *str1, const char *str2);
strcpy( ); char *strcpy(char *str1, const char *str2);

strncpy( ); char *strncpy(char *str1, const char *str2, size_t n);
strcspn( ); size_t strcspn(const char *str1, const char *str2);
strerror( ); char *strerror(int errnum);
strlen( ); size_t strlen(const char *str);
strpbrk( ); char *strpbrk(const char *str1, const char *str2);
strrchr( ); char *strrchr(const char *str, int c);
strspn( ); size_t strspn(const char *str1, const char *str2);
strstr( ); char *strstr(const char *str1, const char *str2);
strtok( ); char *strtok(char *str1, const char *str2);
strxfrm( ); size_t strxfrm(char *str1, const char *str2, size_t n);
A.13 TIME.H
A biblioteca time fornece algumas funções úteis para ler e converter a hora e a data
correntes. O comportamento de algumas funções é definido pela categoria LC_TIME das
propriedades locais.
Variáveis e definições
NULL é o valor de um ponteiro nulo.

CLOCKS_PER_SEC é o número de clocks por segundos do processador.
size_t é o unsigned integer resultante de sizeof keyword.
clock_t é um tipo útil para armazenar o tempo do processador.
time_t é um tipo útil para armazenar o tempo de calendário.
struct tm é uma estrutura usada para guardar o tempo e a data. Seus membros sâo:
int tm_sec; seconds after the minute (0 to 61)
int tm_min; minutes after the hour (0 to 59)
int tm_hour; hours since midnight (0 to 23)
int tm_mday; day of the month (1 to 31)
int tm_mon; months since January (0 to 11)
int tm_year; years since 1900
int tm_wday; days since Sunday (0 to 6 Sunday=0)
int tm_yday; days since January 1 (0 to 365)
int tm_isdst; Daylight Savings Time
Funções
asctime( ); char *asctime(const struct tm *timeptr);
clock( ); clock_t clock(void);
ctime( ); char *ctime(const time_t *timer);
É equivalente a asctime(locatime(timer));
difftime( ); double difftime(time_t time1, time_t time2);
gmtime( ); struct tm *gmtime(const time_t *timer);
localtime( ); struct tm *localtime(const time_t *timer);
mktime( ); time_t mktime(struct tm *timeptr);
time( ); time_t time(time_t *timer);
Calcula a data e hora correntes e codifica-os no formato time_t. Retorna o valor
time_t. Se timer não for um ponteiro nulo, então o valor é também armazenado
em um objeto para o qual ele aponta. Se não houver sucesso, retorna -1.
strftime( ); size_t strftime(char *str, size_t maxsize, const char *for-
mat, const struct tm *timeptr);

Introdução C Linguagem Programação

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Introdução C Linguagem Programação

Uploaded by

Copyright:

Available Formats

CURSO DE PÓS-GRADUAÇÃO

“LATO SENSU” (ESPECIALIZAÇÃO) A DISTÂNCIA

João Carlos Giacomin

UFLA - Universidade Federal de Lavras

Ficha Catalográfica preparada pela Divisão de Processos Técnicos

Giacomin, João Carlos

Introdução à Linguagem C / João Carlos Giacomin. – 2. ed. Lavras:

1. Programa de Computador. 2. Linguagem de Programação. 3.

Nenhuma parte desta publicação pode ser reproduzida, por qualquer

4 Funções Básicas da Biblioteca C 33

5 Estruturas de Controle de Fluxo 39

11 Argumentos da Linha de Comando 81

12 Tipos de Dados Definidos Pelo Usuário 83

13 Noções de Manipulação de Arquivos 97

14 Noções de Alocação Dinâmica 103

Referências Bibliográficas 113

1.1 Trecho de programa em linguagem de máquina . . . . . . . . . . . . . . . . 11

2.1 Estrutura de um programa em C . . . . . . . . . . . . . . . . . . . . . . . . 17

3.1 Programa com instruções básicas . . . . . . . . . . . . . . . . . . . . . . . 22

4.1 Exemplo de utilização da função printf . . . . . . . . . . . . . . . . . . . . . 34

5.1 Exemplo de programa que utiliza o comando de decisão if . . . . . . . . . . 39

6.1 Exemplo simples de utilização de matriz . . . . . . . . . . . . . . . . . . . . 54

7.1 Exemplo simples de operação com strings . . . . . . . . . . . . . . . . . . . 57

8.1 Exemplos de declarações de ponteiros . . . . . . . . . . . . . . . . . . . . . 61

9.1 Cópia de uma string (versão matriz) . . . . . . . . . . . . . . . . . . . . . . 68

11.1 Programa que recebe uma string na linha de comando . . . . . . . . . . . . 81

13.1 Escrevendo e lendo em arquivo . . . . . . . . . . . . . . . . . . . . . . . . . 98

14.1 Primeiro exemplo de alocação dinâmica de memória . . . . . . . . . . . . . 103

15.1 Capítulo 2: Programa para o exercício 1 . . . . . . . . . . . . . . . . . . . . 105

3.1 Palavras reservadas do C . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

4.1 Caracteres de controle da função printf . . . . . . . . . . . . . . . . . . . . 33

13.1 Modos válidos de abertura de arquivos . . . . . . . . . . . . . . . . . . . . . 99

1.1 LINGUAGENS DE MÁQUINA, LINGUAGENS DE MONTAGEM, E LINGUAGENS DE

Programadores escrevem instruções em várias linguagens de programação, algumas

Qualquer computador pode entender diretamente apenas sua própria linguagem de

Figura 1.1: Trecho de programa em linguagem de máquina

Quando os computadores se tornaram mais populares, tornou-se claro que a progra-

Figura 1.2: Trecho de programa em linguagem de montagem

A utilização do computador cresceu rapidamente com o advento das linguagens de

grossPay = basePay + overTimePay

Figura 1.3: Trecho de programa em linguagem de alto nível

C evoluiu das linguagens anteriores, BCPL e B. BCPL foi desenvolvida em 1967

1.3 A BIBLIOTECA PADRÃO C

Programas em C consistem de módulos ou pedaços, chamados funções. Você pode

Funções da biblioteca padrão C,

C é uma linguagem altamente portável e bastante eficiente em termos de desem-

1.6 O COMPILADOR GCC

gcc nome.c -o nome.exe

Um programa em C é estruturado sobre funções. O programa possui uma ou várias

Figura 2.1: Estrutura de um programa em C

A primeira linha compreende apenas comentários. Todos os comentários iniciam com

Figura 2.2: Um programa simples em C

Edite este programa com o nome exemp_01.c e compile-o utilizando o compilador

gcc exemp_01.c -o exemp_01

2.1 VISÃO GERAL DE UM PROGRAMA C

A geração do programa executável a partir do programa fonte obedece a uma seqüên-

Figura 2.3: Ambiente de programação do C

2.2 UM PROGRAMA UTILIZANDO UMA FUNÇÃO

Para que fique entendida a estrutura de um programa em C, façamos um segundo

int quadrado (int num)

Figura 2.4: Um programa que utiliza uma função

Figura 3.1: Programa com instruções básicas

Tabela 3.1: Palavras reservadas do C