Unidade II – Tipos, Operadores e Expressões

Disciplina Linguagens de Programação I

Bacharelado em Ciência da Computação da Uerj
Professores Guilherme Abelha & Gilson Costa

#include <stdio.h>
ANSI C
int main ()
{
printf("Hello World!");
return 0;
}
 Que assuntos serão abordados nesta unidade?

●
Organização de Computadores ●
Sistema de tipos do ANSI C
– visão geral – tipos primários
– modelo em níveis – declaração de constantes
– subsistema de memória – tipos derivados
– uso dos sistemas de tipos – tipos definidos no programa
– declaração de variáveis
●
Operadores e Expressões no ANSI C
– alocação de memória

alocação automática
– operadores

alocação dinâmica
– precedência de operadores
– variáveis em registradores
– ordem de avaliação
– conversão de tipos
– operações com strings
2/72
Estrutura básica de
um computador

3/72
 Ciclo de Instrução

Busca da Busca dos

Decodificação Execução
Instrução Operandos

endereços

Unidade
Central de Memória
Instruções e
Processamento operandos
dados
resultados

4/72
 A Máquina Original de Von Neuman

endereços
Unidade de
Controle
instruções

Memória

Unidade endereços
lógica e
aritmética
entrada
AC dados
saída

5/72
Arquitetura de Computadores em Níveis

Linguagens de
alto nível
Tradução

Assembly

Tradução
S.O.
Interpretação parcial

ISA
Microprograma
ou execução direta
Microarquitetura

Hardware

Lógica digital

6/72
Memória de
computador

7/72
Dispositivos de Memória

8/72
 Leitura da Memoria

Memória
Leitura
0h B5h
1h ADh
2h 15h Endereço 3h
3h 1Fh Processador
4h 56h
5h 87h Conteúdo 1Fh
6h 13h
7h 98h

9/72
 Escrita na Memoria

Memória
Escrita
0h B5h
1h ADh
2h 15h Endereço 6h
3h 1Fh
Processador
4h 56h
5h 87h Conteúdo FFh
6h FFh
13h
7h 98h

10/72
Mapa de Memória de um Programa C em Execução

Argumentos de linha de comando

e variáveis de ambiente
Pilha

Heap

Dados Globais
e Static

Código
Executável

11/72
Sistema de tipos

12/72
 Funções dos Sistemas de Tipos

●
Armazenamento de dados em memória
– Codificação
– Decodificação

●
Execução de expressões
– Precedência
– Ordem de avaliação

●
Conversão de valores

●
Validação de tipos
13/72
 Sistema de Tipos ANSI C

●
Tipos primários ●
Tipos definidos pelo
– char, short, int, usuário
long, long long, – enum,typedef
(signed / unsigned)
– float, double, long
double

●
Tipos derivados
– Tipo [], Tipo [][],
Tipo *, Tipo**,
struct {}, union

14/72
Tipos primários
do ANSI C

15/72
 Tipos Primários do Ansi C – Família dos Inteiros

Tipo Tam. (B) Faixa de valores signed Faixa de valores unsigned

char 1 [-128, 127] [0, 255]

short 2 [-32.768, 32.767] [0, 65.535]

int 4 [-2.147.483.648, 2.147.483.647] [0, 4.294.967.295]

long 4 [-2.147.483.648, 2.147.483.647] [0, 4.294.967.295]

long long [-9.223.372.036.854.775.808,

8 [0, 18.446.744.073.709.551.615]
9.223.372.036.854.775.807]

16/72
 Tipos Primários do Ansi C – Ponto Flutuante

●
A codificação dos números reais se assemelha à
notação científica. Ex.: 678 → 6,78 x102
S E −bias
S EXPOENTE MANTISSA Valor=(−1) . M . 2

Tipo Tam. (B) Faixa de valores*

float 4 [3,4 x 10-38, 3,4 x 1038]

double 8 [1,7 x 10-308 , 1,7 x 10308]

long double 10 [3,4 x 10-4932 , 3,4 x 104932]

