Apostila Ling C Completa

Prévia do material em texto

UNIVERSIDADE DE CAXIAS DO SUL
CENTRO DE CIÊNCIAS EXATAS E TECNOLÓGICAS
DEPARTAMENTO DE INFORMÁTICA
LINGUAGEM C
Professor Maurício Galimberti
Professor André Gustavo Adami
LINGUAGEM C
2/103
Sumário
1. INTRODUÇÃO .............................................................................................................................. 8
1.1 VISÃO GERAL DE UM PROGRAMA C ........................................................................................... 8
2. ESTRUTURA BÁSICA DE UM PROGRAMA EM C ............................................................... 9
2.1 BIBLIOTECAS ............................................................................................................................. 9
3. TIPOS DE DADOS....................................................................................................................... 10
3.1 ENUMERAÇÃO ......................................................................................................................... 11
3.2 MODIFICADORES DE TIPO DE ACESSO ..................................................................................... 12
3.2.1 Const............................................................................................................................... 12
3.2.2 Volatile ........................................................................................................................... 12
3.3 CONSTANTES ........................................................................................................................... 12
3.4 CONSTANTES PRÉ-DEFINIDAS................................................................................................... 13
3.5 AS BIBLIOTECAS DISPONÍVEIS E ALGUMAS FUNÇÕES INTERESSANTES ...................................... 14
4. COMANDO DE ESCRITA ......................................................................................................... 16
4.1 MODIFICADORES DE SAÍDA...................................................................................................... 17
4.2 EXERCÍCIOS ............................................................................................................................. 18
5. VARIÁVEIS.................................................................................................................................. 19
5.1 NOME DE VARIÁVEIS............................................................................................................... 19
5.2 DECLARAÇÃO DE VARIÁVEIS................................................................................................... 19
5.2.1 Tipos de Declarações de Variáveis ................................................................................ 19
5.2.1.1 Variáveis locais ......................................................................................................................... 20
5.2.1.2 Parâmetros Formais................................................................................................................... 20
5.2.1.3 Variáveis Globais ...................................................................................................................... 20
5.3 PALAVRAS RESERVADAS ......................................................................................................... 21
6. OPERADORES ............................................................................................................................ 22
6.1 ATRIBUIÇÃO ............................................................................................................................ 22
6.1.1 Conversão de Tipos em Atribuições ............................................................................... 22
6.2 OPERADORES ARITMÉTICOS .................................................................................................... 23
6.2.1 Incremento e Decremento............................................................................................... 23
6.2.2 Operadores Aritméticos de Atribuição ........................................................................... 24
6.3 OPERADORES RELACIONAIS E LÓGICOS................................................................................... 24
6.4 OPERADORES BIT A BIT........................................................................................................... 24
6.5 OPERADOR ?............................................................................................................................ 25
6.6 OPERADORES DE PONTEIROS & E * ......................................................................................... 25
6.7 OPERADOR VÍRGULA............................................................................................................... 26
6.8 EXPRESSÕES............................................................................................................................ 26
6.8.1 Conversão de Tipos em Expressões................................................................................ 26
6.8.2 Casts ............................................................................................................................... 27
6.8.3 Espacejamento e Parênteses........................................................................................... 28
7. ALGUMAS FUNÇÕES DE E/S .................................................................................................. 29
7.1 FUNÇÃO SCANF() ..................................................................................................................... 29
7.2 FUNÇÃO GETCHE() E GETCH().................................................................................................. 30
7.3 LENDO E ESCREVENDO CARACTERES....................................................................................... 30
LINGUAGEM C
3/103
7.4 EXERCÍCIOS ............................................................................................................................. 31
8. COMANDOS CONDICIONAIS ................................................................................................. 32
8.1 COMANDO IF............................................................................................................................ 32
8.2 COMANDO SWITCH .................................................................................................................. 32
8.3 EXERCÍCIOS ............................................................................................................................. 33
9. COMANDOS REPITITIVOS OU LAÇOS................................................................................ 35
9.1 LAÇO FOR ................................................................................................................................ 35
9.2 LAÇO WHILE ............................................................................................................................ 35
9.3 LAÇO DO-WHILE ...................................................................................................................... 36
9.4 COMANDOS BREAK, CONTINUE E EXIT() .................................................................................. 36
9.5 EXERCÍCIOS ............................................................................................................................. 37
10. FUNÇÕES..................................................................................................................................... 39
10.1 LOCALIZAÇÃO DAS FUNÇÕES ................................................................................................... 40
10.1.1 Corpo da função antes do programa principal (no mesmo arquivo) ............................. 40
10.1.2 Corpo da função depois do programa principal (no mesmo arquivo) ........................... 40
10.1.3 Corpo da função escrito em arquivo separado ..............................................................41
10.2 ARGUMENTOS PARA FUNÇÃO MAIN()....................................................................................... 42
10.3 PROTÓTIPO DE FUNÇÕES .......................................................................................................... 42
10.4 RETORNO DE PONTEIROS......................................................................................................... 42
10.5 NÚMEROS DE PARÂMETROS VARIÁVEL.................................................................................... 43
10.5.1 Funções para número variável de argumentos .............................................................. 43
10.6 CLASSES DE ARMAZENAMENTO .............................................................................................. 44
10.6.1 Classe de Armazenamento - auto ................................................................................... 44
10.6.2 Classe de Armazenamento - extern................................................................................. 44
10.6.3 Classe de Armazenamento - static .................................................................................. 45
10.6.3.1 Variáveis Locais static ............................................................................................................. 45
10.6.3.2 Variáveis Globais static............................................................................................................ 45
10.6.4 Classe de Armazenamento - register .............................................................................. 45
10.7 DIRETIVA #DEFINE................................................................................................................... 45
10.8 FUNÇÕES RECURSIVAS ............................................................................................................ 46
10.9 EXERCÍCIOS ............................................................................................................................. 46
11. VETORES E MATRIZES ........................................................................................................... 47
11.1 INICIALIZAÇÃO DE VETORES E MATRIZES................................................................................ 47
11.2 MATRIZES E VETORES COMO ARGUMENTO DE FUNÇÕES ......................................................... 48
11.3 LIMITES ................................................................................................................................... 48
11.4 STRINGS .................................................................................................................................. 49
11.4.1 Leitura de Strings ........................................................................................................... 49
11.4.1.1 Função scanf().......................................................................................................................... 49
11.4.1.2 Função gets()............................................................................................................................ 50
11.4.2 Escrita de Strings............................................................................................................ 50
11.4.2.1 Função printf() ......................................................................................................................... 50
11.4.2.2 Função puts() ........................................................................................................................... 50
11.4.3 Funções de Manipulação de Strings .............................................................................. 51
11.4.3.1 Função strlen() ......................................................................................................................... 51
11.4.3.2 Função strcat() ......................................................................................................................... 51
11.4.3.3 Função strcmp() ....................................................................................................................... 52
11.4.3.4 Função strcpy() ........................................................................................................................ 52
11.4.3.5 Função strchr() ......................................................................................................................... 52
11.4.3.6 Função strstr() .......................................................................................................................... 52
11.4.4 Exemplo Geral................................................................................................................ 52
LINGUAGEM C
4/103
11.5 EXERCÍCIOS ............................................................................................................................. 53
12. PONTEIROS................................................................................................................................. 55
12.1 EXPRESSÕES COM PONTEIROS ................................................................................................. 55
12.1.1 Atribuição de Ponteiros.................................................................................................. 55
12.1.2 Aritmética de Ponteiros .................................................................................................. 56
12.2 INICIALIZAÇÃO DE PONTEIROS................................................................................................. 56
12.2.1 Comparação de Ponteiros .............................................................................................. 57
12.3 PONTEIROS E MATRIZES .......................................................................................................... 57
12.3.1 Matrizes de Ponteiros ..................................................................................................... 58
12.3.2 Acessando partes de Matrizes como vetores .................................................................. 59
12.4 INDIREÇÃO MÚLTIPLA ............................................................................................................. 59
12.5 PONTEIROS PARA FUNÇÕES ..................................................................................................... 60
12.6 MAIS SOBRE DECLARAÇÕES DE PONTEIROS ............................................................................ 61
12.7 EXERCÍCIOS ............................................................................................................................. 63
13. ESTRUTURAS E UNIÕES.......................................................................................................... 64
13.1 ESTRUTURAS ........................................................................................................................... 64
13.1.1 Inicializando Estruturas ................................................................................................. 65
13.1.2 Estruturas Aninhadas ..................................................................................................... 65
13.1.3 Estruturas e funções ....................................................................................................... 66
13.1.4 Vetor de Estruturas......................................................................................................... 67
13.1.5 Ponteiros para Estruturas .............................................................................................. 67
13.2 CAMPOS DE BITS ..................................................................................................................... 68
13.3 UNIÕES.................................................................................................................................... 69
13.4 SIZEOF() .................................................................................................................................. 7113.5 TYPEDEF ................................................................................................................................. 71
13.6 EXERCÍCIOS ............................................................................................................................. 72
14. ALOCAÇÃO DINÂMICA........................................................................................................... 73
14.1 FUNÇÕES DE ALOCAÇÃO DINÂMICA EM C ............................................................................... 73
14.1.1 Função malloc() ............................................................................................................. 73
14.1.2 Função calloc() .............................................................................................................. 74
14.1.3 Função free() .................................................................................................................. 75
14.1.4 Função realloc() ............................................................................................................. 76
14.2 MATRIZES DINAMICAMENTE ALOCADAS................................................................................. 76
14.3 LISTAS ENCADEADAS .............................................................................................................. 78
14.3.1 Listas Singularmente Encadeadas.................................................................................. 78
14.3.2 Listas Duplamente Encadeadas...................................................................................... 79
14.4 ÁRVORES BINÁRIAS ................................................................................................................ 81
14.5 EXERCÍCIOS ............................................................................................................................. 83
15. E/S COM ARQUIVO ................................................................................................................... 84
15.1 E/S ANSI X E/S UNIX ........................................................................................................... 84
15.2 STREAMS ................................................................................................................................. 84
15.3 ARQUIVOS ............................................................................................................................... 84
15.4 SISTEMA DE ARQUIVOS ........................................................................................................... 85
15.5 ESTRUTURA FILE.................................................................................................................... 85
15.6 ABERTURA DE ARQUIVOS........................................................................................................ 85
15.7 FECHAMENTO DE ARQUIVO ..................................................................................................... 86
15.8 LEITURA E GRAVAÇÃO DE CARACTERES.................................................................................. 86
LINGUAGEM C
5/103
15.8.1 Gravação ........................................................................................................................ 87
15.8.2 Leitura ............................................................................................................................ 87
15.9 VERIFICANDO FIM DE ARQUIVO ............................................................................................... 87
15.10 TRABALHANDO COM ARQUIVOS .............................................................................................. 88
15.11 TRABALHANDO COM STRINGS: FPUTS() E FGETS() ................................................................... 89
15.12 FUNÇÕES DE TRATAMENTO DE ARQUIVOS ............................................................................... 89
15.12.1 rewind() ...................................................................................................................... 89
15.12.2 ferror() ........................................................................................................................ 90
15.12.3 remove()...................................................................................................................... 90
15.12.4 fflush()......................................................................................................................... 91
15.12.5 Função ftell() .............................................................................................................. 91
15.13 LENDO E GRAVANDO REGISTROS ............................................................................................. 91
15.13.1 Escrita de um bloco de dados..................................................................................... 91
15.13.2 Leitura de um bloco de dados..................................................................................... 92
15.13.3 Utilizando os comandos de leitura e gravação de registros....................................... 92
15.14 ACESSO ALEATÓRIO................................................................................................................. 93
15.15 COMANDO DE GRAVAÇÃO EM MODO TEXTO FORMATADO ....................................................... 94
15.16 CONDIÇÕES DE ERRO ............................................................................................................... 95
15.17 STREAMS PADRÃO................................................................................................................... 95
15.18 EXERCÍCIO:.............................................................................................................................. 96
15.19 SISTEMA DE ARQUIVO TIPO UNIX........................................................................................... 96
15.19.1 open().......................................................................................................................... 97
15.19.2 creat() ......................................................................................................................... 98
15.19.3 close() ......................................................................................................................... 98
15.19.4 read() e write()............................................................................................................ 98
15.19.5 unlink() ..................................................................................................................... 100
15.19.6 lseek() e tell() ............................................................................................................ 100
15.19.7 Funções para manipulação de buffers ..................................................................... 100
16. BIBLIOGRAFIA ........................................................................................................................ 103
LINGUAGEM C
6/103
Lista de Figuras
FIGURA 1.1 - CODIFICAÇÃO DE UM PROGRAMA C................................................................................... 8
FIGURA 12.1 INDIREÇÃO SIMPLES E MÚLTIPLA ..................................................................................... 60
FIGURA 14.1 EXEMPLO DE UMA ÁRVORE BINÁRIA................................................................................ 82
LINGUAGEM C
7/103
Lista de Tabelas
TABELA 3.1 - TIPOS DE DADOS BÁSICOS.................................................................................................. 10
TABELA 3.2 - UTILIZAÇÃO DOS MODIFICADORES DE TIPOS DE DADOS ..................................................... 10
TABELA 3.3 - EXEMPLO DE CONSTANTES ................................................................................................ 13
TABELA 4.1 - CÓDIGO PARA OS CARACTERES ESPECIAIS .........................................................................16
TABELA 4.2 - CÓDIGOS PARA FORMATAÇÃO DE IMPRESSÃO.................................................................... 16
TABELA 6.1 - CONVERSÕES DE TIPOS E SEUS EFEITOS ............................................................................. 22
TABELA 6.2 - OPERADORES ARITMÉTICOS .............................................................................................. 23
TABELA 6.3 - OPERADORES ARITMÉTICOS DE ATRIBUIÇÃO ..................................................................... 24
TABELA 6.4 - OPERADORES RELACIONAIS E LÓGICOS.............................................................................. 24
TABELA 6.5 - OPERADORES BIT-A-BIT..................................................................................................... 24
TABELA 6.6 - EXEMPLO DE OPERAÇÕES DE DESLOCAMENTO BIT-A-BIT................................................... 25
TABELA 7.1 - CÓDIGOS DE FORMATAÇÃO DO COMANDO SCANF() ........................................................... 29
TABELA 15.1 - FUNÇÕES MAIS COMUNS DO SISTEMA DE ARQUIVO COM BUFFER ..................................... 85
TABELA 15.2 - OS MODOS DE ABERTURA VÁLIDOS ................................................................................. 86
TABELA 15.3 – MACROS DEFINIDAS EM STDIO.H PARA AS POSIÇÕES PERMITIDAS NA FUNÇÃO FSEEK().93
TABELA 15.3 - FUNÇÕES DE E/S TIPO UNIX SEM BUFFER ...................................................................... 96
TABELA 15.4 MODOS DE ABERTURA DE ARQUIVOS EM BAIXO NÍVEL ...................................................... 97
LINGUAGEM C Introdução
8/103
1. Introdução
A linguagem C foi criada por Dennis M. Ritchie e Ken Thompson no Laboratório Bell em 1972,
baseada na linguagem B de Thompson que era uma evolução da antiga BCPL.
A linguagem C tornou-se muito popular devido a características como:
• O C é uma linguagem de alto nível com uma sintaxe bastante estruturada e flexível tornando sua
programação bastante simplificada.
• Programas em C são compilados, gerando programas executáveis.
• O C compartilha recursos tanto de alto quanto de baixo nível, pois permite acesso e programação
direta do microprocessador. Com isto, rotinas cuja dependência do tempo é crítica, podem ser
facilmente implementadas usando instruções em Assembly. Por esta razão o C é a linguagem
preferida dos programadores de aplicativos.
• O C é uma linguagem estruturalmente simples e de grande portabilidade. O compilador C gera
códigos mais enxutos e velozes do que muitas outras linguagens.
• Embora estruturalmente simples (poucas funções intrínsecas) o C não perde funcionalidade pois
permite a inclusão de uma farta quantidade de rotinas do usuário. Os fabricantes de compiladores
fornecem uma ampla variedade de rotinas pré-compiladas em biblioteca
Como uma ferramenta poderosa a linguagem C é usada na construção de vários aplicativos como
sistemas operacionais, planilhas eletrônicas, processadores de texto, sistemas de transmissão de dados, entre
outros. Um exemplo clássico é o sistema operacional UNIX, o qual foi implementado em C.
No início da década de 80 a linguagem C é padronizada pelo American National Standard Institute:
surge o ANSI C.
Atualmente, a linguagem C vem sendo usada para desenvolver novas linguagens, entre elas a linguagem
C++ e Java.
1.1 Visão geral de um programa C
A geração do programa executável a partir do programa fonte obedece a uma seqüência de operações
ante de tornar-se um executável. Depois de escrever o módulo fonte em um editor de textos, o programador
aciona o compilador. 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 linkador.
FIGURA 1.1 - Codificação de um programa C
Editor
(módulo fonte em C)
Pré-processador
(novo fonte expandido)
Compilador
(arquivo objeto)
Linkador
(executável)
LINGUAGEM C Estrutura Básica de um Programa em C
9/103
2. Estrutura Básica de um Programa em C
Um programa C consiste em uma ou várias “funções”. Baseado nesta afirmação, deve existir um
mecanismo que garanta que todos os programas inicializem da mesma forma. Este mecanismo pode ser
entendido como a padronização da função que será chamada primeiramente. Tal função chama-se main().
Sintaxe:
main() primeira função a ser executada
{ inicia o corpo da função
} termina a função
Abaixo relacionam-se algumas regras para a programação em C:
• Toda função C deve ser iniciada e encerrada por um abre chaves e um fecha chaves
respectivamente;
• O nome da função, os parênteses e as chaves são os únicos elementos obrigatórios de uma
função;
• Todas as instruções devem estar dentro das chaves;
• As instruções C são sempre encerradas por um ponto-e-vírgula;
2.1 Bibliotecas
Para não ter que criar programas grandes devido a linkedição de um arquivo objeto a linguagem inclui
as bibliotecas para que no momento da compilação seja gerado um programa com as funções utilizadas.
Para fazer isto, usa-se uma diretiva de compilação a qual é colocada fora de qualquer função do
programa. A diretiva é #include instrui o compilador a ler outro arquivo-fonte.
Sintaxe:
#include nome_arq
onde:
nome_arq tem que estar entre aspas ou símbolos de maior ou menor
Em algumas plataformas existe somente uma das duas formas. No caso da plataforma DOS/Windows
95, aspas significa para o compilador que a biblioteca em questão deve ser buscada primeiramente no diretório
atual e depois no diretório padrão do turbo ou pelas variáveis de ambiente. Também, os caracteres “<>“
significam ao compilador que deve procurar somente no diretório padrão ou nos diretórios definidos pelas
variáveis de ambiente.
Exemplo 2.1
#include <stdio.h>
Não se usa o ponto-e-vírgula após diretivas de compilação. Este tipo de declaração é muito usado nos
programas profissionais. Cada comando pré-definido em C está prototipado em alguma biblioteca (isto é
informado conjuntamente ao comando).
LINGUAGEM C Tipos de Dados
10/103
3. Tipos de Dados
Em C existem 5 tipos de variáveis básicas. Nos computadores da linha IBM-PC (sistema operacional 16
bits) a tabela 3.1 é válida.
Tabela 3.1 - Tipos de dados básicos
TIPO BIT FAIXA MÍNIMA
char 8 -128 a 127
int 16 - 32768 a 32767
float 32 3.4E-38 a 3.4E+38
double 64 1.7E-308 a 1.7E+308
void 0 sem valor
Com exceção de void, os tipos de dados básicos podem estar acompanhados por modificadores na
declaração de variáveis. Os modificadores de tipos da linguagem C são:
• signed;
• unsigned;
 
 
• long;
• short.
Os modificadores signed, short, long e unsigned podem ser aplicados aos tipos básicos
caractere e inteiro. Contudo, long também pode ser aplicado a double. A tabela 3.2 mostra todas a
combinações de tipos de dados
Tabela 3.2 - Utilização dos modificadores de tipos de dados
TIPO BIT FAIXA MÍNIMA
unsigned char 8 0 a 255
signed char 8 -128 a 127
unsigned int 16 0 a 65535
signed int 16 O mesmo que int
short int 16 O mesmo que int
unsigned short int 16 0 a 65535
signed short int 16 O mesmo que short int
long int 32 -2.147.483.647 a 2.147.483.647
signed long int 32 -2.147.483.647 a 2.147.483.647
unsigned long int 32 0 a 4.294.967.925
long double 128 Dez dígitos de precisão
O uso de signed com inteiros é redundante. No entanto, ele é permitido porque a declaração
default de inteiros assume um número com sinal. O uso mais importante de signed é modificar char em
implementações em que esse tipo, por padrão, não tem sinal. Algumas implementações podem permitir
que unsigned seja aplicado aos tipos de ponto flutuante (como em unsigned double). Porém, isso reduz a
portabilidade de seu código e geralmente não é recomendado. O modificador unsigned altera o valor da
faixa mínima do tipo através do uso do bit mais significativo (indicador de sinal).No caso do sistema operacional ser 32 bits o tipo int será o único a ser alterado, pois ele passa de
2 bytes para 4 bytes de armazenamento. Isto também faz com que o intervalo de valores seja aumentado.
Exemplo 3.1
main()
{
 int qtde;
 char tam;
 float total;
 qtde = 2; tam = ‘G’;
 total = 20.70;
 printf(“Comprei %d camisas de tamanho %c.”, qtde, tam);
LINGUAGEM C Tipos de Dados
11/103
 printf(“\nNo total, paguei R$ %f.”, custo);
}
Execução:
Comprei 2 camisas de tamanho G.
No total, paguei R$ 20.70.
As variáveis podem ser inicializadas no momento em que se faz a declaração das mesmas. Pode-
se ver isto usando o programa anterior, que a execução será a mesma da versão anterior.
main()
{
 int qtde=2;
 char tam=‘G’;
 float total=20.70;
 printf(“Comprei %d camisas de tamanho %c.”, qtde, tam);
 printf(“\nNo total, paguei R$ %f.”, custo);
}
3.1 Enumeração
Enumeração é um conjunto de constantes inteiras que especifica todos os valores legais de uma
variável desse tipo pode ser. A forma geral para enumeração é:
Sintaxe:
enum nome { lista_de_enumeração } lista_de_variáveis;
Aqui, tanto o nome da enumeração quanto a lista de variáveis são opcionais. O nome da
enumeração é usado para declarar variáveis daquele tipo. Com isso pode-se declarar as cores
Exemplo 3.2
enum cores {amarelo, verde, vermelho};
enum cores semaforo;
Dada essa definição e declaração, os tipos de comandos seguintes são perfeitamente válidos:
semaforo = verde;
if (semaforo==verde) printf(“Passagem permitida \n”);
Para melhor compreensão da enumeração entende-se que cada símbolo representa um valor
inteiro. O valor do primeiro símbolo da enumeração é 0. Assim,
printf (“%d %d”, verde, vermelho);
mostra 1 2 na tela.
Como extensão, pode-se inicializar os símbolos de forma alternada para algum problema
específico.
Exemplo 3.3
enum cores { amarelo, verde=10, vermelho };
Agora os valores destes símbolos são
amarelo 0
verde 10
vermelho 11
LINGUAGEM C Tipos de Dados
12/103
3.2 Modificadores de Tipo de Acesso
O padrão ANSI introduziu dois novos modificadores de tipo que controlam a maneira como a
variáveis podem ser acessadas ou modificadas. Esses modificadores são const e volatile. Devem preceder
os modificadores de tipo e os nomes que eles modificam.
3.2.1 Const
Variáveis do tipo const não podem ser modificadas por seu programa (por isso ela recebe um
valor inicial).
Exemplo 3.4
const int a=10;
O exemplo 5.4 cria uma variável inteira chamada a, com um valor inicial 10, que seu programa
não pode modificar.
Um exemplo do uso do const é para verificar se uma variável em particular é modificada pelo
seu programa.
3.2.2 Volatile
O modificador volatile é usado para informar ao compilador que o valor de uma variável pode
ser alterado de maneira não explicitamente especificada pelo programa. Por exemplo, um endereço de
uma variável global pode ser passado para a rotina de relógio do sistema operacional e usado para guardar
o tempo real do sistema. Nessa situação, o conteúdo de uma variável é alterado sem nenhum comando de
atribuição explicito no programa. Isso ajuda o programa no sentido de avisar ao compilador que o
conteúdo de uma variável é mutável, mesmo que sua referência não aparecer no lado esquerdo da
expressão.
É possível usar const e volatile juntos. Por exemplo, se 0x30 é assumido como sendo o valor de
uma porta que é mudado por condições externas. Para evitar efeitos colaterais deve-se declarar da
seguinte forma:
 const volatile unsigned char *port = 0x30;
