Laboratório de Programação
Prof. Oscar Luiz Monteiro de Farias
[email protected]
Capítulo 2
Tipos,
Operadores
e
Expressões
Variáveis, operadores e exps




Variáveis e constantes são os objetos de dados básicos
manipulados por um programa em C.
As declarações listam as variáveis a serem usadas,
definem os tipos assumidos pelas mesmas e
eventualmente estabelecem os seus valores iniciais.
Os operadores especificam as operações que devem ser
realizadas com as variáveis.
As expressões combinam variáveis e constantes, por
meio dos operadores, a fim de produzir novos valores
(que são eventualmente armazenados em variáveis).
Identificadores (1)




Os nomes de variáveis e constantes simbólicas
são compostos por letras e dígitos; o primeiro
caracter deve ser uma letra.
Não inicie identificadores com um '_', pois as
funções da biblioteca padrão normalmente usam
nomes assim.
Maiúsculas e minúsculas são distintas (x e X
representam nomes distintos)
Use minúsculas para as variáveis e maiúsculas
para as constantes simbólicas (convenção do C).
Identificadores (2)




Pelo menos os 31 primeiros caracteres de um
nome interno são significativos.
Para os nomes externos o padrão ANSI garante
que apenas os 6 primeiros caracteres são
significativos, bem como um único tipo de letra
(m ou M).
As keywords (if, else, int, for, float, etc.) não
podem ser usadas como nomes de variável.
As keywords devem ser escritas em
minúsculas.
Tipos de dados básicos (1)
char - um único byte - capaz de representar um
caracter no conjunto de caracteres local
 int - inteiro, reflete o tamanho dos inteiros no hardware
da máquina → usualmente 16bits (-32768 <= valor <=
32767) ou 32 bits
 float – ponto flutuante em precisão simples
usualmente 32 bits - com pelo menos 6 dígitos
significativos 10-38 <=valor<=10+38
 double - ponto flutuante com precisão dupla
 Os tamanhos dos objetos em ponto flutuante são
definidos pela implementação

Tipos de dados básicos (2)

Há qualificadores que podem ser aplicados aos tipos básicos
long double - ponto flutuante com precisão estendida.
short int - inteiro curto, normalmente ocupa16 bits
long int - inteiro longo, normalmente ocupa 32 bits
Ex.: short int counter;



Cada compilador é livre para escolher os tamanhos adequados
ao seu hw;
Restrições: i) short e int devem ocupar pelo menos 16 bits;
ii) short <=int <= long
Os qualificadores signed ou unsigned podem ser aplicados a
char ou a qualquer inteiro.
Tipos de dados básicos (3)


Números unsigned são sempre positivos ou zero.
Obedecem as leis da aritmética módulo 2n, onde n é o número de
bits do tipo correspondente.
ex.: unsigned char x; → 0 <= x <= 255
signed char x; → -128 <= x <= 127
(em máquinas que usam o complemento a dois)

Os arquivos headers standard <limits.h> e <float.h> contêm
constantes simbólicas para todos os tamanhos, juntamente com
soutra propriedades da máquina e do compilador.

Os arquivos headers do C estão localizados em /usr/include.

Ver o apêndice B do livro K&R.
Constantes (1)






Constante inteira → 1234
Constante long → 123456789L
Um inteiro muito grande para caber em um int
será considerado como long.
Constantes não sinalizadas são escritas com a
letra u ou U ao final
O sufixo ul ou UL indica unsigned long
Constantes de ponto flutuante contêm um ponto
decimal → 123.4 ou um expoente → 1e-2
Constantes (2)

Seu tipo é double, a menos que tenham um sufixo.

F ou f → indicam uma constante float

L ou l → constante long double




O valor de um inteiro pode ser especificado em decimal,
octal ou hexadecimal
Um zero inicial em uma constante inteira significa octal →
037 (octal) = 31 em decimal
0X ou 0x inicial significam um número hexadecimal → 0x1f
ou 0X1F = 31 em decimal
Constantes octais ou decimais podem ser seguidas por l ou L
(para torná-las long) ou por u ou U (para torná-las unsigned).
Constantes (3)






Uma constante de caracter é um inteiro, escrito como um
caracter entre aspas → 'x'
O valor de uma constante de caracter é o valor numérico do
caracter no conjunto de caracteres da máquina
Ex.: a constante de caracter '0' tem o valor 48 no conjunto
de caracteres ASCII, que não está relacionado ao valor
numérico 0.
Escrevendo '0' no lugar do valor numérico 48 o programa se
torna independente do valor e mais fácil de ser lido.
Constantes de caracteres participam em operações
aritméticas como quaisquer outros inteiros
Seqüência de escape → \n - \t - \b (um único caracter)
Constantes (4)
Um padrão de bits arbitrário, do tamanho de
um byte, pode ser especificado por '\000', onde
00 é de um a dois dígitos octais (0..7).

ou por '\xhh`, onde hh é de um a dois dígitos
hexadecimais (0...9, A...F).
#define VTAB '\013' /* ASCII vertical tab */
#define BELL '\007' /* ASCII bell character */
#define VTAB '\xb' /* ASCII vertical tab */
#define BELL '\x7' /* ASCII bell character */

Seqüências de escape
\a
alert (bell)
\\
backslash
\b
backspace
\?
question mark
\f
formfeed
\'
single quote
\n
newline
\"
double quote
\r
carriage return
\ooo
octal number
\t
horizontal tab
\xhh
hexadecimal number
\v
vertical tab
Constantes (5)




