Cap1 Intro Linguagem C

Introdução à
Programação
- Introdução à Linguagem C -
Prof. Dr. Adriano Caminha

adrianocaminha@id.uff.br
Profa. Dra. Vera Prudência Caminha
veraprudencia@id.uff.br
ICEx/UFF
Volta Redonda-RJ
© 1999-2020
Introdução à Programação – Introdução à Linguagem C –
Sumário
Do Problema ao Programa ...................................................................... 03

A Linguagem C ........................................................................................ 03
Organização de um Programa em C ....................................................... 04
Forma Geral de um Programa em C ...................................................... 04
Ferramentas e Compiladores para C ..................................................... 05
Compilador GCC -GNU C Compiler (Linux) ......................................... 06
Caracteres Válidos em C ......................................................................... 07
Comentários ............................................................................................. 07
Diretivas de Compilação .......................................................................... 07
Principais Bibliotecas .............................................................................. 07
Saída de Dados ......................................................................................... 08
Códigos de Controle e Caracteres Especiais .......................................... 08
Tipos Básicos de Dados ............................................................................ 09
Variáveis ................................................................................................... 09
Palavras Reservadas ............................................................................... 10
Atribuição ................................................................................................. 10
Atribuição Múltipla ................................................................................. 11
Exercícios .................................................................................................. 11
Entrada de Dados .................................................................................... 12
Operadores Aritméticos ........................................................................... 13
Casting: Conversão de Tipos ................................................................... 13
Uso do Operador Divisão ......................................................................... 14
Exercícios .................................................................................................. 14
Operadores de Atribuição Aritmética ..................................................... 15
Operadores Incrementais ........................................................................ 15
Operadores Relacionais ........................................................................... 17
Operadores Lógicos .................................................................................. 17
© 1999 – 2020 Prof. Dr. Adriano Caminha – ICEx/UFF – Volta Redonda-RJ 2

Tabelas Verdade ...................................................................................... 17

Comando Condicional .............................................................................. 18
Exercícios .................................................................................................. 20

Do Problema ao Programa
1. Problema e análise → Estudo e análise do problema proposto e

de possíveis soluções.
2. Desenvolvimento do algoritmo → Desenvolvimento da solução

do problema em Portugol.
3. Edição → Codificação do algoritmo em uma linguagem de

programação gerando o programa fonte.
4. Preprocessamento → As partes do código fonte são preparadas

ou modificadas pelo preprocessador (distribuição de constantes
por todo o código, troca de comentários por espaços, diretivas
de inclusão de arquivos de cabeçalho, etc).
5. Compilação → O programa fonte é compilado, erros de sintaxe

são verificados. Se não houver erros o programa objeto é
gerado. Em caso de erro, é necessário retornar à fase de edição.
6. Linkedição → O linkeditor junta as funções de bibliotecas ao

programa objeto gerando o programa executável. Em caso de
erro, é necessário retornar à fase de edição.
7. Execução → O programa é carregado para a memória e a cpu o

executa, instrução por instrução.

A Linguagem C
• É uma linguagem de nível intermediário que utiliza recursos da

linguagem de máquina de forma simplificada.
• É uma linguagem estruturada (possui recursos como funções, laços,

etc) e tem sido usada para criação de vários tipos de programas tais
como processadores de texto, sistemas operacionais, planilhas,
compiladores, ferramentas para outras linguagens de programação,
etc.
• C é case sensitive, ou seja, maiúsculas e minúsculas são diferentes

em comandos, nomes de variáveis, etc.
Organização de um Programa em C
Um programa C é constituído de:
1. Um cabeçalho que contém definições de preprocessamento tais

como: arquivos de cabeçalho, definições de constantes
simbólicas, declaração de variáveis globais, declaração de
funções, etc;
2. Um bloco da função principal main();
3. Outros blocos de funções;
4. Comentários.