3.3 Constantes
Uma constante tem valor fixo e inalterável durante a execução do programa. Isto pode ser
exemplificado pelos exemplos 3.1 e 3.2 da função printf().
Em uma constante caractere é escrita entre aspas simples (‘’), uma constante cadeia de caracteres
entre aspas duplas (“”) e constantes numéricas como o número propriamente dito.
Exemplo 3.5
‘C’
“programa”
8
465.67
LINGUAGEM C Tipos de Dados
13/103
Constantes em C podem ser de qualquer um dos cinco tipos de dados básicos. A maneira como
cada constante é representada depende do seu tipo. Pode-se especificar precisamente o tipo da constante
numérica através da utilização de um sufixo. Para tipos em ponto flutuante coloca-se um F após o número,
ele será tratado como float. Se for colocado um L, ele tornar-se-á um long double. Para tipos inteiros, o
sufixo U representa unsigned e o L representa long. A tabela 5.3 mostra alguns exemplos de constantes.
Tabela 3.3 - Exemplo de constantes
Tipo de Dado Exemplo de Constantes
int 1 123 21000 -234
long int 35000L -34L
short int 10 -12 90
unsigned int 10000U 987U 40000“
float 123.23F 2.34e-3F
Double 123.23 12312333 -0.9876324
long double 1001.2L
Além deste tem-se as constantes Hexadecimais e Octais. Usam-se tais sistemas numéricos para
facilitar a programação. Uma constante hexadecimal deve consistir em um 0x seguido por uma constante
na forma hexadecimal. Uma constante octal começa com 0.
Exemplo 3.6
int hex = 0x80; /* 128 em decimal */
int oct = 012; /* 10 em decimal */
3.4 Constantes pré-definidas
Em alguns compiladores C, algumas constantes simbólicas já estão pré-definidas. Estas
constantes em geral definam alguns valores matemáticos (pi, pi/2, e, etc.), limites de tipos etc. A seguir
segue uma tabela contendo algumas (existem muitas outras) constantes simbólicas pré-definidas no
compilador Turbo C++ da Borland.
Biblioteca Constante Valor Significado
math.h M_PI 3.14159... pi
math.h M_PI_2 1.57079... pi/2
math.h M_PI_4 0,78539... pi/4
math.h M_1_PI 0,31830... 1/pi
math.h M_SQRT2 1,41421... √2
conio.h BLACK 0 valor da cor (preto)
conio.h BLUE 1 valor da cor (azul)
conio.h GREEN 2 valor da cor (verde)
conio.h CYAN 3 valor da cor (cyan)
conio.h RED 4 valor da cor (vermelho)
conio.h MAGENTA 5 valor da cor (magenta)
limits.h INT_MAX 32767 limite superior do tipo int
limits.h INT_MIN -32768 limite inferior do tipo int
LINGUAGEM C Tipos de Dados
14/103
3.5 As bibliotecas disponíveis e algumas funções interessantes
A seguir segue uma lista de algumas as bibliotecas disponíveis no compilador Turbo C++
Borland: Ao longo do texto veremos o uso de muitas funções cobrindo uma boa parte destas bibliotecas,
porém o leitor que desejar tornar-se "fluente" na linguagem C pode (e deve) estudá-las com profundidade.
alloc.h assert.h bcd.h bios.h complex.h
conio.h ctype.h dir.h dirent.h dos.h
errno.h fcntl.h float.h fstream.h generic.h
graphics.h io.h iomanip.h iostream.h limits.h
locale.h malloc.h math.h mem.h process.h
setjmp.h share.h signal.h stdarg.h stddef.h
stdio.h stdiostr.h stdlib.h stream.h string.h
strstrea.h sys\stat.h sys\timeb.h sys\types.h time.h
values.h
Vejamos algumas funções disponíveis nas bibliotecas C.
Biblioteca math.h
int abs(int i);
double fabs(double d);
Calcula o valor absoluto do inteiro i e do real d, respectivamente.
double sin(double arco);
double cos(double arco);
double tan(double arco);
double asin(double arco);
double acos(double arco);
double atan(double arco);
Funções trigonométricas do ângulo arco, em radianos.
double ceil(double num);
double floor(double num);
Funções de arredondamento para inteiro.
ceil() arredonda para cima. Ex. ceil(3.2) == 4.0;
floor() arredonda para baixo. Ex. floor(3.2) == 3.0;
LINGUAGEM C Tipos de Dados
15/103
double log(double num);
double log10(double num);Funções logarítmicas: log() é logaritmo natural (base e), log10() é
logaritmo decimal (base 10).
double pow(double base, double exp);
Potenciação: pow(3.2,5.6) = 3.25.6.
double sqrt(double num);
Raiz quadrada: sqrt(9.0) = 3.0.
Biblioteca stdlib.h
int random(int num);
Gera um número inteiro aleatório entre 0 e num - 1.
LINGUAGEM C Comando de Escrita
16/103
4. Comando de Escrita
A função printf() é uma das funções de E/S (entrada e saída) que mostra na tela os parâmetros
que são passados como argumento. Seu protótipo está na biblioteca stdio.h.
Sintaxe:
printf(“<expressao_de_controle>”, lista_de_argumentos)
onde:
expressão_de_controle = contém caracteres que serão exibidos na tela e códigos de formatação
que indicam o formato em que os argumentos (da
lista_de_argumentos) devem ser impressos.
lista_de_argumentos = lista de argumentos que serão apresentadas na expressão_de_controle. Tal
lista não tem tamanho máximo e cada argumento deve ser separado
por uma vírgula.
A tabela 4.1 mostra os códigos na linguagem para caracteres que não podem ser inseridos
diretamente do teclado.
Tabela 4.1 - Código para os caracteres especiais
CÓDIGOS ESPECIAIS SIGNIFICADO
\n Nova Linha (LF)
\t Tab (HT)
\b Retrocesso (BS)
\” ”
\\ Barra invertida
\f Salta Página de Formulário (FF)
\r Retorno de Carro (CR)
\’ ’
\v Tabulação Vertical
\a Alerta (beep)
\N Constante octal (onde N é uma constante octal)
\xN Constante Hexadecimal (onde N é uma constante
hexadecimal)
\0 Nulo
Além destes, existem os códigos para formatação de impressão dos argumentos passados para a
função, os quais estã relacionados na tabela 4.2.
Tabela 4.2 - Códigos para formatação de impressão
CÓDIGO printf() FORMATO
%c Caractere Simples
%d ou %i Decimal
%e ou %E (minúsculo ou maiúsculo) Notação Científica
%f Ponto Flutuante
%g ou %G (minúsculo ou maiúsculo) %e ou %f (o mais curto)
%o Octal
%s Cadeia de Caracteres
%u Decimal sem Sinal
%x ou %X (minúsculo ou maiúsculo) Hexadecimal
%% Escreve o símbolo %
LINGUAGEM C Comando de Escrita
17/103
Exemplo 4.1
main()
{
 printf(“A %s C foi criada em %d \nOk?”, “Linguagem”, 1972);
}
Execução::
A Linguagem C foi criada em 1972
Ok?
No exemplo 3.1 percebe-se o uso de dois tipos de códigos: primeiro de formatação com %s (para
strings) representando a constante string “Linguagem” e %d (decimais) representando a constante ano
1972; segundo um código especial para representar caracter de nova linha \n.
Exemplo 4.2
main()
{
 printf(“A %s %c foi ”, “Linguagem”, ‘C’);
 printf(“ criada em %d ”, 1972);
}
Execução:
A Linguagem C foi criada em 1972
No exemplo 3.2, nota-se que ‘C’ é delimitado por aspas simples enquanto que “Linguagem” é
delimitado por aspas duplas. Isto indica ao compilador como diferenciar um caractere de uma cadeia de
caracteres.
4.1 Modificadores de Saída
Para complementar os códigos de formatação a linguagem C oferece alguns códigos especiais
para melhorar a apresentação dos dados. Para isto relacionam-se:
• ‘-’ : alinhamento pela esquerda.
• ‘+’: coloca o sinal de menos ou mais se o valor for numérico.
• n (número) : indica o tamanho mínimo do campo. O preenchimento é feito com espaços em
branco. Se o tamanho iniciar com 0 (ex. 05), o preenchimento passa a ser feito com zeros.
• .m : tamanho máximo do campo, menos para os reais onde é usado para indicar o número de
casas decimais.
• * : substitui um dos n, mas o seu valor é o próximo parâmetro.
• ‘l’ : indica que segue um dado longo.
Exemplo 4.3
COMANDO TELA
printf(“%s %d”, “Numero”,10); Numero 10
printf(“%8s %4d”, “Numero”,10); ##Numero ##10
printf(“%-8s %4d”, “Numero”,10); Numero## ##10
printf(“%-3.5s %2.2f”,“Numero”,10.99); Numer 10.99
printf(“Long %ld”, 57485784); Long 57485784
onde:
# - representa 1 espaço em branco.
LINGUAGEM C Comando de Escrita
18/103
4.2 Exercícios
1. Escreva os comandos de saída formatada que gerem as seguintes saídas:
 01234567890123456789012
 a) Camisa estampada 40,00
 Camisa lisa 35,00
 
 b) Camisa estampada 40,00
 Camisa lisa 35,00
 
 c) Camisa estampada 00040,00
 Camisa lisa 00035,00
 
 d) Camisa e 40
 Camisa l 35
