Introdução à Linguagem C

Prévia do material em texto

1
ª
A
u
l
a
–
L
i
n
g
u
a
g
e
m
C
Representação de Algoritmos
Maiores níveis de detalhamento
¾ Pseúdocódigo :Æ
¾ Programas (Linguagem C):Æ Vamos começar???
¾ Outras :Æ . . .
¾ Fluxogramas:Æ
¾ Descrição Narrativa:Æ 9
9
9
1
ª
A
u
l
a
–
L
i
n
g
u
a
g
e
m
C
Símbolos Básicos
Linguagem C
(case sensitive)
- Palavras reservadas
- Operadores
- Especiais
Æ Pré-definidos
Æ Identificadores (criados pelo usuário)
ÆPré-Definidos (existentes na linguagem e com propósito bem definido):
Palavras reservadas (letras minúsculas)
Operadores (atribuição, aritméticos, relacionais, boleanos, bit-bit, …)
Especiais (delimitadores, pontuação, …)
ÆIdentificadores (criados pelo usuário (programador) para identificar constantes, macros 
parametrizadas, variáveis e funções). São compostos por letras (‘a’ .. ‘z’, ‘A’ .. ‘Z’), dígitos
(0 .. 9) e o caractere de sublinha (‘_’). O primeiro caractere não pode ser um dígito. 
Além disso, um identificador não pode ser igual a nenhum dos símbolos pré-
definidos na linguagem.
1
ª
A
u
l
a
–
L
i
n
g
u
a
g
e
m
C
Palavras Reservadas
whileunionstaticreturnifexterndochar
volatiletypedefsizeofregistergotoenumdefaultcase
voidswitchsignedlongforelsecontinuebreak
unsignedstructshortintfloatdoubleconstauto
Tabela com as 32 palavras reservadas da linguagem C (ANSI-C89).
Observações: 
ÆComo não poderia deixar de ser, palavras reservadas possuem uma semântica bem 
definida na linguagem (cada uma delas é usada em contextos específicos).
Æ Palavras reservadas da linguagem C são escritas sempre em minúsculas.
1
ª
A
u
l
a
–
L
i
n
g
u
a
g
e
m
C
Classificação dos Operadores
! && ||lógicos :
<< >> & | ^ ~bitwise :
(bit a bit)
= += -= *= /= %= atribuição :
< > <= >= = = !=relacionais :
* / % + - - (unário)aritméticos :
( ) [ ] -> . ?: * & ++ -- sizeof (tipo)especiais :
OperadoresCategoria
Observações: 
Æ Uma característica da Linguagem C é o seu rico conjunto de operadores;
Æ Muitos dos operadores acima serão explorados somente no segundo semestre;
Æ Uma outra característica da Linguagem C é o seu alto poder de expressão, ou
seja, é capaz de “dizer” muito, com poucos símbolos;
1
ª
A
u
l
a
–
L
i
n
g
u
a
g
e
m
C
Operadores Relacionais
igual==
diferente!=
DescriçãoSímbolos
maior>
menor<
maior ou igual>=
menor ou igual <=
Observação: 
Æ Muita atenção em relação ao símbolo do operador de igualdade, que na
Linguagem C é representado por um duplo sinal de igual;
1
ª
A
u
l
a
–
L
i
n
g
u
a
g
e
m
C
Operadores Boleanos/Lógicos
DescriçãoOperadores
conjunção&&
disjunção||
negação!
Exemplos de Expressões Boleanas em C:
(2*sin(3.141565) – 13+(b/c)*c ) > ( (a+b)*sqrt(c*d) )
( a <= 12.7 ) && ( b >= (c*d) )
( sqrt(a) <= 12.7 ) || ( ( b >= d ) || (a == c) ) 
( (b%2 == 0) || ( b >= d ) ) && ( a/b != 3 ) || (! (a > 7) ) 
( (ano % 400 == 0) || ((ano % 4 == 0) && (ano % 100 != 0))
Observem os diferentes tipos de operadores e de operandos existentes numa expressão boleana.
1
ª
A
u
l
a
–
L
i
n
g
u
a
g
e
m
C
Operadores de Atribuição
Operador de atribuição padrão (clássico):Æ Símbolo de igualdade: ‘=’
variável = expressão; Resolve a expressão (lado direito) e atribui o valor obtido a variável (lado esquerdo)
Entretanto, há situações em que a variável que está “recebendo” o valor (lado esquerdo), está
também envolvida no cálculo da expressão (lado direito), em situações do tipo:
variavel = variavel op expressão;
Onde op é uma operação aritmética ou bit-a-bit. Nesse caso, uma outra forma de escrever o 
comando acima é:
variavel op= expressão; 
Razão pela qual, os operadores +=, -=, *=, /=, %= e outros, também são considerados de 
atribuição. Com o tempo e a prática (que resulta em experiências acumuladas), todos irão 
incorporar essas idéias.
1
ª
A
u
l
a
–
L
i
n
g
u
a
g
e
m
C
Semântica de Alguns Operadores
divisão de a por b (produz resultados diferentes 
quando os operandos inteiros e reais)
a/b/
adição de a mais ba+b+
multiplicação de a por ba*b*
tamanho em bytes do objeto vcsizeof(vc)sizeof
endereço do objeto vc&vc&
vc é um apontador para um objeto*vc*
vc é convertido para o tipo de dado (cast - molde) ( tipo de dado ) vc( )
decrementa o valor de vc e depois usa vc
usa o valor de vc e depois decrementa vc
--vc
vc--
--
incrementa o valor de vc e depois usa vc
usa o valor de vc e depois incrementa vc
++vc
vc++
++
SignificadoExemploOperador
Observe que os operadores de incremento e decremento unitário podem ser 
usados de forma pré-fixada e pós-fixada, com resultados diferentes. Vamos
explorar estes recursos de forma intensa ao longo das disciplinas.
1
ª
A
u
l
a
–
L
i
n
g
u
a
g
e
m
C
resto da divisão inteira de a por b (a módulo b )a%b%
subtração de a por ba-b -
b, se a é verdade, senão c (operador ternário)a?b:c?:
vc = vc / avc /= a/=
vc = vc % avc %= a%=
vc = vc * avc *= a*=
vc = vc – avc - = a-=
vc = vc + avc += a+=
atribui o valor de a para vc (comando de atribuição)vc = a=
SignificadoExemploOperador
Semântica de Alguns Operadores
1
ª
A
u
l
a
–
L
i
n
g
u
a
g
e
m
C
Tabela dos Operadores em Ordem (decrescente) de Prioridade
direita para a esquerda= += -= *= /= %= &= ^= |= <<= >>=
direita para a esquerda?:
esquerda para a direita||
esquerda para a direita&&
esquerda para a direita|
esquerda para a direita&
esquerda para a direita== !=
esquerda para a direita< <= > >=
esquerda para a direita<< >>
esquerda para a direita+ -
esquerda para a direita* / %
direita para a esquerda! ~ ++ -- + - * & (tipo) sizeof
esquerda para a direita( ) [ ] −> . 
AssociatividadeOperadores
Operadores na mesma linha possuem a mesma prioridade
1
ª
A
u
l
a
–
L
i
n
g
u
a
g
e
m
C
Operador de Divisão
Em C, o operador de divisão ‘/’ é sobrecarregado. Isso significa que o resultado da 
divisão depende dos operandos serem reais ou inteiros.
ÆSe ambos os operandos forem inteiros o resultado será a parte inteira da 
divisão (o resto é ignorado);
ÆSe um dos operandos (numerador ou denominador) for real, o resultado 
sera a divisão real;
Observação: O mesmo acontece quando os operandos são variáveis 
associadas aos tipos de dados inteiros (int) ou real (float ou
double).
Exemplo: Se o valor das variáveis a, b e c, são, respectivamente, 5, 3 e 
1.0. Então, temos que:
a/b = 1 e a/c = 5.0
Exemplos: 5/2 = 2; 5/2.0 = 2.5; 5.0/2 = 2.5 e 5.0/2.0 = 2.5
1
ª
A
u
l
a
–
L
i
n
g
u
a
g
e
m
C
Variáveis
O conceito de variáveis é fundamental em diferentes classes de linguagens de 
programação. Elas são utilizadas para representar quantidades que se alteram ao
longo da execução de um programa e possuem uma série de atributos
(propriedades) que vamos explorar ao longo do ano, entre eles, podemos destacar
os seguintes: 
Atributos
Nome (identificador)
Tipo de dado
Escopo (alcance)
Classe de armazenamento (auto, static, register, extern, volatile)
Estáticas ou Dinâmicas
Possui um endereço de memória (posição de memória)
1
ª
A
u
l
a
–
L
i
n
g
u
a
g
e
m
C
Exemplos de Identificadores (para variáveis)
Válidos
Maior maior
maio MaiOR
Volume _esfera MAIOR
Abc abc
a1 a2
a3 a4 
max min
Pontocom fors
Inválidos
3Maior maior-valor
abc* extern
max 12 case
ponto.com for´s
(maior)
...
Lembre-se que a Linguagem C é case-sensitive, ou seja, letras maiúsculas diferem
das letras minúsculas.
1
ª
A
u
l
a
–
L
i
n
g
u
a
g
e
mC
Tipos de Dados Primitivos
Tipos de Dados definem quais são os valores possíveis que uma variável pode
assumir ao longo da execução do programa.
void
char
int
float
double
Tipos de 
Dados
……Æ Tipo de dados vazio (vamos explorar mais a frente)
……Æ Caractere
……ÆNúmero inteiro
……Æ Número real não muito grande
……Æ Número real muito grande
1
ª
A
u
l
a
–
L
i
n
g
u
a
g
e
m
C
Modificadores de Tipos
Além dos tipos de dados primitivos, a linguagem C disponibiliza alguns
modificadores de tipo, que são capazes de alterar os tipos de dados redefinindo os
valores passíveis de serem representados por uma variável daquele tipo, ou seja, o 
seu domínio de valores. Alteram também a precisão, em particular do tipo double.
Modificadores
de Tipos
short (int)
signed (char, int)
unsigned (char, int)
long (int, double)
Os tipos de dados em conjugação com os modificadores de tipo, permitem um 
melhor uso da memória e consequentemente, de seu gerenciamento. 
É possível aplicar simultaneamente mais de modificador de tipo sobre um tipo de 
dados.
1
ª
A
u
l
a
–
L
i
n
g
u
a
g
e
m
C
Limites (mínimos) Associados aos Tipos de Dados (ANSI C89)
long double3.4e-4932 .. 1.1e+493210/80real longo (18 dígitos )
double1.7e-308 .. 1,7e+3088/64real ( precisão dupla – 15 dígitos )
float3.4e-38 .. 3.4e+384/32real ( precisão simples - 6dígitos )
unsigned long int0 .. 4.294.967.2954/32inteiro longo sem sinal
long int-2.147.483.648 .. 2.147.483.647 4/32inteiro longo 
unsigned int0 .. 655352/16 inteiro sem sinal
int-32768 .. 327672/16 inteiro 
short int -32768 .. 327672/16 inteiro pequeno
unsigned char0 .. 2551/8caractere sem sinal
char-128 .. 1271/8 caractere
PALAVRA 
RESERVADA
INTERVALO DE VALORESTAMANHO
( bytes/bits )
TIPOS DE DADOS 
Atenção!!! A tabela acima mostra algumas combinações possíveis e deve ser usada como
referência. Compiladores diferentes em arquiteturas diferentes, em geral, possuem limites
diferentes. Quais os limites do IDE DevC++?
1
ª
A
u
l
a
–
L
i
n
g
u
a
g
e
m
C
Tipos de Dados Inteiros em Alguns Sistemas
8888char
16323232int
16161616short
64646464long long
32323232long
ANSI C-89 
(mínimo)
Windows 
98/NT
Linux (PC)Macintosh
TIPO
Tamanhos em bits
(em geral)
1
ª
A
u
l
a
–
L
i
n
g
u
a
g
e
m
C
Precisão de Dados Reais para Alguns Sistemas
6
-37Æ38
6
-37Æ38
6
-37Æ38
6
-37Æ38float
10
-37Æ38
15
-307Æ308
15
-307Æ308
18
-4931Æ4932double
10
-37Æ38
18
-4931Æ4932
18
-4931Æ4932
18
-4931Æ4932long double
ANSI C-89 
(mínimo)
Windows 
98/NT
Linux (PC)Macintosh
TIPO
Tamanhos em dígitos decimais (em geral)
A segunda linha em cada coluna representa o expoente do domínio de 
variação do tipo de dado em base 10.
0 65535
unsigned int 
]
-32768 0 32767
int ]
Modificadores Aplicados aos Tipos de Dados
Exemplos:
1
ª
A
u
l
a
–
L
i
n
g
u
a
g
e
m
C
Modificadores Aplicados aos Tipos de Dados
Exemplos:
long int
]
- 2147483648 0 2147483647
unsigned long int
]
0 4294967295
O importante aqui é que você consiga entender quais os efeitos da aplicação 
de um modificador sobre um tipo de dado primitivo. 
1
ª
A
u
l
a
–
L
i
n
g
u
a
g
e
m
C
Estrutura Geral de um Programa em C
Diretivas de pré-processamento // inclusão de arquivos, declaração de constantes e macros parametrizadas, 
Declarações de estruturas. variáveis globais e 
definições de tipos
/* declaração de estruturas e variáveis Globais, ... */
/* declaração da função F1 */Tipo_dado Identificador_F1( lista de parâmetros formais) {
instruções associadas a essa função
} 
/* declaração da função Fn */Tipo_dado Identificador_Fn( lista de parâmetros formais) {
instruções associadas a essa função
} 
Tipo_dado main (parâmetros passados pelo SO) {
instruções relativas a função main
} 
// A poderosa função main
...
1
ª
A
u
l
a
–
L
i
n
g
u
a
g
e
m
C
Estrutura Geral de um Programa em C
Observações: Æ
Æ Um programa em C, é formado por um conjunto (pelo menos uma) de funções;
Æ A função main() sempre deverá estar presente. Quando o SO inicia a execução 
do programa, ela é a primeira função a ser executada. É onde todo o processo se 
inicia;
Æ Nesta fase inicial, todos os nossos programas terão apenas uma função, que será
exatamente a função main(); 
Æ No início do segundo semestre, vamos aprender como criar nossas próprias 
funções (códigos com propósitos bem específicos) e integrá-las num único 
programa; 
Æ Até o final do ano, nossa expectativa é dominar técnicas de programação e 
metodologias de desenvolvimento (básicas) que vão nos permitir elaborar um Projeto 
Final (programa), da ordem de 2000 - 3000 linhas; 
1
ª
A
u
l
a
–
L
i
n
g
u
a
g
e
m
C
Exemplo de um Programa em C
/*******************************************************************/
/* Programa para calcular a área da superfície e o volume */
/* de uma esfera de raio arbitrário. */
/*******************************************************************/
#include <stdio.h> /* funções ENTRADA/SAÍDA */
#define PI 3.141592654 /* declaração da constante π */
#define SQR(x) ((x)*(x)) /* definição da macro parametrizada SQR */
#define MSG1 “AREA DA SUPERFÍCIE e VOLUME de uma esfera”
#define MSG2 “Introduza o raio da esfera : ”
float raio, // variável para armazenar o raio 
area_sup_esf, // variável para armazenar a área da superfície 
vol_esf; // variável para armazenar o volume da superfície 
int main(void) { // todo programa em C, deve possuir uma função main() 
printf(“\n”, MSG1);
printf(“\n\n\n”, MSG2); // mensagem para o usuário 
scanf(“%f”, &raio); // leitura do valor introduzido pelo teclado 
area_sup_esf = 4*PI*SQR(raio); /* Cálculo da área da superfície */
vol_esf = area_sup_esf*raio/3.0; /* Cálculo do volume da esfera */
printf(“\n\n\n\ R E S U L T A D O S O B T I D O S ”);
printf(“ RAIO = %10.6f ”, raio);
printf(“ VOLUME DA ESFERA = %10.6f ”, vol_esf);
printf(“AREA_DA_SUPERFÍCIE_DA_ESFERA = %10.6f ”,area_sup_esf); 
system(“Pause”); /* artifício para manter a janela de introdução dos dados visível */
return(0);
} // final da função main() 
1
ª
A
u
l
a
–
L
i
n
g
u
a
g
e
m
C
PROCESSO DE COMPILAÇÃO DE UM PROGRAMA EM C
Editor de Textos
(programa_fonte.c)
Erros de 
SintaxePré-Processador
Compilador C
Código Objeto
(programa_fonte.obj
Linker
Funções pré-
definidas 
(biblioteca-Padrão)
Funções pré-
definidas em outras 
bibliotecas
1
ª
A
u
l
a
–
L
i
n
g
u
a
g
e
m
C
PROCESSO DE COMPILAÇÃO DE UM PROGRAMA EM C
programa executavél
( programa_fonte.exe )
Execução do programa 
programa_fonte.exe
Entrada e 
Saída de 
Dados
Erro em tempo 
de execução
1
ª
A
u
l
a
–
L
i
n
g
u
a
g
e
m
C
Comando de Saídas Formatadas
1
ª
A
u
l
a
–
L
i
n
g
u
a
g
e
m
C
O comando printf(.) é comando utilizado para apresentar os dados de 
seu programa para o mundo exterior através dos dispositivos físicos de 
saída (Tela do monitor, impressoras, discos, etc.). É o comando de saída 
formatada mais geral existente no cabeçalho <stdio.h>.
FORMA GERAL:Æ
printf(“String_de_Controle”, Lista_de_Itens);
onde:
String_de_Controle: diz como os dados devem ser exibidos 
(qual o seu formato). Observe que a string de controle
vem sempre entre “aspas”;
Lista_de_itens: pode ser constantes, variáveis, funções 
primitivas e/ou expressões aritméticas, separadas por vírgulas;
Comando de Saída printf()
1
ª
A
u
l
a
–L
i
n
g
u
a
g
e
m
C
Uma String_de_Controle pode conter:
ƒ Textos a serem impressos;
ƒ Caracteres de Controle/escape (começam sempre com barra invertida):
Exemplos:
\n : caractere de mudança de linha;
\t : caractere de tabulação e outros (ver tabela dos próximos slides)
ƒ Especificadores de Formato (começam sempre com sinal de porcentagem):
Exemplos:
%f :Æ número real em formato decimal (123.54312)
%e :Æ número real em formato exponencial (1.23e+002)
%d :Æ números inteiros (-12354, 6543)
%s :Æ cadeia de caracteres (“Eu Adoro Programação”)
e muitos outros (ver tabela dos próximos slides).
Caracteres especiais são sempre precedidos pelo caractere de barra invertida ‘\’ e 
usados em conjunção com a função de saída formatada printf () .
Alimentação de folha (form feed-FF)\f
Ponto de interrogação\?
Retorno de carro (carriage return - CR)\r
Sinal de alerta (beep)\aBackspace (retrocesso - BS)\b
Aspas duplas (double quote)\”Tabulação vertical - VT\v
Apóstrofe (single quote)\’Tabulação horizontal - HT\t
Barra invertida (backslash)\\Nova linha (newline - LF)\n
Caracteres Especiais Pré-definidos
1
ª
A
u
l
a
–
L
i
n
g
u
a
g
e
m
C
Número inteiro longo%ld
Número real do tipo double e long double%lf
Cadeia de caracteres (string)%s
Número inteiro no sistema de numeração hexadecimal%x
Número inteiro no sistema de numeração octal%o
Apontador%p
Número real (formato exponencial)%e
Número real (formato decimal)%f
Número inteiro decimal (não sinalizado)%u
Número inteiro decimal%i
Número inteiro decimal%d
Caractere%c
Tipo de dadoCaractere de conversão
Especificadores de Formato (Entrada/Saída)
Especificadores de Formato são sempre precedidos pelo caractere de porcentagem ‘%’ .
1
ª
A
u
l
a
–
L
i
n
g
u
a
g
e
m
C
1
ª
A
u
l
a
–
L
i
n
g
u
a
g
e
m
C
printf ( “ %d %5d %f %12.7f ” , 5, a, sin(a), a*sqrt(b) );
Exemplo Básico: Æ
formatação Itens a serem impressos
?
Comando de Saída printf()
Observação: 
Æ O número de especificadores de formatos na String_de_ Controle, deve ser igual 
ao número de itens, na Lista_de_Itens;
Æ A associação é feita exatamente na ordem em que eles aparecem em ambas as listas
1
ª
A
u
l
a
–
L
i
n
g
u
a
g
e
m
C
Especificadores de Formato (Números reais)
FORMA GERAL:Æ
%-m.nf
Modificador (opcional):
- : alinhamento a esquerda
+ : imprime o sinal
0 :(zero) preenche os campos 
não usados (esquerda com 
zeros)
m: Especifica a largura 
do campo onde o 
número será impresso.
n: especifica a precisão (número 
de dígitos significativos). No caso 
de números reais.
Descritor de formato (obrigatório): Æ
Pode ser f, e, lf, ...
ExemploÆ %-15.7f
1
ª
A
u
l
a
–
L
i
n
g
u
a
g
e
m
C
Especificadores de Formato
Exemplo 03:
printf(“%f\n”, PI);
printf(“%e\n”, PI);
printf(“%15.8f\n”, PI);
printf(“%15.3f\n”, PI);
printf(“%13.4e\n”, PI);
printf(“%15.9e\n”, PI);
printf(“%+15.8f\n”, PI);
printf(“%025.3f\n”, PI);
Faça um programa em C para verificar os resultados associados a 
saída. Não esqueça de usar a diretiva define para criar a 
constante simbólica PI. 
1
ª
A
u
l
a
–
L
i
n
g
u
a
g
e
m
C
Especificadores de Formato (Números inteiros)
FORMA GERAL:Æ
%-md
Modificador (opcional):
- : alinhamento a esquerda
+ : imprime o sinal
0 :(zero) preenche os campos 
não usados (esquerda com 
zeros)
m: Especifica a largura 
do campo onde o 
número será impresso 
(opcional)
Descritor de formato (obrigatório): Æ
Pode ser d, u, ld, ...
ExemploÆ %-15d
1
ª
A
u
l
a
–
L
i
n
g
u
a
g
e
m
C
Especificadores de Formato
Exemplo 01:
a = 2;
printf(“%d”,a);
printf(“%-3d”,a);
printf(“%5d”,a);
printf(“%05d”,a);
Produz uma saída semelhante a: 
_ _ _ _ _ _ _ _ _ 1 2 3 4 5 6 7 8 9
2
2
2
0 0 0 0 2
Caracteres da esquerda para a direita no dispositivo de saída.
Explorar alguns exemplos em C.