* fonte: “Programming in Ansi C” E. Balagurusamy

17/72
 Tipos Primários do Ansi C – Ponto Flutuante

●
Exemplo padrão IEEE 754-1985 de 32 bits:
S EXPOENTE MANTISSA

0 01111100 01000000000000000000000

S E −bias
Valor=(−1) . M . 2
0 124−127
Valor=(−1) . 1,0100 . 2
−3
Valor=1,0100 . 2
Valor=(0,0010100)2
⁻3 −5
Valor=2 + 2 =1/8+1/32
Valor=0,125+0,0315=0,15625
18/72
Definição de
constantes

19/72
 Constantes

'A' 'c' /* (char) */

"Cadeia de char" "" /* (char[]) */
100 /* (int) */
100L /* (long) */
100.0 /* (float) */
123.7e-2 123.7E-2 /* (double) */
023 067L /* (int) notação octal */
0xFD 0XFD 0xdaefeeL /* (int) notação hex */
'\n' '\t' '\b' '\0' '\'' '\\' '\014'/* (char) */

20/72
Código ASCII

21/72
Código ASCII

22/72
 Exercício U2.1 – Tipos primários no Linux 64

Crie um programa na linguagem C que apresente na tela os

tamanhos dos tipos primários da linguagem (char, short, int,

long, long long, float, double e long double).

23/72
Tipos derivados
do ANSI C

24/72
 Arrays

float[]

0.27 2.45 6.12 5.07 0.145

int[][]
10 20 15 18

44 65 2 5

16 25 6 36

23 15 56 36

25/72
 struct

●
Cria tipos compostos
struct <identificadorDoTipo>
{
<tipo1> <identificadorMembro1>;
...
<tipon> <identificadorMembron>;
};

struct Point2D
{
float x;
float y;
int label;
};
26/72
 struct

struct Point2D
{
float x;
float y;
int label;
} Var1;

struct Point2D P1;

P1.x = 10.0;
P1.y = 20.0;
P1.label = 20;

Var1 = P1;

27/72
 union

●
Cria tipos que pode assumir valores e se comportar
como tipos diferentes
●
Não é feito teste de consistência, o programa deve
saber o tipo em uso
union u_tag{
int ival;
float fval;
char *sval;
} u;

printf("%d\n", u.ival);
printf("%f\n", u.fval);
printf("%s\n", u.sval);
28/72
 Apontadores

float* pfloat;

float** ppFloat;

29/72
Tipos definidos
no programa

30/72
 typedef

●
Cria novos tipos
●
Sinônimo para um tipo primitivo ou derivado

typedef <tipo> <identificadorDoTipo>;

typedef int Idade;

typedef char* String;

31/72
 enum

●
Cria um tipos que enumera constantes simbólicas do
tipo inteiro
●
Não é feito teste de consistência entre o valor inteiro
armazenado e as constantes listadas
enum booleano { NO, YES };/* NO = 0, YES = 1 */

enum escapes { BELL = '\a',

BACKSPACE = '\b', TAB = '\t',
NEWLINE = '\n', VTAB = '\v', RETURN='\r' };

enum months { JAN = 1, FEB, MAR, APR, MAY,

JUN,JUL, AUG, SEP, OCT, NOV, DEC }; /* FEB = 2,
MAR = 3, etc. */
32/72
 Exercício U2.2 – Tipos derivados no Linux 64

1. Baixe o arquivo Ud3Exercicio2.c

2. Analise o código

3. Compile e execute este programa

4. Compare o tamanho dos tipos derivados com o dos

respectivos tipos primitivos

5. Avalie a coerência dos tamanhos dos tipos em função da

teoria vista na aula

33/72
Declaração de
Variáveis

34/72
 Declaração de Variáveis

<tipo> <identificadorDaVariavel>;

int fahr;
char c;
unsigned int indice;
long double saldoContaEikeBatista;
short cont;
float salarioDeProfessor;
float vector[3];

35/72
 Declaração e Inicialização de Variáveis

<tipo> <Variavel> = <constante>;