LINGUAGEM C Variáveis
19/103
5. Variáveis
Variável em C é um espaço de memória reservado para armazenar um certo tipo de dado e tendo
um nome para referenciar o seu conteúdo. O conteúdo da mesma pode variar segundo os comandos de
alteração do programa.
Exemplo 5.1
main()
{
 int ano;
 ano = 1972;
 printf(“A Linguagem C foi criada em %d ”, ano);
}
A primeira instrução,
int ano;
é um exemplo de declaração de variável, isto é, apresenta um tipo, int, e um nome, ano.
A segunda instrução,
ano = 1972;
atribui um valor à variável e este valor será acessado através de seu nome. Para realizar isto foi usado o
operador de atribuição (=).
5.1 Nome de Variáveis
Regras:
• Uma variável não pode ter o mesmo nome de uma palavra-chave de C.
• Em C, letras maiúsculas diferem das letras minúsculas.
• O número de caracteres válidos é definido de ambiente para ambiente.
 
5.2 Declaração de Variáveis
A declaração de variáveis serve para reservar uma quantidade de memória apropriada para
armazenar o tipo especificado. Tal declaração consiste no nome de um tipo, seguido do nome da variável.
Em C todas as variáveis devem ser declaradas.
Se existir mais de uma variável do mesmo tipo, pode-se declará-la de uma vez separando seus
nomes por vírgulas.
int ano, mes, dia;
5.2.1 Tipos de Declarações de Variáveis
O tipo de declaração de variável é definido pela localização onde a mesma é declarada. Existem
três lugares básicos: dentro de funções, na definição dos parâmetros das funções e fora de todas as
funções. Estas são variáveis locais, parâmetros formais e variáveis globais, respectivamente.
LINGUAGEM C Variáveis
20/103
5.2.1.1 Variáveis locais
Variáveis que são declaradas dentro de uma função. Tais variáveis só podem ser referenciadas
por comandos que estão dentro do bloco no qual as variáveis foram declaradas, isto é, não são
reconhecidas fora de seu próprio bloco de código.
Exemplo 5.2
void main()
{
 int num;
 num = 10;
}
5.2.1.2 Parâmetros Formais
Variáveis que são declaradas para passagem de parâmetros em funções.
Exemplo 5.3
int soma(int x, int y)
{
 return (x+y);
}
5.2.1.3 Variáveis Globais
Variáveis que são declaradas fora de qualquer função. Tais variáveis são reconhecidas pelo
programa inteiro e podem ser usadas por qualquer pedaço de código.
Exemplo 5.4
int num=10;
void main()
{
 printf(“%d”, num * num);
}
Exemplo 5.5
int num=2;
int media(int y, int x)
{
 return ((x+z)/num);
}
void main()
{
 int x1 = 15;
 int x2 = 4;
 printf(“%d %d ”, num * num, media(x1,x2));
}
LINGUAGEM C Variáveis
21/103
5.3 Palavras reservadas
Existem certos nomes que não podem ser usados como identificadores. São chamadas as
palavras reservadas e são de uso restrito da linguagem C (comandos, estruturas, declarações, etc.). O
conjunto de palavras reservadas usadas em C é o seguinte:
 asm auto break case cdecl char
 class const continue _cs default delete
 do double _ds else enum _es
 extern _export far _fastcall float for
 friend goto huge if inline int
 interrupt _loadds long near new operator
 pascal private protected public register return
 _saveregs _seg short signed sizeof _ss
 static struct switch template this typedef
 union unsigned virtual void volatile while
