Super Interessante...

[Renyo]

Galera, recebi um email dum programador das antigas aqui na empresa...

e achei interessante e gostaria de passar pra você's...!!!

Dêem uma lida, vale a pena mesmo !!!

Valeu ! :rolleyes:

Senhores... um "bug" BRABO do Delphi que detectei:

Esses bugs foram detectados quando analisava uma rotina que TINHA QUE DAR PAU... mas não dava!

Os exemplos abaixo ilustram:

--------------------------------------------------------------------------------

const a: array [1..8] of Integer = ( 1, 2, 3, 4, 5, 6, 7, 8 );

var i: Integer;

begin

for i := -10 to 10 do

WriteLn(a);

end.

--------------------------------------------------------------------------------

O programinha acima não causa quaisquer exceções... de fato, os itens do array a cujo índice seja menor que 1 e maior que 8 são "lixo" e são devolvidos por a.

Para evitar esse tipo de bug devemos usar a chave de compilação $R nos códigos:

--------------------------------------------------------------------------------

// Usando $R+ garantimos que uma exceção ERangeError seja disparada neste caso.

{$R+}

const a: array [1..8] of Integer = ( 1, 2, 3, 4, 5, 6, 7, 8 );

var i: Integer;

begin

for i := -10 to 10 do

WriteLn(a);

end.

--------------------------------------------------------------------------------

O mesmo ocorre, por exemplo, se usarmos um tipo sem sinal e tentarmos fazer isso:

--------------------------------------------------------------------------------

var x: Cardinal;

begin

x := 0;

Dec(x);

WriteLn(x);

end.

--------------------------------------------------------------------------------

O compilador não chia.... mas o valor mostrado será 4294967295, e não -1 como poderia ser esperado!

Para evitar esse erro, use a chave $Q:

--------------------------------------------------------------------------------

// Usando $Q+ garantimos que uma exceção EIntOverflow seja disparada neste caso.

{$Q+}

var x: Cardinal;

begin

x := 0;

Dec(x);

WriteLn(x);

end.

--------------------------------------------------------------------------------

Erros semelhantes para ponto-flutuante devem também ser levados em consideração... Não apenas a exceção EZeroDivide, mas tb as exceções EUnderflow e EOverflow. Isso levanta outra questão: O problema da instrução FDIV nos antigos processadores Pentium... Use sempre a chave $U+ para prevenir esse bug.

[Micheus]

Sem dúvida, serve de alerta aos menos avisados.

Essas diretivas de compilação estão disponíveis via menu Project->Options.

A omissão ("desabilitação") delas tem apenas o objetivo de otimização do código final. Significaria dizer que você tem certeza que esta condição não ocorrerá no seu programa ou que você não quer saber se elas ocorrerão. Evidentemente você deveria estar consciente disto. ;)

E, na verdade, não trata-se de um BUG, mas apenas de algumas coisas não são conferidas e "mostradas" a você na forma de erro.

É como você fazer um:

try
  aux := 10/0;
except
end;

eu sei que haverá erro, mas não quero saber desta mensagem. é um exemplo extremo, apenas para ilustrar;

na época do pascal, era comum para verificar a existência de um arquivo você desabilita os erros de I/O antes de abrir o arquivo (reset) e testar a variável IOResult, para conforme o caso dar uma mensagem amigável ao usuário ou, simplesmente, por não existir, criá-lo (rewrite). Logo após este tratamento, a diretiva era novamente ligada.

Abraços