int - Prof. Ms. Claudio Benossi

Algoritmos e Estruturas de Dados
Linguagem C
- Conceitos Básicos -
Prof. Me. Claudio Benossi
[email protected]
Histórico
 A linguagem C é uma linguagem de programação
genérica inventada na década de 1970 por Dennis
Ritchie.
 O ANSI (American National Standard Institute)
padronizou a versão ANSI-C
http://en.wikipedia.org/wiki/C_programming_language
C é uma linguagem de médio nível
Alto nível
Ada
Pascal
Cobol
Fortran
Basic
Médio nível
C++
C
Baixo nível
Assembly
Por que estudar C?
 Versatilidade: ele possui tanto características de "alto
nível" quanto de "baixo nível".
 Poder: possui ampla biblioteca de funções e é utilizado
na construção de “software” para os mais diversos
projetos.
 Portabilidade: é possível adaptar um programa em C de
um tipo de computador para outro.
Primeiros passos
 Um programa em C consiste de várias funções
encadeadas.
 Uma função é um bloco de código de programa que
pode ser usado diversas vezes em sua execução.
 Blocos de código são delimitados por chaves: {}
 O uso de funções permite que o programa fique mais
legível, mais estruturado.
O C é “Case Sensitive”
Caracteres maiúsculos e minúsculos fazem
diferença:
Soma ≠ soma ≠ SOMA ≠ SomA
Comandos do C (if ou for, por exemplo) só
podem ser escritos em minúsculas, pois senão o
compilador interpretará como variáveis.
Estrutura Geral
tipo_de_retorno main()
{
comandos
return valor;
}
Exemplo:
int main()
{
int x, y;
x = x + y;
return 0;
}
A função main()
Todo programa deve ter uma única função
main.
A função main é o ponto de partida quando o
programa é executado.
Arquivos auxiliares não devem conter a função
main.
Bibliotecas
 Programas que possuem a especificação das funções
pré-definidas da linguagem.
 As bibliotecas que serão usadas devem ser os primeiros
comandos de um programa em C.
#include <nome_da_biblioteca.h>
int main()
{
<açoes>
return 0;
}
1
Bibliotecas
Programas que possuem a especificação das
funções pré-definidas da linguagem.
As bibliotecas que serão usadas devem ser os
primeiros comandos de um programa em C.
#include <nome_da_biblioteca.h>
int main()
{
<açoes>
return 0;
}
1
Bibliotecas
:: Exemplos
stdio.h: biblioteca de funções de entrada e
saída (leitura e escrita de dados).
math.h: biblioteca de funções matemáticas
(potenciação, raiz quadrada, funções
trigonométricas, etc.).
string.h: biblioteca de funções para
manipulação de conjunto de caracteres (por
exemplo, palavras).
Comentários
Comentários em C podem ser escritos em
qualquer lugar do texto para facilitar a
interpretação do algoritmo.
Tipos de comentários:
 Delimitados por /* e */.
 Todo o texto delimitado é considerado pelo compilador como
um comentário.
 Colocando // em uma linha.
 Tudo que estiver à direita do símbolo é considerado como
um comentário.
1
Variáveis
Devem ser declaradas antes de serem usadas,
no início de um bloco de código.
Forma geral da declaração de variáveis:
tipo_da_variável lista_de_variáveis;
Exemplo:
char
float
int
letra;
temperatura, pressao;
dia, mes, ano;
Variáveis
Variáveis são armazenadas na
memória do computador.
Endereço
0000
0001
0002
0003
0004
0005
...
FFFF
Conteúdo
Tipos de dados
A linguagem C tem 5 tipos básicos:
 char
– caractere ASCII
 int
– número inteiro
 float
– número real de precisão simples
 void
– sem valor
 double – número real de precisão dupla
Tipos de dados
:: Modificadores
Um modificador de tipo altera o intervalo de
valores que uma variável pode armazenar ou
como o compilador representa um valor.
Existem quatro modificadores de tipo:
 signed
 unsigned
 long
 short
Tipos de dados
:: Modificadores
Ao tipo float não se pode aplicar nenhum
modificador.
Ao tipo double pode-se aplicar apenas o
modificador long.
Os quatro modificadores podem ser aplicados a
inteiros (int).
O modificador unsigned serve para especificar
variáveis sem sinal, instruindo o compilador a
não considerar o primeiro bit como sinal.
Tipos de dados
:: Modificadores
O número de bits do tipo int normalmente
corresponde ao tamanho da palavra de uma
determinada arquitetura de computador.
Dependendo do compilador, os modificadores
short e long alteram a quantidade de bits
reservados para representar números inteiros:
 short int: reserva mais bits que o tipo int
 long int: reserva menos bits que o tipo int