LINGUAGEM C Operadores
22/103
6. Operadores
A linguagem Cé muito rica em operadores internos. C define quatro classes de operadores:
aritméticos, relacionais, lógicos e bit a bit. Além disso, C tem alguns operadores especiais para tarefas
particulares.
6.1 Atribuição
Para o operador de atribuição é utilizado o símbolo =. Além disto, a linguagem oferece um tipo
de atribuição múltipla, isto é, em um comando só pode-se atribuir o mesmo valor a muitas variáveis.
Exemplo 6.1
x = 10;
a = b = c = 10;
6.1.1 Conversão de Tipos em Atribuições
A linguagem C permite a conversão automática de tipos, o que não acontece em Pascal, por
exemplo. Conversão de tipos refere-se à situação em que variáveis de um tipo são misturadas com
varáveis de outro tipo. Em um comando de atribuição, a regra de conversão de tipos é muito simples: o
valor do lado direito (lado da expressão) de uma atribuição é convertido no tipo do lado esquerdo
(variável destino), como no exemplo 6.2:
Exemplo 6.2
void main()
{
int x;
char ch;
float f;
ch = x; // Linha 1
x = f; // Linha 2
f = ch; // Linha 3
f = x; // Linha 4
}
Na linha 1, os bits mais significativos da variável inteira x são ignorados, deixando ch com os 8
bits menos significativos. Se x está entre 255 e 0, então ch e x têm valores idênticos. De outra forma, o
valor de ch reflete apenas os bits menos significativos de x. Na linha 2, x recebe a parte inteira de f. Na
linha 3, f converte o valor inteiro de 8 bits armazenado em ch no mesmo valor em formato de ponto
flutuante. Isso também acontece na linha 4, exceto por f converter um valor inteiro de 16 bits no formato
de ponto flutuante.
Na tabela 6.1 mostra-se algumas conversões de tipos e seus efeitos. Para essas conversões foi
assumido uma palavra de 16 bits.
Tabela 6.1 - Conversões de tipos e seus efeitos
Tipo Destino Tipo da Expressão Possível Informação Perdida
signed char char Se valor > 127, o destino é negativo
char short int Os 8 bits mais significativos
char int Os 8 bits mais significativos
char long int Os 24 bits mais significativos
int long int Os 16 bits mais significativos
int float A parte fracionária e possivelmente mais
float double Precisão, o resultado é arredondado
double long double Precisão, o resultado é arredondado
LINGUAGEM C Operadores
23/103
Para utilizar a tabela acima a fim de fazer uma conversão não mostrada, simplesmente converta
um tipo por vez até acabar. por exemplo, para converter double em int, primeiro converta double em
float e, então, float em int.
6.2 Operadores Aritméticos
A tabela 6.2 mostra os operadores aritméticos suportados pela linguagem.
Tabela 6.2 - Operadores aritméticos
Operador Ação
- Subtração, também menos unário
+ Adição
* Multiplicação
/ Divisão
% Módulo da Divisão (resto)
-- Decremento
++ Incremento
O menos unário multiplica seu único operando por -1. Isso é, qualquer número precedido por um
sinal
Quando / é aplicado a um inteiro ou caractere, qualquer resto é truncado.
O operador módulo % também, trabalha em C da mesma forma que em outras linguagens,
devolvendo o resto de uma divisão inteira. Contudo, % não pode ser usado nos tipos em ponto flutuante.
6.2.1 Incremento e Decremento
A linguagem C inclui dois operadores que geralmente não encontramos em outras linguagens.
São os operadores de incremento (++) e decremento (--), os quais somam 1 ao seu operando, e subtraem 1
de seu operando, respectivamente.
x++; ou ++x; ou x = x + 1;
x--; ou --x; ou x = x - 1;
Quando usados em uma expressão tem seus efeitos alterados pela posição do sinal de decremento
e incremento. Se o operador de incremento ou decremento preceder seu operando, C executa a operação
de incremento ou decremento antes de usar o valor do operando. Se o operador estiver após seu operando,
C usa o valor do operando antes de incrementá-lo ou decrementá-lo.
Exemplo 6.3
x = 10;
y = ++x; /*y recebe 11*/
x = 10;
y = x++; /* y recebe 10 */
A precedência dos operadores aritméticos é a seguinte:
++ -- Mais alta
-
* / %
+ - Mais baixa
Os operadores do mesmo nível de precedência são avaliados pelo compilador da esquerda para a
direita.
LINGUAGEM C Operadores
24/103
6.2.2 Operadores Aritméticos de Atribuição
A tabela 6.3 mostra os operadores aritméticos de atribuição suportados pela linguagem.
Tabela 6.3 - Operadores aritméticos de atribuição
Operador Ação
x -= y x = x - y
x += y x = x + y
x *= y x = x * y
x /= y x = x / y
x %= y x = x % y
As expressões com este operadores são mais compactas e normalmente produzem um código de
máquina mais eficiente.
6.3 Operadores Relacionais e Lógicos
A tabela 6.4 mostra os operadores relacionais e lógicos suportados pela linguagem C.
Tabela 6.4 - Operadores relacionais e lógicos
Operador Ação Operador Ação
> Maior que && AND
>= Maior ou igual que || OR
< Menor que ! NOT
<= Menor ou igual que
== Igual
!= Diferente
Em C, verdadeiro é qualquer valor diferente de zero, e falso é zero. As expressões que usam
operadores relacionais ou lógicos devolvem zero para falso e 1 para verdadeiro. Lembre-se de que toda
expressão relacional e lógica produz como resiltado 0 ou 1.
A precedência dos operadores relacionais e lógicos é a seguinte:
! Mais alta
> >= < <=
== !=
&&
|| Mais baixa
6.4 Operadores Bit a Bit
A tabela 6.5 mostra os operadores bit a bit suportados pela linguagem.
Tabela 6.5 - Operadores bit-a-bit
Operador Ação
& AND
| OR
^ OR exclusivo (XOR)
~ Complemento de um
>> Deslocamento à direita
<< Deslocamento à esquerda
LINGUAGEM C Operadores
25/103
A tabela 6.6 mostra o resultado de operações com deslocamento.
Tabela 6.6 - Exemplo de operações de deslocamento bit-a-bit
char x; x a cada execução da sentença Valor de x
x =7 00000111 7
x << 1 00001110 14
x << 3 01110000 112
x << 2 11000000 192
x >> 1 01100000 96
x >> 2 00011000 24
Os operadores bit a bit só podem ser utilizados sobre um byte ou uma palavra, isto é, aos tipos de
dados char e int e variantes do padrão C. Operações bit não podem ser usadas em float, double, long
double, void ou outros tipos mais complexos.
6.5 Operador ?
O operador ? substitui sentenças da forma Se-então-senão.
Sintaxe:
Exp1 ? Exp2 : Exp3;
Onde Exp1, Exp2 e Exp3 são expressões. Onde Exp1 é avaliada e se a mesma for verdadeira,
então Exp2 é avaliada e se torna o valor da expressão. Se Exp1 é falso, então Exp3 é avaliada e se torna o
valor da expressão.
Exemplo 6.4
x = 10;
y = x > 9 ? 100 : 200;
No exemplo 6.4, y recebe o valor 100, porque x (valor é 10) é maior que 9. Uma expressão
equivalente seria
x = 10;
if (x > 9) y = 100;
else y = 200;
6.6 Operadores de Ponteiros & e *
Um ponteiro é um endereço na memória de uma variável. Uma variável de ponteiro é uma
variável especialmente declarada para guardar um ponteiro para seu tipo especificado.
O primeiro operador de ponteiro é &. Ele é um operador unário que devolve o endereço na
memória de seu operando. Por exemplo,
m = &cont;
atribui o endereço de memória da variável cont em m.
Este tipo de operando não pode ser utilizado em três casos:
1. &(cont + 4) - sempre associa-se a uma variável e não expressão;
2. &3 - constantes não são válidas;
LINGUAGEM C Operadores
26/103
3. variáveis declaradas com classe de armazenamento register (não existe endereço para
registrador).
O segundo operador é *. Ele é um operador unário que devolve o valor da variável localizada no
endereço que o segue. Por exemplo, se m contém o endereço da variável cont,
q = *m;
coloca o valor de cont em q.
Os seguintes operadores * e & colocam o valor 10 na variável chamada target. O resultado (o
valor 10) deste programa é mostrado na tela.
Exemplo 6.5
#include “stdio.h”
void main()
{
 int target, source;
 int *m;
 source = 10;
 m = &source;
 target = *m;
 printf(“%d”,target);
}
6.7 Operador Vírgula
O operador vírgulaé usado para encadear diversas expressões. O lado esquerdo de um operador
vírgula é sempre avaliado como void. Isso significa que a expressão do lado direito se torna o valor de
toda a expressão separada por vírgulas.
Exemplo 6.6
x = (y = 3, y + 1);
No exemplo 6.5, primeiro y recebe 3 e, em seguida, atribui o valor 4 a x.
6.8 Expressões
Operadores, constantes e variáveis são os elementos que constituem as expressões. Uma
expressão é qualquer combinação válida desses elementos.
6.8.1 Conversão de Tipos em Expressões
Quando constantes e variáveis de tipos diferentes são misturadas em uma expressão, elas são
convertidas a um mesmo tipo. O compilador C converte todos os operandos no tipo do maior operando, o
que é denominado promoção de tipo. Isso é feito operação por operação, como descrito nas regras de
conversão de tipos abaixo.
SE um operando é long double
ENTÃO o segundo é convertido para long double.
SENÃO, SE um operando é double
ENTÃO o segundo é convertido para double.
SENÃO, SE um operando é float
LINGUAGEM C Operadores
27/103
ENTÃO o segundo é convertido para float.
SENÃO, SE um operando é unsigned long
ENTÃO o segundo é convertido para unsigned long.
SENÃO, SE um operando é long
ENTÃO o segundo é convertido para long.
SENÃO, SE um operando é unsigned
ENTÃO o segundo é convertido para unsigned.
Há ainda um caso adicional especial: se um operando é long e o outro é unsigned, e se o valor
do unsigned não pode ser representado por um long, os dois operandos são convertidos para unsigned
long.
Considere as conversões de tipo que ocorrem no exemplo 6.6. Primeiro, o caractere ch é
convertido para um inteiro e float f é convertido para double. Em seguida, o resultado de ch/i é
convertido para double porque f*d é double. O resultado final é double porque, nesse momento, os dois
operandos são double.
Exemplo 6.7
char ch;
int i;
float f;
double d;
result= ( ch / i ) + ( f * d ) - ( f + i );
 int double float
 double
 double
