Tipos de variáveis ou dados
é um nome para uma combinação de valores e algumas
operações que as variáveis podem executar.
As linguagens de programação permitem combinar valores entre si para calcular novos valores.
Diferentes tipos de valores :
- inteiro: 1
- decimal : 1.0
- texto: um
As linguagens possuem operadores pré-definidos para combinar valores:
exemplo: operadores matemáticos ( soma,
subtração, multiplicação, divisão
etc.)
Sistema de tipos
As linguagens de programação possuem tipos básicos
e também oferecem a possibilidade da construção de
novos tipos.
O sistema de tipos define os tipos básicos, os construtores de
tipos, e regra de conversão entre tipos; oferece também
um mecanismo de controle para evitar que o programador cometa certos
erros tais como:
1 pessoa + 1 gato = Erro
1 quilo + 1 metro = Erro
A riqueza do sistema de tipos de uma linguagem pode variar
Tipos
Inteiro: tipo primitivo, normalmente com 1, 2, 4 ou 8 bytes de
comprimento ( 8, 16, 32 ou 64 bits ) ( observe: número de
bits = 8 * comprimento em bytes ).
Um computador só pode representar um subconjunto dos inteiros,
uma vez que o número de bits fixa limita a
representação a um máximo de 2^número de
bits(2^8 para bytes, 2^32 para 32-bits arquitetura, etc.)
número de bits = comprimento em bytes * 8;
limite = 2^(número de bits)
- limitado / ilimitado ( aritimética modular )
- com sinal ( Z ) / sem sinal ( N )
- se limitado: limite = 2^número de bits
ex: 1, 124123, -234332, 13, 17, 355, etc.
Float: é uma representação digital dos
números reais , que é usada nos computadores. Ultiliza
precisão para realizar operações.
ex: 5,0; 3,7; 0,003; 8E10( = 8 * 10^10 ), 7E13+/-7 ( 7 * 10^13
+ 7 )
Booleano: apresenta dois valores ( 0 ou 1, true ou false, etc.), que representa verdadeiro ou falso.
Caracteres: 'a', 'b', 'c',...'A', 'B', 'C', ..., '!', '#', ...
String: É uma sequência de vários caracteres simples.
"Hello World", "Hi", etc.
Tipos do O'Caml
int: números interos ( limitados )
float: números decimas ( limitados )
char: caracteres. ex: 'a'
string: sequência de caracteres
unit: possui apenas uma valor; escrito como ()
Tipos básicos em C/C++
inteiro:
- int: pode possuir 16 ou 32 bits, ddependendo do processador
- short int: possui o tamanho de 16 bits
- long int: possui o tamanho de 32 bits
- long long int: possui o tamanho de 64 biits
- unsigned int: números positivos
caractere:
- char: ocupa 1 byte, e serve para armazenar carateres. Isso
significa que o programa reserva um espaço de 8 bits na
memória RAM para armazenar um valor.
float:
- float: serve para armazenar númerros de ponto flutuante, ou seja, com casas decimais
double:
- double: serve para armazenar númeeros de ponto flutuante de
dupla precisão. Possui o dobro do tamanho de float e portanto o
dobro da capacidade
- struct: cria um novo tipo de variáe;vel
void:
-void: retorna vazio
booleano:
-bool: true ou false
Operadores e tipos
Assim como os valores, operadores possuem um tipo.
- tipo de operandos
- tipo de resultado
mecanismos para definir novos operadores.Os
operadores permitem combinar valores entre si para criar novos valores.
As linguagens de programação possuem operadores
pré-definidos últeis e possuemComo os valores, os
operadores possuem um tipo.
f : arg1 -> arg2 -> arg3 -> ... -> argn -> tipo
exemplo:
# tan(1.0);;
- : float = 1.5574077246549023
tan: float -> float
Os tipos dos operadores são os tipos funcionais. Os tipos
funcionais por sua vez, são compostos por dois tipos mais
simples:
--- tipo do domínio
--- tipo da imagem
Separamos o tipo do domínio do tipo da imagem por uma seta
dom -> im
exemplo:
# tan;;
- : float -> float = <fun>
Algumas linguagens de programação permitem que diferentes
tipos de operadores possuam o mesmo o nome, tal capacidade é
chamada de sobrecarga de operadores. Os operadores normais ( + , - , /
, etc. ) são sobrecarregados a manejar também os
novos tipos de dados.
Em O'Caml não há sobrecarga de operadores, para soma
entre número inteiros usamos o operador + e para a soma entre
números reais usamos o operador +.
Posição dos operadores:
- Operadores préfixo: aparecem antees dos operandos
ex: sin, cos, tan, etc.
- Operadores infixo: aparecem entre os opeerandos
ex: +, - , * , / , etc.
- Operadores pósfixo: aparecem depoois dos operandos
A soma e o produto são operados associativos:
( 1 + 2 ) + 3 = 1 + (2 + 3) = 1 + 2 + 3
# ( 1 + 2 ) + 3;;
- : int = 6
# 1 + (2 + 3);;
- : int = 6
# 1 + 2 + 3;;
- : int = 6
Operadores pré-definidos em O'Caml
- menos unário: ~- : int -> int<
--- # ~- 1;;
--- - : int = -1
- sucesso: succ: int -> int
--- # succ 1;;
--- - : int = 2
- predecessor: pred: int -> int
--- # pred 1;;
--- - : int = 0
- soma: +: int -> int -> int
--- # 1 + 1;;
--- - : int = 2
- subtração: -: int -> innt -> int
--- # 1 - 1;;
--- - : int = 0
- multiplicação: *: int ->t; int -> int
--- # 3 * 3;;
--- - : int = 9
- divisão: / : int -> int -> int
--- # 9 / 3;;
--- - : int = 3
- resto da divisão: mod: int -> int -> int
--- # 9 mod 2;;
--- - : int = 1
- valor absoluto: abs: int -> int ->; int
--- # abs ~-1;;
--- - : int = 1
- valores extremos: int
--- # max_int;;
--- - : int = 1073741823
--- # min_int;;
--- - : int = -1073741824
O padrão IEEE754 definiu o comportamento dos operadores de ponto flutuante e a linguagem O'Caml segue tal padrão.
O tipo float possui três valores especiais:
infinity: 1.0/0.0;
neg-infinity: -1.0/0.0;
nan( not a number ) : 0.0
Os operadores propagam esses valores de acordo com o padrão
Operadores pré-definidos em O'Caml ( float )
- menos unário: ~-. : float -> ffloat
# ~-. 1.0;;
- : float = -1.
- soma: +.: float -> float-> float <
# 1.0 +. 1.0;;
- : float = 2.
- subtração: -. : float ->t; float -> float
# 1.0 -. 1.0;;
- : float = 0.
- multiplicação: *.: float --> float-> float
# 3.0 *. 3.0;;
- : float = 9.
- divisão: /.: float -> float -&> float
# 6.0 /. 7.5;;
- : float = 0.8
- exponenciação: **: float-&> float -> float
# 3.0**7.0;;
- : float = 2187.
-raiz quadrada: sqrt: float -> float
# sqrt 9.0;;
- : float = 3.
-valores extremos;
# max_float;;
- : float = 1.7976931348623157e+308
# min_float;;
- : float = 2.2250738585072014e-308
- exponencial: **: float -> float
# exp 2.0;;
- : float = 7.38905609893065
- logarítmo natural: log: float -&ggt; float
# log 2.0;;
- : float = 0.69314718055994529
-logarítmo em base 10 : log 10: flooat -> float
# log10 2.0;;
- : float = 0.3010299956639812
-arredondamento: floor, ceil: float -> float
# floor 4.7;;
- : float = 4.
# ceil 4.7;;
- : float = 5.
-conversão
-- float : int -> float
-- float_of_int: int -> float
-- int_of_float: float -> int
# float 1;;
- : float = 1.
# int_of_float 3.0;;
- : int = 3
# float_of_int 3;;
- : float = 3.
-valor absoluto: abs_float: float -> flloat;
# abs_float ~-. 3.0;;
- : float = 3.
-resto da divisão: mod_float: floatt -> float -> float
# mod_float 3.0 2.0;;
- : float = 1.
-significante e expoente em base 2: ;frexp: float -> float * int;
f (x, n ) = x . 2^n
# frexp 3.0;;
- : float * int = (0.75, 2)
note que 0.75 * 2^2 = 3
-construção em base 2: idexpp: float * int -> float;
-parte integral e parte funcionáriaa: modf : float -> float * float;
# modf 5.4;;
- : float * float = (0.40000000000000036, 5.)
Em O'Caml, qual o valor da expressão: ~-. 0.5 + 2.3 ?
possível resultado: (~- 0.5 ) + 2.3 = 1.8
possível resultado: ~- ( 0.5 + 2.3) = ~- 2.8
Temos duas expressões diferentes.
Pode-se usar parênteses para evitar dúvidas: (~- 0.5 ) + 2.3
Estouro: Existe um tempo limite de execução do programa
para cada linguagem e de acordo com a configuração da
mesma
Transbordagem ( overflow ): operações que tentam quebrar o limite
http://www.arnaut.eti.br/op/CPPAI06.htm
http://pt.wikipedia.org/wiki/Linguagem_de_programa%C3%A7%C3%A3o_C
http://www.ocaml-tutorial.org