int fahr = 50;

char c = 50;
char c = '2';
char c = 0x32;
char c = 062;
unsigned int indice = 50;
long double saldoContaEikeBatista = 50.7e127;
short cont = 50;
float salarioDeProfessor = 50;
float vector[3] = {50, 12, 8};
char str1[] = "Sou uma cadeia de carcteres\n";

36/72
Alocação automática e
dinâmica de memória

37/72
 Alocação automática de memória

int

int number; number

int
int number = 5; number 5

38/72
 Alocação automática de memória

int main() 0x0000000003CE10CB 0xA5

Sh1
{ 0x0000000003CE10CC 0xFD
short Sh1; 0x0000000003CE10CD 0x01 Ch1
char Ch1; 0x0000000003CE10CE 0xFF
float Fl1; 0x0000000003CE10CF 0x96
Fl1
0x0000000003CE10D0
struct Point2d 0xB7
0x0000000003CE10D1 0x32
{
0x0000000003CE10D2 0x08
float x,y;
0x0000000003CE10D3 0xA5
}P1; 0x0000000003CE10D4 0xFD
} 0x0000000003CE10D5 0x01
0x0000000003CE10D6
P1
0xFF
0x0000000003CE10D7 0x96
0x0000000003CE10D8 0xB7
0x0000000003CE10D9 0x32
0x0000000003CE10DA 0x08
39/72
 Alocação automática de memória

float vect[5];
float float float float float

vector

float vect2[]={120.0, 23.0, 25.0, 17.0};

float float float float

vector2 120 23 25 17

40/72
 Alocação automática de memória

int main() 0x0000000003CE10CB 0xA5

{ 0x0000000003CE10CC 0xFD
short V[2]; 0x0000000003CE10CD 0x01
V; 0x0000000003CE10CE 0xFF
V[0]=2; 0x0000000003CE10CF 0x96
V[1]=5; 0x0000000003CE10D0 0xB7
*(V+1)=5; 0x0000000003CE10D1 0x32
} 0x0000000003CE10D2 0x08
0x00000000003CE10D3
0x0000000003CE10D3
0x0000000003CE10D4
0xA5
0xFD
v[0]
0x01
0x0000000003CE10D5
0x0000000003CE10D6 0xFF
v[1]
0x0000000003CE10D7 0x96
0x0000000003CE10D8 0xB7
0x0000000003CE10D9 0x32
0x0000000003CE10DA 0x08
41/72
 Alocação automática de memória

int main() 0x00000000001C10AB 0xA5

{ 0x00000000001C10AC 0xFD
char S[5]; 0x00000000001C10AD 0x01
} 0x00000000001C10AE 0xFF
0x00000000001C10AF 0x96
0x00000000001C10B0 0xB7
0x00000000001C10B1 0x32
0x00000000001C10B2 0x08
0x00000000001C10B3
0x00000000001C10B3 0xA5 S[0]
0x00000000001C10B4 0xFD S[1]
0x00000000001C10B5 0x01 S[2]
0x00000000001C10B6 0xFF S[3]
0x00000000001C10B7 0x96 S[4]
0x00000000001C10B8 0xB7
0x00000000001C10B9 0x32
0x00000000001C10BA 0x08
42/72
 Apontadores e Arrays

int main()
{
p
short V[2];
0x03CE10D3
V
short* pVet; e
pVet = V;
*pVet=5; t
pVet[0]=9;
PVet[1]=10;
*(pVet+1)=11;
}
0x0000000003CE10D3
0x0009
0x0005 V[0]
0x000B
0x000A V[1]
43/72
 Alocação Dinâmica de memória

int main()
{
short* pVet;
pVet = malloc(5*sizeof(*pVet));
}
0xA5 0xA5
0x03CE10D4 0xFD
[0] 0xFD p
0x01 0x01
0xFF 0xFF V
0x96
[1] 0x03CE10D4
0x96 e
0xB7
0xE4
[2] 0xB7
0x32 t
0xDF 0x08
0x32 [3] 0xA5
0x08
0xFB
[4] 0xFD
0x01
0xA2 0xFF 44/72
 Tratamento de