Cada compilador é livre para escolher tamanhos
adequados para o seu próprio hardware.
Tipos de dados
:: Resumo (compilador gcc)
Tipo
Tamanho em
bits
char
8
-128 a 127
unsigned char
8
0 a 255
signed char
8
-128 a 127
32
-2.147.483.647 a 2.147.483.647
unsigned int
32
0 a 4.294.967.295
signed int
32
-2.147.483.647 a 2.147.483.647
short int
16
-32.767 a 32.767
unsigned short int
16
0 a 65.535
signed short int
16
-32.767 a 32.767
32
-2.147.483.647 a 2.147.483.647
unsigned long int
32
0 a 4.294.967.295
signed long int
32
-2.147.483.647 a 2.147.483.647
float
32
seis dígitos de precisão
double
64
dez dígitos de precisão
80
dez dígitos de precisão
int
long int
long double
Faixa de números
representados
2
Identificadores
São os nomes que damos aos objetos utilizados
(variáveis, constantes, funções, etc.)
 Podem ter qualquer nome, desde que:
 Comece com uma letra ou sublinhado (underscore) _
 Os caracteres subseqüentes devem ser letras,
números ou _.
 Não seja igual a:
 uma palavra reservada,
 uma função declarada
 bibliotecas do C.
Identificadores
:: Exemplos
Não permitido!
Permitido
int
int
float
char
_mes
ano_atual
temp1
palavra_digitada
char
int
float
int
char
2a_feira
valores$
float
main
stdio
3
Constantes
Constantes são valores fixos que não podem ser
modificados em nenhuma parte do programa.
Sua definição não usa ponto-e-vírgula, nem
sinal de igualdade.
#define <identificador> <valor>
Exemplos:
#define
#define
#define
PI
ANO
LETRA
3.1415
2007
' A'
Constantes
Costuma-se definir o nome das constantes com
letras maiúsculas, para diferenciá-los de nomes
de variáveis e funções.
Essa prática melhora a legibilidade do
programa.
Definição de constantes facilita a manutenção
do programa.
4
Operador de Atribuição
Uma variável, ao ser definida, contém um valor
qualquer e imprevisível. Costuma-se dizer que
contém lixo de memória.
O comando de atribuição (=) permite alterar o
valor (conteúdo) de uma variável.
<variável> = <valor>;
Operador de Atribuição
Exemplos:
atribuição de valor
letra
=
'H';
ano
=
2007;
temperatura
=
38.9;
nova_letra
=
letra;
float cateto
=
3.1;
definição e atribuição
area_ret
=
base * altura;
atribuição de fórmula
atribuição de uma
variável a outra
Caractere × String de caracteres
Quando uma variável possui apenas um
caractere, ele ocupa apenas uma posição de
memória:
char letra = 'A';
A
Variável
0100 0001
Memória
Caractere × String de caracteres
 Uma string de n caracteres ocupa n+1 posições de
memória.
 A posição adicional corresponde ao valor zero (\NULL
em ASCII), indicativo do final da string.
char nome[] = "ABC";
A
B
C
0100
0100
0100
0000
0001
0010
0011
0000
n caracteres
Variável
Memória
n+1
posições
Operadores
 Aritméticos
 Bit a bit
 Relacionais
 Lógicos
Operadores Aritméticos
Operador
Ação
Exemplo
+
Adição
x = 0x1A + y;
-
Subtração
x = x – y;
*
Multiplicação
x = 8 * y;
/
Divisão
x = y / 2;
%
Resto de divisão
x = y % 2;
++
Incremento
x++;
--
Decremento
y--;
Operadores Aritméticos
Diversos operadores podem ser utilizados em
uma mesma expressão:
area
delta
= 2 * PI * raio;
= b*b – 4*a*c;
A ordem de execução dos operadores pode ser
determinada explicitamente pelo uso de
parênteses:
media
delta
= (a + b + c)/2;
= (b*b) – (4*a*c);
Operadores Aritméticos
Quando não há parênteses, o compilador usa
regras de precedência para determinar qual
operação executar primeiro
Maior precedência
- (unário)
* / %
+ Menor precedência
Se duas operações têm a mesma precedência,
segue-se a ordem da esquerda para a direita.
5
Operadores Aritméticos
:: Incremento e decremento
O operador incremento de 1 (++) realiza duas
operações:
 Soma 1 ao valor atual da variável
 Armazena o resultado na própria variável
 Em vez de x = x + 1; , escreve-se x++;