Forma Geral de um Programa em C
<definições de pré-processamento>
<tipo de retorno> main (<parâmetros>)
{ <bloco de comandos>
<tipo de retorno> nome_funcao1(<parâmetros>)
<tipo de retorno> nome_funcao2(<parâmetros>)

Exemplo:
#include <stdio.h>
main()
{
printf(“Um programa em C.\n”);
}
Onde:
#include <stdio.h> → Usar a biblioteca padrão de entrada e saída.
main → main é o nome da função principal.
() → Parâmetros: neste caso, sem parâmetros.
{ → Início da função principal.
printf(...) → Imprime na tela a mensagem.
\n → Adiciona uma quebra de linha (nova linha).
} → Fim da função principal.
Ferramentas e Compiladores para C
Ferramenta Dev-C++ (Windows)

→ Para cada exercício deve ser criado um novo projeto:
1- File/New/Project
2- Console Application, C Project, name = nome do projeto
3- Escolher a pasta do projeto (ex: Desktop)
Exemplo: main.c (nome sugerido pela ferramenta)

#include<stdio.h>
#include<stdlib.h> //obrigatório para o windows
int main (int argc, char *argv[])
{ printf(“Funciona!\n\n”); //adicione esta linha
system(“pause”); //obrigatório para o windows
return 0;
}
Compilar e Executar: [F9] (tecla)
Saída: Funciona!
Press any key to continue...
Compilador GCC – GNU C Compiler (Linux)
-Editar o programa com editor de texto simples gedit (aplicativos/

acessórios/ editor de textos).
-Crie uma nova pasta (sua nova pasta de projetos para C).
-Abra o Terminal (Ctrl+Alt+T) e use o comando “cd” do linux para ir

para a sua pasta do projeto.
Ex:
...$ cd Área[tab]
→ A tecla TAB ajuda a auto complementar nomes

de arquivos e de pastas (neste caso para “Área de
Trabalho”).
...$ cd suapasta

Exemplo: main.c
→ Salve o arquivo com este nome e extensão, isso ativará as
cores do editor gedit para a linguagem C.
#include<stdio.h>
main ()
{
printf(“Funciona!\n\n”);
}
-Para compilar: gcc main.c
-Para executar: ./a.out
-Para compilar mudando o nome do executável:

gcc –o main.out main.c
-Para executar: ./main.out

Caracteres Válidos em C
• Letras maiúsculas e minúsculas não acentuadas
• Algarismos de 0 a 9
• Especiais: + - * / \ = | & ! ? # % ( ) { } [ ] _ ' “ ” . , ; : < >
→ Para as strings, qualquer outro caractere é válido.
Comentários
→ Podem aparecer em qualquer lugar do programa:
// Comentário de uma única linha
/* Comentário
de várias
linhas
*/

Diretivas de Compilação
→ Informam que bibliotecas e constantes simbólicas deverão ser

anexadas quando for gerado o programa executável.
#include → diz ao compilador para incluir na compilação do

programa outros arquivos (geralmente bibliotecas de funções).
Sintaxes válidas para inclusão de bibliotecas:
#include <nome_da_biblioteca>
#include “nome_da_biblioteca”
Principais Bibliotecas
1. stdio.h (ler, imprimir na tela, esvaziar o buffer)

→ printf(), scanf(), …
2. math.h (funções matemáticas)

→ sqrt(), pow(), sin(), cos(), tan(), ...
3. ctype.h (funções de texto, converter para maiúsculas ou

minúsculas, etc)
→ toupper(), tolower(), …
4. stdlib.h (valor absoluto, randômicos, etc)

→ abs(), rand(), ...

Saída de Dados
→ printf() (biblioteca stdio.h)
Sintaxe:
printf(“Expressão”, <lista de argumentos>);
Onde:
1. A expressão de controle contém, entre aspas duplas, o que

aparecerá na tela (strings e códigos de controle).
2. Lista de argumentos são os valores que queremos mostrar na tela,

separados por vírgulas.
Exemplo: printf(“Linguagem C.”);
Códigos de Controle e Caracteres Especiais
Código Significado
%d Inteiro
%f Real
%c Caractere
%s String (Conjunto de caracteres)

Caracteres Especiais Significado
\n Nova linha
\t Tabulação (próxima zona)
\” Imprimir aspas duplas
\' Imprimir aspas simples
\\ Imprimir barra invertida

Exemplo prático:
//exprintf.c
#include <stdio.h>
int main()
{
//impressoes
printf("Impressao com PRINTF:\n\n");
printf("Letras: %c, %c \n", 'A', 'a');
printf("Inteiros: %d, %d \n", 384, 58);
printf("Reais: %.2f, %.3f\n",12.27,104.752);
printf("Letra, Inteiro: %c, %d \n",'L',37);
printf("Tabulando: %d \t %d \n", 55, 10);
}
Tipos Básicos de Dados
Existem 5 tipos básicos de dados em C:
Tipo Significado Tamanho
char Caracter 1 byte
int Inteiro 2 bytes
float Ponto flutuante (real) 8 bytes
double Ponto flutuante de precisão dupla 16 bytes
void Sem valor

Variáveis
Sintaxe para declarações:
<tipo> nome_da_variavel;
Exemplos:
int num;
int idade;
float a, b, c;
float peso;
char sexo;
float altura;
→ Em C, as variáveis são declaradas no início da função.

Palavras Reservadas
Existem certos nomes que não poderão ser usados como

identificadores (nomes) de variáveis. São chamadas palavras reservadas e
são de uso restrito da linguagem C.
Exemplos: double, int, float, char, void, for, while, do,

if, eles, break, short, switch, default, long, entre outras.
→ O nome da variável nunca pode começar com um número.
Exemplo: int 1num; //errado
int num1; //correto
Atribuição
Sintaxe: nome_da_variavel = valor;
Exemplos: num = 12;
idade = 27;
peso = 58.8;
altura = 1.73;
sexo = 'F';
→ Em C, é possível declarar e inicializar uma variável.
Exemplos: int num = 12;
int a = 0;
float peso = 58.8;

Exemplo prático:
//exinicializacao.c
#include <stdio.h>
int main()
{
//inicializacoes
int num = 100;
float a = 20.56;
char letra = 'A';
//impressoes
printf("Número inteiro: %d \n", num);
printf("Número real: %.2f \n", a);
printf("Letra: %c \n", letra);
}
Atribuição Múltipla
→ Em C, é possível inicializar variáveis do mesmo tipo ao mesmo

tempo.
Exemplo: int x, y, z;
x = y = z = 20;

→ As operações ocorrem da direita para a esquerda, isto é,

inicialmente o valor 20 é atribuído a z, depois o valor de z é atribuído a y e
por último, o valor y é atribuído a x.
Exercício Resolvido: Escreva um programa que contenha 2

variáveis inteiras, duas variáveis reais e uma variável caractere. Atribua
valores para as variáveis. Imprima os valores das variáveis.
//exvariaveis.c
#include <stdio.h>
int main()
{ //declaracoes
int a, b;
float c, d;
char e;
//inicializacoes
a = 10;
b = a + 10;
c = a + 0.123;
d = b + 1.234;
e = 'E';
//impressoes
printf("a = %d, b = %d\n", a, b);
printf("c = %.3f, d = %.3f.\n", c, d);
printf("e = %c.\n", e);
}

Exercícios
→ Faça os exercícios iniciais da Lista de Exercícios 1.
→ Procure revisar os seus algoritmos em Portugol correspondentes a
estes exercícios e tente reescrevê-los em linguagem C, este é o
processo normal de escrita de um bom programa.
→ Comece escrevendo os programas no caderno, só depois passe para
o seu editor para então os compilar e executar, anotando no caderno
os possíveis erros e correções.

Entrada de Dados
→ scanf() (biblioteca stdio.h)
Sintaxe:
scanf(“Expressão”, <lista de argumentos>);
→ Permite que o usuário digite dados através do dispositivo padrão

de entrada (teclado).
→ A expressão de controle contém os códigos de controle (os mesmos

da impressão) para o tipo de dado que será lido.
→ A lista de argumentos corresponde aos endereços das variáveis.
→ O nome de cada variável deverá ser precedido pelo caracter &.
Exemplos:
scanf(“%d”, &x);
scanf(“%d, %d”, &x, &y);
scanf(“%f”, &a);
scanf(“%f, %f”, &a, &b);
Dica: Antes de ler um caracter, é necessário limpar o buffer de

leitura, da seguinte forma:
fgetc(stdin); //limpar buffer

scanf(“%c”, &letra);

Exercício Resolvido: Escreva um programa que leia dois números

inteiros e dois números reais. Logo após imprima os valores lidos.
//exscanf.c
#include <stdio.h>
int main()
{ //declarações de variáveis
int a, b;
float c, d;
//leitura
printf("Informe um valor inteiro para a: ");
scanf("%d",&a);
printf("Informe um valor inteiro para b: ");
scanf("%d",&b);
printf("Informe um valor real para c: ");
scanf("%f",&c);
printf("Informe um valor real para d: ");
scanf("%f",&d);
printf("Os valores lidos foram %d, %d, %f e %f.\n", a,
b, c, d);
}
→ Transformando o código acima em somente duas linhas de leitura,

temos:
//exscanf.c
#include <stdio.h>
int main()
{ //declarações de variáveis
int a, b;
float c, d;

//leitura
printf("Informe dois inteiros: ");
scanf("%d, %d", &a, &b);
printf("Informe dois reais: ");
scanf("%f, %f", &c, &d);
printf("Os valores lidos foram %d, %d, %f e %f.\n", a,
b, c, d);
}
Operadores Aritméticos
→ +, -, *, /, %
→ / - Operador Divisão (CUIDADO):
1. inteira: int/int = int

Ex: 5 / 2 = 2
2. real: (deve conter um valor real)
float/int, int/float, float/float

Ex: 5 / 2.0 = 2.5
→ % - Operador Resto da Divisão Inteira
Casting: Conversão de Tipos

→ Para modificar o tipo de dado representado por uma variável, isto
é, para que o valor seja utilizado em um tipo diferente do qual a variável foi
inicialmente declarada.
Sintaxe: (tipo) variável
Onde: (tipo) → Tipo para o qual o valor será convertido.

Exemplo: int x = 7, y = 2;
float result = (float) x/y;
Uso do Operador Divisão

→ Quando se divide dois inteiros o resultado é um inteiro.
Exemplo: 15/2 → 7
→ Para dividir dois inteiros e obter a resposta em real:
0. Acrescente “.0” ao numerador ou ao denominador.
Exemplo: 15.0 / 2 → 7.5 ou 15 / 2.0 → 7.5
1. Ou, caso sejam variáveis inteiras, use casting:
int var1 = 15, var2 = 2;

float resultado = (float) var1/var2;
Exemplo:
#include <stdio.h>
int main()
{ int x;
printf("\nInforme um inteiro:");
scanf("%d", &x);
printf("\nsoma: %d", x + 5);
printf("\nsubtração: %d", x - 5);
printf("\nproduto: %d", x * 5);

printf("\ndiv inteira: %d", x / 5);
printf("\ndiv real (.0): %.2f", x / 5.0);
printf("\ndiv real (casting): %.2f", (float) x / 5);
printf("\nresto: %d\n\n", x % 5);
Exercícios
→ Faça os exercícios intermediários da Lista de Exercícios 1.



Operadores de Atribuição Aritmética
Para otimizar instruções de atribuição aritmética:
+= -= *= /= %=
Sintaxe:
var += expressão; //var = var + expressão;

var -= expressão;
var *= expressão;
var /= expressão;
var %= expressão;
Exemplo: Programa que lê dois números inteiros e os imprime. Logo

após modifica o primeiro valor na memória utilizando o operador aritmético
+= e imprime o novo valor.
#include <stdio.h>
int main()
{ int x, y;
printf("Informe dois números inteiros: ");
scanf("%d, %d", &x, &y);
printf("x = %d e y = %d.\n", x, y);

x += y;
printf("Após x += y, x = %d.\n", x);
}

Operadores Incrementais
→ Em programação existem instruções chamadas incremento

(adiciona uma unidade ao conteúdo da variável) e decremento (subtrai
uma unidade do conteúdo da variável):
Incremento → ++
Decremento → --
Sintaxe: var++; //var = var + 1; (sufixo)
var--; //var = var – 1; (sufixo)

++var; //var = var+1; (prefixo)
--var; //var = var-1; (prefixo)

Em expressões, atenção à precedência lateral dos operadores:
CUIDADO:
++var → prefixo (operador antes): incrementa var antes de

usar o valor na expressão.
var++ → sufixo (operador após): incrementa var após usar o

valor na expressão.
Exemplo 1:
int i = 5, x;
x = i++; //x = 5 e i = 6
x = ++i; //x = 6 e i = 6
Exemplo 2:
int a = 5, b;
b = a*(a++); //b = 25 e a = 6
Exemplo 3:
int a = 5, b;
b = a*++a; //b = 36 e a = 6
Exemplo 4:
int a = 5, b;
b = a*a++; //b = 25 e a = 6
Exercício Resolvido: Escreva um programa que leia um número

inteiro n. Calcule o valor do sucessor e do antecessor do número lido (crie
variáveis para receber o valor do sucessor e do antecessor). Imprima os
valores das variáveis criadas.
Solução:
#include <stdio.h>
int main()
{ //declaração de variável
int n, a, s;
//leitura
printf("\nEntre com um número inteiro: ");
scanf("%d", &n);
//cálculo
s = ++n; //n = n + 1
n--; //n = n – 1 (valor original de n)
a = --n; //n = n - 1
//impressões
printf("\nSucessor: %d", s);
printf("\nAntecessor: %d\n\n", a);
}
Operadores Relacionais (Comparações)
== → Igualdade
!= → Diferente
> → Maior
>= → Maior ou igual
< → Menor
<= → Menor ou igual

Operadores Lógicos
→ Possuem os mesmos significados dos operadores lógicos booleanos

(os resultados das expressões são sempre verdadeiro ou falso).
Sintaxes: AND (e): exp1 && exp2
OR (ou): exp1 || exp2
NOT (negação): !exp
→ Os operadores lógicos, na linguagem C, atuam sobre expressões de

qualquer valor.
→ Para estes operadores, em C, todo valor numérico diferente de 0

(falso) é considerado 1 (verdadeiro).
Operador Matemática Linguagem C
Conjunção (E) ^ &&
Disjunção (OU) v ||
Negação (NÃO) ¬ !
→ Para entender melhor, vamos estudar as tabelas verdade através

de exemplos.

Tabelas Verdade
Exemplo: Suponha que foram feitas duas perguntas para quatro

candidatos a uma vaga de programador.
→ Se a resposta do candidato for negativa deverá responder 0 (zero).
→ Se a resposta do candidato for positiva, deverá responder 1 (um).
1) Operador && → Será selecionado o candidato que dominar as

duas linguagens de programação:
Você conhece C? Você conhece Java? Seleção
0 0 0
0 1 0
1 0 0
1 1 1
2) Operador || → Será selecionado o candidato que dominar pelo