caracteres em C

45/72
 Funções da Biblioteca ctype.h

●
Avaliação de caracteres:
– isalnum() se é alfanumérico
– isalpha() se é alfabético
– isblank() se é branco
– iscntrl() se is um caracter de controle
– isdigit() se é um digito decimal
– isgraph() se possui representação gráfica
– islower() se é letra minúscula
– isprint() se é imprimível
– ispunct() se caracter é símbolo de pontuação

46/72
 Funções da Biblioteca ctype.h

●
Avaliação de caracteres:
– isspace() se é maiúsculo espaço em branco
– isupper() se é maiúsculo
– isxdigit() se é um dígito hexadecimal válido

●
Conversão de caracteres:
– tolower() para minúsculo
– toupper() para maiúsculo

47/72
String em C

48/72
 String

char Str[5]="Uerj";
char Str[ ]="Uerj";
0xA5
0xFD
0x01
0xFF
0x96
0xB7
0x32
0x08
0x00000000001C10B3 0x55 Str[0]
0x65 Str[1]
0x72 Str[2]
0x6A Str[3]
0x00 Str[4]
49/72
 Funções da Biblioteca string.h

●
Cópia:
– strcpy() copia string
– strncpy() copia caracteres de uma string
●
Concatenation:
– strcat() concatena strings
– strncat() concatena parte de uma string a outra
●
Comparison:
– strcmp() compara duas strings caracter a caracter
– strcoll() compara duas strings usando LC_COLLATE
– strncmp() compara até n caracteres de duas strings
– strxfrm() transforma string usando LC_COLLATE
50/72
 Funções da Biblioteca string.h
●
Busca:
– strchr() a primeira ocorrência de um caracter
– strcspn() fornece o comprimento da substring inicial de
str1 contendo somente caracteres que não pertençam a str2
– strpbrk() idem strcspn(), retornando ponteiro
– strrchr() a última ocorrência de um caracter
– strspn() fornece o comprimento da substring inicial de
str1 contendo exclusivamente caracteres em str2
– strstr () localiza substring
– strtok () quebra string em tokens
●
Outras:
– strerror() obtém apontador para mensagem de erro
– strlen() obtém o comprimento da string
51/72
 Exercício U3.3 – Funções de Manipulação de
Strings

Crie um programa que receba através do canal de entrada

default uma string e teste se esta é um palíndromo.

fgets (char * str,int num, FILE* stream)lê uma

string a partir do canal especificado

strcmp (char * str1, char str2) compara strings

52/72
 Recursos
complementares

53/72
 Register

●
Indica ao compilador que uma determinada variável
será usada exaustivamente.
●
Variáveis register não são armazenadas na memória
principal, mas nos registradores localizados dentro
do processador.
●
Melhora o desempenho dos programas

register int x;

register char c;

54/72
 const

●
Especifica que o valor de uma variável ou parâmetro
de uma função não poderá ser modificado.
● Num array const os valores dos elementos
permanecem inalterados.

const double pi = 3.141592654;

const char c[]= "Guilherme é legal";

55/72
Operadores

56/72
 Operadores Aritméticos

●
Operadores binários ●
Precedência e ordem de
+ soma avaliação
- (unário)
- subtração
* / %
* multiplicação
+ -
/ divisão
% resto da divisão ●
Exemplo
●
Operador unário 2*25.2/32*-3
- negativo = -4.725
57/72
 Operadores Relacionais e Lógicos

●
Operadores binários ●
Operador unário
> maior que ! negação
>= maior ou igual ●
Precedência e ordem
< menor que * / %
<= menor ou igual + -
== igual a > >= < <=
!= diferente == !=
&& E lógico &&
|| OU lógico ||
= += *= ^⁼
58/72
 Operadores Lógicos bit-a-bit

●
Aplicáveis a operandos ●
Operadores binários
da família de inteiros: & E-Lógico
char | OU-Lógico
short ^ Ou-Exclusivo
int ●
Operadores unários
long << left shift
long long >> right shift
~ complemento