6.8.2 Casts
A linguagem permite que uma expressão pode ser forçada a ser de um tipo especificado usando
uma construção chamada cast. A forma geral de um cast é
(tipo) expressão
onde um tipo é um tipo de dado padrão de C. Por exemplo, para ter certeza de que a expressão x /2 será
do tipo float, escreve-se
(float) x/2;
Neste caso se a variável x fosse um inteiro ímpar sem o cast seu valor reria um inteiro (o que não
seria verdadeiro). Entretanto, com o uso do Cast oa variável x é definida como um float o que tornará o
seu resultado um float.
Como um operador, um cast é unário e tem a mesma precedência de qualquer outro operador
unário.
LINGUAGEM C Operadores
28/103
6.8.3 Espacejamento e Parênteses
A linguagem C não limita o espaçamento ou tabulações em uma expressão. Ajudam a aumentar a
legibilidade do programa.
O excesso de parênteses não causa erros, isto é, colocar parênteses onde não necessita, não
provoca erros, mas dificulta a leitura do programa.
LINGUAGEM C Algumas funções de E/S
29/103
7. Algumas funções de E/S
Neste capítulo será visto algumas funções como scanf(), getche(), getch(), getchar() e putchar().
Tais funções encontram-se no arquivo stdio.h, exceto getch() e getche() que encontram-se seus protótipos
em conio.h.
7.1 Função scanf()
Esta função serve para ler dados formatados da entrada padrão (teclado). Sua sintaxe é similar à
de printf(), isto é, uma expressão de controles seguida por uma lista de argumentos separados por
vírgulas.
A principal diferença é que os argumentos de scanf() devem ser endereços de variáveis. Para
enviar o endereço de cada argumento utiliza-se o operador &.
Sintaxe:
scanf(“expressão_de_controle”,lista_de_argumentos)
A expressão de controle pode conter códigos de formatação, precedidos por um sinal %. Além
disso, o caractere * colocado após o % que avisa à função que deve ser lido um valor do tipo indicado
pela especificação, mas não deve ser atribuído a nenhuma variável (não deve ter parâmetros na lista de
argumentos para estas especificações).
Tabela 7.1 - Códigos de formatação do comando scanf()
CÓDIGO printf() FORMATO
%c Lê um único caractere simples
%d ou %i Lê um inteiro decimal
%e Lê um número em notação científica
%f Lê um número em ponto flutuante
%g Lê um número em ponto flutuante
%o Lê um número em octal
%s Lê um número em cadeia de Caracteres
%u Lê um decimal sem sinal
%x Lê um hexadecimal
%l Lê um inteiro longo
%% Busca por um conjunto de caracteres
Exemplo 7.1
main()
{
 char a;
 printf(“Digite um caractere e veja-o em decimal, ”);
 printf (“ octal e hexadecimal. \n”);
 scanf(“%c”,&a);
 printf(“\n%c=%d dec., %o oct. e %x hex. \n”,a,a,a,a);
}
Execução (faça você mesmo):
LINGUAGEM C Algumas funções de E/S
30/103
7.2 Função getche() e getch()
A função getche() lê um caractere do teclado sem pressionar <ENTER> e mostra o que foi
digitado. Esta função não aceita argumentos e devolve o caracter lido para a função que a chamou.
Exemplo 7.2
main()
{
 char ch;
 printf(“Digite algum caractere:”);
 ch=getche();
 printf(“\n A tecla pressionada eh %c.”, ch);
}
Execução:
Digite algum caractere: a
A tecla pressionada eh a.
A função getch() lê um caractere do teclado sem pressionar <ENTER> e não mostra o que foi
digitado. Esta função não aceita argumentos e devolve o caracter lido para a função que a chamou.
Exemplo 7.3
main()
{
 char ch;
 printf(“Digite algum caractere:”);
 ch=getch();
 printf(“\n A tecla pressionada eh %c.”, ch);
}
Execução:
Digite algum caractere:
A tecla pressionada eh a.
7.3 Lendo e escrevendo caracteres
A função getchar() lê um caractere do teclado (este comando necessita o pressionamento da
tecla <ENTER> após o caractere), e putchar() escreve um caracter na tela. A função getchar() espera
até que uma tecla seja pressionada (a qual é mostrada na tela) e devolve o seu valor. A função putchar()
escreve seu argumento caractere na tela a partir da posição atual do cursor. Os protótipos para getchar() e
putchar() são mostrados aqui:
int getchar(void);
int putchar(int c);
A função getchar() devolve um inteiro, mas o byte de baixa ordem contém o caractere. Além
disso, pode-se chamar putchar() com um argumento caractere. A função putchar() devolve o caractere
escrito, ou EOF (definida em stdio.h e geralmente é igual a -1), se ocorreu algum erro. A função
putchar() não acrescenta um \n a saída.
Exemplo 7.4
main()
{
 char ch;
 printf(“Digite algum caractere:”); ch=getchar();
 printf(“\n A tecla pressionada eh ”);
 putchar(ch);
LINGUAGEM C Algumas funções de E/S
31/103
}
7.4 Exercícios
1. Escreva um programa que leia 3 números e mostre a sua média.
2. Escreva um programa que leia 2 números e mostre qual é o maior.
3. Faça um programa que leia dois números e em seguida mostre ,o produto a soma e a subtração entre
eles.
4. Faça um programa que leia 3 variáveis a, b e c, coeficientes de uma equação do 2º grau e escreva as
duas raízes da equação.
5. Escreva um programa onde o usuário entra com um número qualquer e o programa responda se o
número e par ou impar . Se for par emite a mensagem “ O número é par ” ou caso contrário “O número
é impar ”.
 