Uma expressão constante é uma expressão que
envolve apenas constantes
É avaliada em tempo de compilação
Podem ser usadas como constantes também
Exemplos:
#define MAXLINE 1000
char line[MAXLINE+1];
#define LEAP 1 /* in leap years */
int days[31+28+LEAP+31+30+31+30+31+31+30+31+30+31];
Constantes (6)
Uma constante do tipo cadeia (string) ou literal
do tipo cadeia é uma seqüência de zero ou mais
caracteres delimitados por aspas
''Eu sou uma cadeia de caracteres''
'''' /* cadeia vazia ou nula */
 As mesmas seqüências de escape ssão usadas
nas cadeias
 Constantes do tipo cadeia podem ser
concatenadas em tempo de compilação
''Rio'' ''de'' ''Janeiro'' == ''Rio de Janeiro''

Constantes (7)






Uma cadeia é um vetor cujos elementos são caracteres.
A representação interna de uma cadeia possui um
caracter nulo '\0' ao seu final.
A área física de armazenamento é sempre um a mais do
que o número de caracteres entre aspas.
A função da biblioteca padrão strlen (s) retorna o
tamanho da cadeia s, excluindo o '\0' final.
Ver prog17-chap02-pg38.c
O arquivo <string.h> possui declarações de várias
funções de cadeias
Constantes (8)



'x' não é o mesmo que ''x''
'x' é uma constante de caracter, um inteiro usado
para produzir o valor numérico da letra x no
conjunto de caracteres da máquina.
''x'' é uma cadeia de caracteres (ou vetor) que
contém o caracter x e um '\0'.
Constante de enumeração (1)
É uma lista de valores inteiros constantes
enum boolean { NO, YES };
o primeiro nome em uma enum tem o valor 0, o
seguinte 1, e assim por diante, a não ser que valores
explícitos sejam especificados.
 Se nem todos os valores foram especificados, aqueles
que não o foram continuama progressão a partir do
último valor informado
enum months { JAN = 1, FEB, MAR, APR, MAY, JUN,
JUL, AUG, SEP, OCT, NOV, DEC };
/* FEB = 2, MAR = 3, etc. */

Constante de enumeração (2)



Os nomes em diferentes enumerações devem
ser distintos.
As enumerações fornecem uma forma
conveniente de associar valores constantes a
nomes.
É uma alternativa ao uso de #define, com a
vantagem dos valores serem gerados pelo
compilador.
Declarações (1)



Todas as variáveis devem ser declaradas antes
de serem usadas
Certas declarações podem ser feitas
implicitamente pelo contexto (eg. variáveis
extern).
Uma declaração especifica um tipo e é seguida
por uma ou mais variáveis daquele tipo
int lower, upper, step;
char c, line[1000];
Declarações (2)
Pode-se inicializar uma variável em sua
declaração
char esc = '\\';
int i =0;
float eps = 1.0e-5;
 Se a variável não for automática (local à função)
a inicialização é feita uma única vez, antes do
início do programa e o inicializador deve ser
uma expressão constante.

Declarações (3)



Uma variável automática explicitamente
inicializada tem seu valor inicializado toda vez
que a função ou bloco em que se encontra
ganhar o controle do programa.
Por default as variáveis externas e estáticas
são inicializadas com zero.
Variáveis automáticas sem inicializações
explícitas assumem valores iniciais indefinidos
(lixo).
Declarações (4)
O qualificador const pode ser aplicado à
declaração de qualquer variável, indicando que a
mesma não poderá ser alterada.
const double e = 2.71828182845905;
const char msg[] = "warning: ";

const pode ser aplicado a argumentos do tipo
vetor, indicando que os seus elementos não
podem ser alterados
int strlen(const char[]);

Operadores aritméticos





+, -, *, /, % (módulo)
A divisão inteira trunca a parte fracionária
x % y é igual a zero se x for um múltiplo de y;
em caso contrário é o resto da divisão de x por y
+ e – possuem a mesma precedência que é
menor que a dos operadores *, / e %, que por
sua vez é menor que a dos operadores unários +
e -.
Os operadores aritméticos se associam da
esquerda para a direita.
Operadores relacionais e lógicos (1)
Relacionais: >, >= , < , <= possuem a mesma
precedência.

De igualdade: == , != têm maior precedência
que os operadores relacionais.

Os operadores relacionais possuem menor
precedência que os aritméticos.
Expressões como i < lim -1 são avaliadas como
i < (lim -1)

Lógicos: &&, ||

Operadores relacionais e lógicos (2)


Expressões conectadas por && e || são avaliadas da
esquerda para a direita, e a avaliação pára, assim que a
veracidade ou falsidade do resultado for conhecida.
A maioria dos programas em C fundamenta-se nessas
propriedades.
for (i=0; i < lim-1 && (c = getchar()) != '\n' && c != EOF; ++i)
s[i] = c;


A precedência de && é maior que a de || e ambos têm
menor precedência que os operadores relacionais e de
igualdade.
A precedência de != é maior que a da atribuição =
Operadores relacionais e lógicos (3)
Por definição, o valor numérico de uma
expressão relacional ou lógica é 1 se a relação
for verdadeira e 0 se a relação for falsa.

O operador unário de negação ! converte um
operando diferente de 0, ou verdadeiro, no valor
0, e um operador 0 ou falso no valor 1.

if (!valid)
/* ao invés de */
if (valid == 0)

Conversões de tipo