menos uma linguagem.
Você conhece C++? Você conhece PHP? Seleção
0 0 0
0 1 1
1 0 1
1 1 1

3) Operador ! → Negação da resposta dada:
Acredita que finalizou seus estudos? Seleção
1 0
0 1
Comando Condicional
Estrutura de seleção if...else:
Após o teste, o fluxo do algoritmo poderá seguir dois caminhos:
→ Se o teste (ou condição) for verdade, será executado o bloco de

código que se encontra após o parênteses do teste.
→ Caso contrário, se existir, será executado o bloco de código que se

encontra após o comando else.
Sintaxe: if ( condição )
{
bloco de código
}
Onde: -Condição é uma expressão lógica ou relacional;
-Bloco de código é um conjunto de instruções separadas por “;”

(ponto e vírgula);
-Chaves “{}”, no bloco de código, só serão obrigatórias se houver

mais de uma instrução a ser executada.
Exemplo:
#include <stdio.h>
int main()
{ int idade;
printf("\nQual é a sua idade? ");

scanf("%d", &idade);
if (idade >= 18)

{ //executado se condição verdadeira
printf("\n\nMaior de idade.\n\n");
printf("\n\nObrigado a votar.\n\n");
}
}

Sintaxe com senão: if ( condição )
{ //condição verdadeira
bloco de código 1
}
else{ //condição falsa
bloco de código 2
}
→ Se a condição for verdadeira, o bloco de código 1 será executado.