De forma semelhante funciona o operador
decremento de 1 (--).
 Em vez de x = x - 1; , escreve-se x--;
Operadores Aritméticos
:: Incremento e decremento
Os operadores ++ e -- podem ser usados como:
 Prefixos:
antes da variável:
++x
 Sufixos:
após a variável:
x++
Se a operação aparece isolada, ambas notações
são equivalentes:
int n = 6, m =
n++;
/*
++m;
/*
n--;
/*
--m;
/*
3;
resultado:
resultado:
resultado:
resultado:
n
m
n
m
=
=
=
=
7
4
6
3
*/
*/
*/
*/
6
Operadores Aritméticos
:: Incremento e decremento
 Se a operação é parte de uma expressão:
 Prefixo: Valor usado na expressão é o valor
incrementado/decrementado.
 Sufixo: Operação incremento/decremento será realizada depois
que o valor for usado na expressão.
int n = 0, m = 0, a, b, c, d;
n++;
/* resultado: n = 1
++m;
/* resultado: m = 1
n--; --n;
/* resultado: n = -1
a = n++;
/* resultado: a = -1;
b = ++m;
/* resultado: b = 2;
c = 2*(m++); /* resultado: c = 4;
d = 3*(++n); /* resultado: d = 3;
n
m
m
n
*/
*/
*/
=0 */
= 2 */
= 3 */
= 1 */
7
Operadores bit a bit
 Atuam sobre os bits
individuais de uma
variável.
 Não enxergam as
variáveis com um valor
único, mas sim como um
conjunto de bits.
Operador
Ação
&
AND
|
OR
^
XOR (OR exclusivo)
~
NOT
>>
Deslocamento de bits
à direita
<<
Deslocamento de bits
à esquerda
8
Operações combinadas com atribuição
 Uma operação pode ser
combinada com a
atribuição em um
mesmo operador.
 Embora sejam mais
eficientes, tornam o
programa mais difícil de
se compreendido.
Forma normal
Forma
combinada
x=x+5
x += 5
x=x-a
x -= a
x=x*k
x *= k
x = x / (x+1)
x /= x+1
x=x&k
x &= k
x = x << k
x <<= k
...
...
9
Operadores Relacionais
 Compara dois valores,
produzindo um resultado
lógico:
 FALSO é indicado pelo
valor zero.
 VERDADEIRO é indicado
por um valor ≠ zero.
Operador
Ação
>
Maior do que
>=
Maior ou igual a
<
Menor do que
<=
Menor ou igual a
==
Igual a
!=
Diferente de
Operadores Relacionais
:: Exemplos
int
cond;
int
a = 3;
float x = 1.5;
cond
cond
cond
cond
cond
cond
cond
cond
cond
=
=
=
=
=
=
=
=
=
a
!=
a/2.0 ==
a/2
==
a
!=
a
>=
a/3
<=
a/2
>
a;
a – 2*x;
x;
x;
x;
2*x;
x;
x;
2;
/*
/*
/*
/*
/*
/*
/*
/*
/*
cond=1
cond=1
cond=0
cond=0
cond=1
cond=1
cond=0
cond=3
cond=0
->
->
->
->
->
->
->
->
->
V
V
F
F
V
V
F
V
F
*/
*/
*/
*/
*/
*/
*/
*/
*/
10
Operadores Lógicos
 Operam sobre os valores
lógicos das variáveis, sem
considerar seu bits
individuais.
Operador
Ação
&&
AND (E)
||
OR (OU)
!
NOT (NÃO)
 Não confundir com
operadores bit a bit.
Operadores Lógicos
:: Exemplos
int
cond;
int
a = 3;
float x = 1.5;
cond
cond
cond
cond
cond
cond
cond
=
=
=
=
=
=
=
(a/2 == x) && (a > 2);
(a != x) || (a/x < 2);
(x <= a) && (a >= 2*x);
!(a/3 <= x);
(a/2==x) || (a>=x) && !(2*x!=a);
a && x;
(a - 2*x) || (x < a/2);
/*
/*
/*
/*
/*
/*
/*
cond=0
cond=1
cond=1
cond=0
cond=1
cond=1
cond=0
->
->
->
->
->
->
->
F
V
V
F
V
V
F
*/
*/
*/
*/
*/
*/
*/
11
Precedência entre operadores
++
--
-
Menos Unário
!
Negação
*
>
Módulo (resto da divisão inteira)
=
Subtração, adição
-
>=
<=
==
Maior precedência
Multiplicação, divisão
/
%
+
Pré/pós incremento, decremento
<
!=
Relacionais
Igual, diferente
&&
E lógico
||
OU lógico
+= -=
*= /=
Atribuição
Menor precedência
Comandos de Entrada e Saída
Estão descritos na biblioteca stdio.h
Comandos de Saída:
 Função printf()
 Função putchar()
