Multiplicador de P.F.
Só de brincadeira vamos relembrar para os voadores de plantão, Pontos Flutuantes são números quebrados, ex: 1/3 = 0,3333333333333333333333333… e que os processadores possuem um estrutura específica em seu core para trabalhar com esses números que são muito mais difíceis e complicados do que os números inteiros. E para os viciados em jogos, bora lembrar que as partes gráficas utilizam muito o ponto flutuante. Antes de explicar os passos, vamos passar uma figura mostrando uma visão geral do que acontece.
Imagem não muito estranha né?! Será que alguém reconhece? ^^
A primeira coisa a ser feita pelo processador é somar os expoentes de cada número (fazendo uso da ULA pequena, próximo à Unidade de Controle), lembrando de subtrair o bias da soma, para obtermos o valor do novo expoente deslocado.
Feito isso, multiplica-se os significativos (com a ULA grande, a outra né ¬¬’ ) e normaliza o produto quando necessário (Utilizando Incremento). Se esse for o caso, desloca-se o produto para direita (Adivinhe onde ^^’) e o expoente é incrementado.
Se houver um Overflow ou um Underflow, que ocorre quando o resultado obtido é pequeno demais para ser representado em um número de ponto flutuante, será aplicada uma exceção, senão arredonda-se o significando para o número correto de bits (através do Hardware de arredondamento). Caso ainda não esteja normalizado, voltamos para etapa de normalização do produto e permanecemos neste ciclo até que a normalização ocorra.
Finalmente, analisaremos os sinais (através da porta lógica XOR). Se ambos forem iguais, um sinal positivo será atribuído ao resultado, senão, um negativo o será.
Burlando a orientação a objetos do C++ com ponteiros
C++ introduziu alguns conceitos de Orientação a Objetos à linguagem C. Dessa forma podemos trabalhar com encapsulamentos e todas as demais vantagens de uma linguagem Orientada a Objetos. Porém, C++ manteve uma característica importante de C: os ponteiros.
Devido à existência de ponteiros em C++ torna-se possível burlar a Orientação a Objetos suportada na linguagem. Afinal os ponteiros fazem referência direta ao endereço e não à variável.
Segue abaixo um exemplo de código de como isso pode ser feito:
class Burlando {
private: float array [] = {2,3,4,5,6,7};
public:
Burlando();
virtual ~Burlando();
float* ponteiro;
//retorna o endereco da primeira posicao do array
int getAdress(){
return &array[0];
}
//imprime o array
void imprimeArray(){
for (int i = 0; i==6; i++){
cout<<array[i];
}
}
void main(){
Burlando obj = new Burlando();
obj.imprimeArray();
*ponteiro = getAdress();
for (int c = 0; c == 6; c++){
//faz o quadrado do valor do array
ponteiro = ponteiro * ponteiro;
//ponteiro aponta p/ proxima posicao do array
*ponteiro = ponteiro + 2;
}
obj.imprimeArray();
}
};
Neste exemplo, nós criamos um array do tipo float como privado. Criamos como público um ponteiro que aponta para float e um método do tipo int getAdress que retorna o endereço da primeira posição do array privado.
No método main nós instanciamos um objeto da classe, mandamos imprimir os valores do array apenas para comprovar a quebra da Orientação a Objeto. Em seguida atribuímos ao ponteiro o resultado do método getAdress e em seguida modificamos um a um os valores do array, calculando o quadrado deles.
Logo depois, nós mandamos imprimir os valores do array novamente para termos certeza que eles foram modificados. Dessa forma pudemos constatar que a Orientação a Objeto foi burlada.