Caso contrário, o bloco de código 2 será executado.
Exercício Resolvido 1: Faça um programa que leia um número

inteiro e determine se o número é par ou impar.
Solução:
#include <stdio.h>
int main()
{ int n;
printf("\n\nInforme um inteiro: ");

scanf("%d", &n);
if (n%2==0){
printf("\nO número é par.\n\n");
} else {
printf("\nO número é impar.\n\n");
}
}

Exercício Resolvido 2: Escreva um programa que leia dois números

inteiros a e b. Se a for maior que b imprima o valor do produto entre eles.
Caso contrário, imprima o valor da soma entre eles.
Solução:
#include <stdio.h>
int main()
{ int a, b;
printf("\n\nInforme dois inteiros: ");

scanf("%d, %d", &a, &b);
if (a > b) {
printf("\nProduto = %d.\n", a*b);
} else {
printf("\nSoma = %d.\n", a+b);
}
}
Exercícios
→ Faça os exercícios finais da Lista de exercícios 1.



Cap1 Intro Linguagem C

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Cap1 Intro Linguagem C

Enviado por

Direitos autorais:

Formatos disponíveis

Introdução à

Prof. Dr. Adriano Caminha

Do Problema ao Programa ...................................................................... 03

© 1999 – 2020 Prof. Dr. Adriano Caminha – ICEx/UFF – Volta Redonda-RJ 2