59/72
 Operadores Lógicos bit-a-bit

●
Exemplos

int n, x, y, z;

n = 0xFF & 0177; /* n = 0x7F */

x = 0xF00 | 0xFF; /* x = 0xFFF */

y = 0xFB << 2; /* y = 0x3EC */

z = ~ 0xFF; /* z = 0xFF00 */

60/72
 Operadores de Atribuição

●
Atribuição

n = 0xFF ;

●
Incremento e decremento
n++; ++n; n--; --n;

●
Atribuição + operador binário

n+=2; /* n=n+2
-= *= /= %= <<= >>= &= ^= |= */

61/72
Operadores: Precedência e Ordem de Avaliação

Precedência dos operadores Ordem de avaliação

() [] -> . Esquerda → Direita
! ~ ++ – + - * (type) sizeof Esquerda ← Direita
* / % Esquerda → Direita
+ - Esquerda → Direita
<< >> Esquerda → Direita
< <= > >= Esquerda → Direita
== != Esquerda → Direita
& Esquerda → Direita
^ Esquerda → Direita
| Esquerda → Direita
&& Esquerda → Direita
|| Esquerda → Direita
?: Esquerda ← Direita
= += -= *= /= %= &= ^= |= <<= >>= Esquerda ← Direita
, Esquerda → Direita
62/72
Conversões
de Tipos

63/72
 Conversões Automáticas

●
Expressões aritméticas fazem conversões
automáticas de tipos
– var1 <operador> var2
– se var1 e var2 são do tipo1 o resultado é
tipo1
– se var1 e var2 é são de tipos diferentes, durante o
cálculo um dos operandos é convertido
●
o resultado terá o mesmo para o qual o operando foi
convertido

64/72
 Operandos de Tipos Distintos

●
Hierarquia de Conversão
double

float

unsigned long

long
unsigned int
int
65/72
 Conversão Automática na Atribuição

●
Do tipo menor para o tipo maior → OK
double

float

unsigned long

long
unsigned int
int
●
Do tipo maior para o tipo menor → Truncamento
66/72
 Conversão Automática do tipo char

● Todo char é convertido para short

/* atoi: convert s to integer */

int atoi(char s[])
{
int i, n;
n = 0;
for (i = 0; s[i] >= '0' && s[i] <= '9'; ++i)
n = 10 * n + (s[i] - '0');
return n;
}

67/72
 Conversão Explícita de Tipo

● O operador de conversão de tipo (<tipo>) muda

o tipo do resultado da expressão a sua direita

(<tipo>) <expressão>

●
O tipo da expressão se mantém
● O resultado é convertido para <tipo>

68/72
 Compilação e
Tabelas de Símbolos

69/72
 Tabela de Símbolos

●
Estrutura de dados, normalmente uma hash, que armazena
informações sobre os identificadores
●
Na compilação:
– Monitoramento dos identificadores em uso
– Análise léxica, sintática e semântica
●
Arquivo objeto:
– Mapeamento das variáveis em endereços relativos de memória
●
Linking:
– definição dos endereços de memória absoluta
●
Debuging de Executáveis
●
Conjunto de entradas em bibliotecas compartilhadas

70/72
 Tabela de Símbolos

void myProc ( int A, short B)

{
int D, E;
D = 0;
E = A / round(B);
if ( E > 5)
printf("%d", D);
}

Símbolo Token Dtype Inicializado? Endereço

myProc id procName - 0x0E
A id int SIM 0x00
B id short SIM 0x04
D id int SIM 0x06
E id int SIM 0x0A

Disciplinas: Compiladores e Estruturas de Linguagens

71/72
 Trabalho U2.4 – Conversão de Base

Crie um programa que dada uma string contendo um número

na base 8 (número octal) a converta para uma string relativa ao

número na base 2 (binário) correspondente. Em seguida, seu

programa deve converter a string com a representação binária

em uma string com a representação hexadecimal.

72/72
Fim

73/72