acb,
a
b
x 4 onde 
2
2
−=∆∆±−=
LINGUAGEM C Comandos Condicionais
32/103
8. Comandos Condicionais
Neste capítulo serão vistos os comandos condicionais da linguagem C.
8.1 Comando if
Sintaxe:
if (<expressão>)
 <comando>;
else
 <comando>;
Onde comando pode ser um único comando, um bloco de comandos ou nada (no caso de
comandos vazios). A cláusula else é opcional.
Exemplo 8.1
if (x != 0)
 x = 0;
Obs.: Caso haja um else ele pertence ao if mais próximo.
Exemplo 8.2
if (a > 5)
 {
 if (a < 10)
 b = 3;
 }
else
 b = 7;No exemplo 8.2, se o comando if mais interno não fosse separado por chaves, o else pertenceria
ao mesmo e não ao mais externo.
Exemplo 8.3
/* Programa para adivinhar um numero */
#include “stdio.h”
#include “stdlib.h”
void main()
{
int num, tentativa;
num = rand(); /*gera numero aleatorio entre 0 e 32767*/
scanf(“%d”, &tentativa);
if (tentativa == num)
 printf(“* * * CERTO * * *”);
}
Lembre-se que para montar um bloco de comando é somente necessário usar o abre e fecha
chaves para marcar início e fim de bloco de comandos respectivamente.
8.2 Comando switch
C tem um comando interno de seleção múltipla, switch, que testa sucessivamente o valor de uma
expressão contra uma lista de constantes inteiras ou de caractere.
Sintaxe:
switch (<expressão>) {
LINGUAGEM C Comandos Condicionais
33/103
case <valor1> : <seqüência de comandos>
break;
case <valor2> : <seqüência de comandos>
break;
…
default:
 <seqüência de comandos>
}
O valor da expressão é testado, na ordem, contra os valores das constantes especificadas nos
comandos case. Quando uma coincidência for encontrada, a seqüência de comandos associada àquele
case será executada até que o comando break ou o fim do comando switch seja alcançado. O comando
default (opcional) é executado no momento em que não coincidir nenhum valor.
Exemplo 8.4
#include <stdio.h>
void main()
{
char opcao;
printf(“1. Opcao 1 \n”);
printf(“2. Opcao 2 \n”);
printf(“3. Opcao 3 \n”);
printf(“Opcao:”);
opcao=getchar();
switch(opcao) {
case ‘1’: printf (“\nVocê escolheu a opcao 1”);
break;
case ‘2’: printf (“\n Você escolheu a opcao 2”);
break;
case ‘3’: printf (“\n Você escolheu a opcao 3”);
break;
default: printf (“\n Nenhuma opcao selecionada”);
break;
}
}
8.3 Exercícios
1. Escrever um programa que leia 3 pares de cordenadas (x,y), que definam 3 pontos e:
• Verificar se eles formam um triângulo : não podem estar alinhados e não podem haver pontos
sobrepostos.
• calcular os lados do triângulo.
• classificar o tipo do triângulo:
• eqüilátero, isósceles ou escaleno.
• acutângulo, obtusângulo ou retângulo
2. Escreva um programa que leia 3 números e os escreve em ordem crescente.
3. Faça um programa que leia um número inteiro, verifique se é positivo ou negativo e escreva uma
mensagem apropriada.
4. Faça um programa contendo um menu com as seguintes opções :
S - soma
P - produto
U - subtração
D - divisão
Q - sair
LINGUAGEM C Comandos Condicionais
34/103
O programa deve conter uma função para executar cada tarefa pedida: soma , subtração etc .
Quando o usuário teclar ESC o programa deve terminar.
LINGUAGEM C Comandos Repititivos ou Laços
35/103
9. Comandos Repititivos ou Laços
9.1 Laço for
Comando de repetição condicional com inicialização e incremento.
Sintaxe:
for(inicialização; condição;incremento) comando;
Onde comando é um comando vazio, um comando simples, ou um bloco de comandos. Primeiro
é executado a inicialização que consiste em atribuições iniciais. Depois é testada a condição (expressão
relacional) de controle do laço. O incremento é executado após a execução do comando ou bloco de
comandos. O fim do laço é determinado pelo valor falso que a condição se apresenta.
Exemplo 9.1
#include “stdio.h”
main()
{
 int x;
 for(x=1; x<=100; x++)
 printf(“%d”,x);
}
No programa acima x é inicializado com 1. Uma vez que x é menor que 100, printf() é
executado e x é incrementado em 1 e testado para ver se ainda é menor ou igual a 100. Esse processo se
repete até que x fique maior que 100; nesse ponto, o laço termina. Então este programa imprime na tela os
números de 1 a 100.
9.2 Laço while
Comando de repetição condicional.
Sintaxe:
while(condição) comando;
Onde comando é um comando vazio, uma comando simples, ou um bloco de comandos. Primeiro
é testada a condição (expressão relacional) de controle do laço. E a cada execução de comando é repetido
o teste de condição. O fim do laço é determinado pelo valor falso que a condição se apresenta.
Exemplo 9.1
#include “stdio.h”
main()
{
 int cont=0;
 char ch;
 while((c=getchar()) != ‘0’)
 cont++;
 printf(“Foram lidos %d caracteres”,cont);
}
LINGUAGEM C Comandos Repititivos ou Laços
36/103
9.3 Laço do-while
Ao contrário dos comandos for e while, que testam a condição do laço no começo, o laço do-
while verifica a condição ao final do laço.
Sintaxe:
do
<comando>
while(condição);
Exemplo 9.2
#include <stdio.h>
void main()
{
char opcao;
printf(“1. Opcao 1 \n”);
printf(“2. Opcao 2 \n”);
printf(“3. Opcao 3 \n”);
printf(“Opcao:”);
do {
 opcao=getchar();
 switch(opcao) {
case ‘1’: printf (“\nVocê escolheu a opcao 1”);
 break;
case ‘2’: printf (“\n Você escolheu a opcao 2”);
 break;
case ‘3’: printf (“\n Você escolheu a opcao 3”);
 break;
default: printf (“\n Nenhuma opcao selecionada”);
 break;
 }} while (opcao != ‘1’ && opcao != ‘2’ && opcao != ‘3’);
}
9.4 Comandos break, continue e exit()
O comando break pode ser usado no corpo de qualquer estrutura de laço C. Causa a saída
imediata do laço e o controle passa para o próximo comando do programa.
Sintaxe:
break;
O comando continue força a próxima iteração do laço e pula o código que estivar abaixo. Nos
laços while e do-while um comando continue faz com que o controle do programa vá diretamente para o
teste condicional e depois continue o processo do laço.
Sintaxe:
continue;
Da mesma forma que pode-se sair de um laço, pode-se sair de um programa usando a função
exit() da biblioteca padrão. Essa função provoca uma terminação imediata do programa inteiro, forçando
um retorno ao sistema operacional.
Sintaxe:
void exit(int código_de_retorno);
LINGUAGEM C Comandos Repititivos ou Laços
37/103
O valor de código_de_retorno é retornado ao processo chamador (sistema operacional). O zero é
geralmente usado como um código de retorno que indica uma terminação normal do programa.
Exemplo 9.3
#include <stdio.h>
void main()
{
char opcao;
printf(“1. Opcao 1 \n”);
printf(“2. Opcao 2 \n”);
printf(“3. Opcao 3 \n”);
printf(“4. Abandonar \n”);
printf(“Opcao:”);
do {
 opcao=getchar();
 switch(opcao) {
case ‘1’: printf (“\nVocê escolheu a opcao 1”);
 break;
case ‘2’: printf (“\n Você escolheu a opcao 2”);
 break;
case ‘3’: printf (“\n Você escolheu a opcao 3”);
 break;
case ‘4’: exit(0); /* retorna ao SO */
 }} while (opcao != ‘1’ && opcao != ‘2’ && opcao != ‘3’);
}
9.5 Exercícios
1. Escreva um programa para calcular o fatorial de um número lido.
2. Escreva um programa para ler um caracter de comparação e vários caracteres de entrada finalizados
por ‘0’ e contar o número de vezes que o caracter de comparação apareceu.
3. Escrever um programa que mostre os números primos entre 1 e 100.
4. Escreva um programa que leia um número não determinado de valores positivos, e mostre a soma e
média dos respectivos números ao ser lido um valor negativo.
5. Faça um programa que leia um número (inteiro) e escreva todos os seus divisores.
6. Faça um programa que leia um número de no máximo 3 dígitos e escreva-o na tela.
7. Faça um programa que receba como entrada uma quantia em dinheiro e mostre na tela a quantidade de
notas de 5, 10, 50 e 100 são necessárias para representar o valor. O programa deve contabilizar a partir
das notas de 100.
8. Suponha um número N qualquer: se N é par então N agora é N / 2; se N é ímpar N agora é 3*N + 1.
Assim para N = 3 calculamos a seguinte tabela :
3 � 10 4 � 2
10 � 5 2 � 1
5 � 16 1 � 4
16 � 8 4 � 2
8 � 4 2 � 1
Observe que a partir de sete iterações a seqüência 4 2 1 começa a se repetir . Faça um programa
que calcule para um dado N o número de iterações até se chegar aoprimeiro 1 .
LINGUAGEM C Comandos Repititivos ou Laços
38/103
9. Faça um programa que imprima os elementos de uma PA e o somatório da mesma dados : primeiro
termo , numero de termos e razão
10. Faça um programa que imprima um elemento da seqüência de Fibonacci , dado o numero do elemento.
11. Faça um programa onde o usuário entra com um número decimal e o mesmo calcula e imprime o
número no sistema binário .
12. Faça um programa onde o usuário entra com dois números A e B o programa devolve como resultado
A elevado a B .
13. Escreva um programa que solicite ao usuário três números inteiros a,b,c onde a é maior que 1 . Seu
programa deve somar todos os inteiros entre b e c divisíveis por a .
LINGUAGEM C Funções
39/103
10. Funções
A forma geral de uma função é:
Sintaxe:
tipo_função nome_função (lista_de_parâmetros)
declaração_parâmetros
{
 corpo_função;
}
Exemplo 10.1
 int soma(int x, int y)
 {
 ...
 }