Tabelas Verdade ...................................................................................... 17

© 1999 – 2020 Prof. Dr. Adriano Caminha – ICEx/UFF – Volta Redonda-RJ 3

1. Problema e análise → Estudo e análise do problema proposto e

2. Desenvolvimento do algoritmo → Desenvolvimento da solução

3. Edição → Codificação do algoritmo em uma linguagem de

4. Preprocessamento → As partes do código fonte são preparadas

5. Compilação → O programa fonte é compilado, erros de sintaxe

6. Linkedição → O linkeditor junta as funções de bibliotecas ao

7. Execução → O programa é carregado para a memória e a cpu o

© 1999 – 2020 Prof. Dr. Adriano Caminha – ICEx/UFF – Volta Redonda-RJ 4

• É uma linguagem de nível intermediário que utiliza recursos da

• É uma linguagem estruturada (possui recursos como funções, laços,

• C é case sensitive, ou seja, maiúsculas e minúsculas são diferentes

Um programa C é constituído de:

1. Um cabeçalho que contém definições de preprocessamento tais

2. Um bloco da função principal main();

3. Outros blocos de funções;

© 1999 – 2020 Prof. Dr. Adriano Caminha – ICEx/UFF – Volta Redonda-RJ 5

Forma Geral de um Programa em C

<tipo de retorno> main (<parâmetros>)

<tipo de retorno> nome_funcao1(<parâmetros>)

<tipo de retorno> nome_funcao2(<parâmetros>)

© 1999 – 2020 Prof. Dr. Adriano Caminha – ICEx/UFF – Volta Redonda-RJ 6

#include <stdio.h> → Usar a biblioteca padrão de entrada e saída.

main → main é o nome da função principal.

() → Parâmetros: neste caso, sem parâmetros.

{ → Início da função principal.

printf(...) → Imprime na tela a mensagem.

\n → Adiciona uma quebra de linha (nova linha).

} → Fim da função principal.

Ferramentas e Compiladores para C

Ferramenta Dev-C++ (Windows)

Exemplo: main.c (nome sugerido pela ferramenta)

© 1999 – 2020 Prof. Dr. Adriano Caminha – ICEx/UFF – Volta Redonda-RJ 7

Compilar e Executar: [F9] (tecla)

Compilador GCC – GNU C Compiler (Linux)

-Editar o programa com editor de texto simples gedit (aplicativos/

-Abra o Terminal (Ctrl+Alt+T) e use o comando “cd” do linux para ir

→ A tecla TAB ajuda a auto complementar nomes

© 1999 – 2020 Prof. Dr. Adriano Caminha – ICEx/UFF – Volta Redonda-RJ 8

-Para compilar: gcc main.c

-Para executar: ./a.out

-Para compilar mudando o nome do executável:

-Para executar: ./main.out

© 1999 – 2020 Prof. Dr. Adriano Caminha – ICEx/UFF – Volta Redonda-RJ 9

• Letras maiúsculas e minúsculas não acentuadas

• Especiais: + - * / \ = | & ! ? # % ( ) { } [ ] _ ' “ ” . , ; : < >

→ Para as strings, qualquer outro caractere é válido.

→ Podem aparecer em qualquer lugar do programa:

// Comentário de uma única linha

© 1999 – 2020 Prof. Dr. Adriano Caminha – ICEx/UFF – Volta Redonda-RJ 10

→ Informam que bibliotecas e constantes simbólicas deverão ser

#include → diz ao compilador para incluir na compilação do

Sintaxes válidas para inclusão de bibliotecas:

1. stdio.h (ler, imprimir na tela, esvaziar o buffer)

2. math.h (funções matemáticas)

3. ctype.h (funções de texto, converter para maiúsculas ou

4. stdlib.h (valor absoluto, randômicos, etc)

© 1999 – 2020 Prof. Dr. Adriano Caminha – ICEx/UFF – Volta Redonda-RJ 11

→ printf() (biblioteca stdio.h)