Comandos de Entrada:
 Função scanf()
 Função gets()
 Função getchar()
Comandos de Saída
:: printf()
Função para a escrita formatada no dispositivo
de saída padrão, normalmente o vídeo.
printf (string_de_controle, argumentos);
Comandos de Saída
:: printf()
 string_de_controle consiste em:
 Caracteres que serão exibidos na tela
 Caracteres de controle (\)
 Comandos de formato, que definem a maneira como
os argumentos serão mostrados (%)
 argumentos são as variáveis cujos conteúdos
serão exibidos na tela.
Comandos de Saída
:: printf()
Caracteres de controle imprimem caracteres
especiais na saída:
 \n
– nova linha
 \t
– tabulação horizontal
 \\
– a própria contra-barra
 \b
– backspace
 \"
– aspas
 \'
– apóstrofe
 \xnnn
– código hexadecimal do caractere ASCII
 \a
– alerta sonoro
Comandos de Saída
:: printf()
 Comandos de formato disponíveis (começam por %):
 %d (%i)– números inteiros em decimal
 %f
– números reais do tipo float
 %lf
– números reais do tipo double
 %e (%E)– números reais em notação científica
 %c
– caractere
 %s
– seqüência de caracteres (string)
 %x (%X)– números em hexadecimal (base 16)
 %o
– números em octal (base 8)
 %%
– o próprio caractere %
 %p
– endereços de memória (em hexadecimal)
12
Comandos de Saída
:: printf()
 Comandos de formato podem ser alterados para
especificação da largura mínima de campo ou do
número de casas decimais:
%[alinhamento][tamanho][.][precisão]formato
Especifica número de casas
decimais a serem impressas.
Especifica número de caracteres
a serem impressos, incluindo o
sinal e o ponto decimal.
0: completa com zeros à esquerda
para atingir o tamanho especificado
-: força alinhamento à esquerda
13
Comandos de Saída
:: printf()
 Outros comandos de alinhamento:
 + - imprime o sinal de + mesmo quando o número é positivo
 #x ou #X – imprime 0x ou 0X à esquerda do número hexa
 #f, #e ou #E – imprime o ponto decimal, mesmo para inteiros
13a
Comandos de Saída
:: putchar()
 Escreve um caractere na tela a partir da posição atual
do cursor.
putchar (<variável>);
 O resultado do comando é a impressão do caractere
corresponde ao código ASCII do argumento.
 Argumento pode ser do tipo int ou char.
14
Comandos de Entrada
:: scanf()
 Rotina de leitura formatada de dados inseridos pelo
usuário pelo teclado.
scanf (string_de_controle, argumentos);
 string_de_controle: comandos de formato (%_),
os mesmos relacionados para o printf().
 argumentos: endereço das variáveis onde serão
colocados os valores de entrada: &nome_variável.
 O operador & representa o endereço de uma variável.
15
16
Comandos de Entrada
:: gets()
 Rotina de entrada que lê uma seqüência de caracteres
(string) até que seja pressionada a tecla ENTER.
gets(nome_da_variável);
17
Comandos de Entrada
:: getchar()
 getchar() - rotina que espera uma tecla ser
pressionada e devolve seu valor na tela.
 Deve-se pressionar ENTER depois de digitar o caractere.
nome_da_variável = getchar();
 Não fazem parte do ANSI C padrão:
 getche() - lê caractere, exibe na tela, dispensa ENTER.
 getch() - lê caractere, não exibe na tela, dispensa ENTER.
18
Modeladores (Cast)
Modeladores ou cast são aplicados a uma
expressão para converter seu resultado em um
tipo especificado.
(<tipo>) <expressão>
19
Questões
Tabela ASCII
American Standard Code for Information
Interchange (ASCII) é um conjunto de códigos
para o computador representar números, letras,
pontuação e outros caracteres.
http://pt.wikipedia.org/wiki/ASCII
Binário
Decimal
Hex
Caractere
0100 0001
65
41
A
0100 0010
68
42
B
0100 0011
67
43
C
0010 1011
43
2B
+
0011 0001
49
31
1