ou
int soma(x, y)
int x,y;
{
...
 }
As funções retornam um valor (do tipo indicado em tipo_função). O valor retornado pela função
é dado pelo comando return (o valor retornado pode ou não ser utilizado).
Existem dois tipos de passagem de argumentos: por valor e por referência. A segunda é realizada
através de apontadores.
Exemplo 10.2
int pot(x,n) /* x elevado na n potência */
int x,n;
{
int p;
for(p=1;n>0;n--)
 p *= x;
return p;
}
No exemplo 11.2, os argumentos foram passados por valor e a função retorna um valor do tipo
inteiro. A chamada seria:
a = pot(10,2);
No exemplo 11.3, nenhum valor é retornado (por isso usa-se o tipo void) mas é realizado uma
troca dos valores das variáveis, necessitando de uma passagem de parâmetros por referência.
Exemplo 10.3
void troca(a,b) /* troca os valores das variáveis */
int *a, *b; /* usa-se ponteiros para referenciar */
{ /* o conteúdo do endereço da variável */
int aux;
aux = *a;
*a = *b;
*b = aux;
}
LINGUAGEM C Funções
40/103
A chamada para esta função seria:
int x=1,y=2;
troca(&x,&y);
Na passagem de parâmetros por referência é passado explicitamente o endereço da variável com
o uso do operador &.
Quando o argumento for uma matriz automaticamente será passado o endereço da matriz para a
função.
A linguagem C aceita chamadas recursivas de funções.
10.1 Localização das funções
Existem basicamente duas posições possíveis para escrevermos o corpo de uma função: ou antes
ou depois do programa principal. Podemos ainda escrever uma função no mesmo arquivo do programa
principal ou em arquivo separado.
10.1.1 Corpo da função antes do programa principal (no mesmo arquivo)
Quando escrevemos a definição de uma função antes do programa principal e no mesmo arquivo
deste, nenhuma outra instrução é necessária.
Exemplo 10.4
float media2(float a, float b){ // função
 float med;
 med = (a + b) / 2.0;
 return(med);
}
void main(){ // programa principal
 float num_1, num_2, med;
 puts(”Digite dois números:”);
 scanf(”%f %f”, &num_1, &num_2);
 med = media2(num_1, num_2); // chamada da função
 printf(”\nA media destes números e´ %f”, med);
}
10.1.2 Corpo da função depois do programa principal (no mesmo arquivo)
Quando escrevemos a definição de uma função depois do programa principal e no mesmo
arquivo deste, devemos incluir um protótipo da função chamada. Um protótipo é uma instrução que
define o nome da função, seu tipo de retorno e a quantidade e o tipo dos argumentos da função. O
protótipo de uma função indica ao compilador quais são as funções usadas no programa principal os tipo.
A sintaxe geral para isto é a seguinte:
Sintaxe:
void main(){ // programa principal
 tipo nomef(...); // protótipo da função
 ...
 var = nomef(...) // chamada a função
 ...
}
LINGUAGEM C Funções
41/103
tipo nomef(...){ // definição da função
 [corpo de função]
}
Exemplo 10.5
void main(){ // programa principal
 float media2(float,float); // protótipo de media2()
 float num_1, num_2, med;
 puts(”Digite dois números:”);
 scanf(”%f %f”, &num_1, &num_2);
 med = media2(num_1, num_2); // chamada a função
 printf(”\nA media destes números e´ %f”, med);
}
float media2(float a, float b){ // função media2()
 float med;
 med = (a + b) / 2.0;
 return(med);
}
Observe que o protótipo de uma função nada mais é que a declaração da função sem o seu
corpo. Observe ainda que na lista de argumentos do protótipo podem ser escritos apenas os tipos dos
argumentos.
10.1.3 Corpo da função escrito em arquivo separado
Em C, como em muitas outras linguagens, é permitido que o usuário crie uma função em um
arquivo e um programa que a chame em outro arquivo distinto. Esta facilidade permite a criação de
bibliotecas de usuário: um conjunto de arquivos contendo funções escritas pelo usuário. Esta
possibilidade é uma grande vantagem utilizada em larga escala por programadores profissionais.
Quando escrevemos a definição de uma função em arquivo separado do programa principal
devemos incluir este arquivo no conjunto de arquivos de compilação do programa principal. Esta
inclusão é feita com a diretiva #include. Esta diretiva, vista nas seções 2.4.2 e 3.7.1, instrui o
compilador para incluir na compilação do programa outros arquivos que contem a definição das funções
de usuário e de biblioteca.
Sintaxe:
#include ”path” // inclusão da função
void main(){ // programa principal
...
 var = nomef(...) // chamada a função
...
}
Na diretiva #include, indicamos entre aspas duplas o caminho de localização do arquivo onde
está definida a função chamada.
Exemplo 10.6
#include ”c:\tc\userbib\stat.h” // inclusão da função
void main(){ // programa principal
 float num_1, num_2, med;
 puts(”Digite dois números:”);
 scanf(”%f %f”, &num_1, &num_2);
 med = media2(num_1, num_2); // chamada a função
LINGUAGEM C Funções
42/103
 printf(”\nA media destes números e´ %f”, med);
}
10.2 Argumentos para função main()
A função main() aceita argumentos para a passagem de parâmetros realizada através da chamada
do programa. Os dois argumentos são:
argc: contador de argumentos;
argv: vetor de argumentos (vetor de apontadores para strings).
Sintaxe:
main(int argc, char *argv[])
É importante lembrar que
Exemplo 10.7
#include “stdio.h”
void main(int argc, char *argv[])
{
int cont;
printf(“Foram encontrados %d argumentos \n”,argc -1);
for (cont=1;cont < argc;cont++)
 printf(“Argumento %d: %s \n”, cont, argv[cont]);
}
O primeiro argumento (argv[0]) é o nome do programa.
10.3 Protótipo de funções
O padrão ANSI C expandiu a declaração tradicional de função, permitindo que a quantidade e os
tipos dos argumentos das funções sejam declarados. A definição expandida é chamada protótipo de
função. Protótipos de funções não faziam parte da linguagem C original. Protótipos permitem que C
forneça uma verificação mais forte dos tipos.
Protótipos de funções ajudam a detectar erros antes que eles ocorram. É verificado número de
parâmetros, compatibilidade de tipos, entre outras.
Existem três tipos de declaração de protótipos:
Sintaxe Exemplo
tipo_função nome_função(); int pot();
tipo_função nome_função(lista_tipo_argumentos); int pot(int,int);
tipo_função nome_função(lista_tipo_nome_argumentos); int pot(int x, int y);
10.4 Retorno de Ponteiros
Ponteiros para variáveis não são variáveis e tampouco inteiros sem sinal. São endereço na
memória de um certo tipo de dado. A forma geral é:
Sintaxe:
tipo_função *nome_função(lista_de_argumentos);
LINGUAGEM C Funções
43/103
10.5 Números de parâmetros variável
Em C, pode-se especificar uma função que