Делфи забавления :)

Ако ви се забавлява странно :) и знаете Делфи
(щом четете тук сигурно е така :)
Тогава познайте "на око" преди да го опитате какво
правят следните примерчета.

Какво ще покаже ShowMessage?

procedure TForm1.Button1Click(Sender: TObject);

begin

  ShowMessage( IntToStr( Round(3.5) - Round(2.5) ) );

end;

А следващия ShowMessage?

procedure TForm1.Button1Click(Sender: TObject);

const

  cs: array[0..1] of char='01';

begin

  ShowMessage(copy(cs,0,1)+copy(cs,1,1));

end;

Сложете във формата една променлива FControl:TControl;
ето така:

  TForm1 = class(TForm)

    Button1: TButton;

    procedure Button1Click(Sender: TObject);

  private

    { Private declarations }

    FControl:TControl;

  public

    { Public declarations }

  end;

а на един буттон:

procedure TForm1.Button1Click(Sender: TObject);

begin

  if (FControl is TControl)

     then ShowMessage('Is Control')

     else ShowMessage('Not a Control');

end;

И? Какво според вас ще излезе? (И защо?)

Следващатата закачка:
(които наум познае какво ще излезе без да си
подсказва с компилатора (ама честно де) има една бира от мен :)

procedure TForm1.Button1Click(Sender: TObject);

var

  X,Y,Z: variant;

begin

  X := '1';

  Y := '2';

  Z :=  3;

  ShowMessage(X+Y+Z);

end;

Хайде още една последно. Както всички знаем
abs връща положително число ....

procedure TForm1.Button1Click(Sender: TObject);

begin

  if abs(-maxint-1)>=0

     then ShowMessage('ABS alwais is positive.')

     else ShowMessage('Sometimes ... negative.');

end;

Ако някой се сети още нещо подобно - може да
попълни колекцията.

======================================================
ShowMessage( IntToStr( Round(3.5) - Round(2.5) ) )=>2

Много има писано за работата с "плаваща запетая" и за функциите за закръгляване.
Според тези писания резултата изглежда логичен (донякъде).
======================================================

======================================================
ShowMessage(copy(cs,0,1)+copy(cs,1,1))=>00 - Грешно използване на "Copy()"
ShowMessage(copy(cs,1,1)+copy(cs,2,1))=>01 - Правилно използване на "Copy()"

Например ако си беше дефинирал масив:"cs2: array[5..6] of char;"
то правилното използване на Copy() е:
ShowMessage(copy(cs2,1,1)+copy(cs2,2,1))=>01
======================================================

======================================================
При използване на НЕинициалицирани обекти резултата ще такъв:
"Not a Control"
А компилатора казва:"Variable "FControl" might not have been initialized"

Но ако беше написал поне "FControl:=TControl.Create(self);",
то резултата щеше да е:
"Is Control"
======================================================

======================================================
"Sometimes ... negative." - това вероятно е проблем

Но ако се използва променлива "i:int64;"
и се напише:
i:=-maxint-1;
if abs(i)>=0
then Memo1.Lines.Add('ABS alwais is positive.')
else Memo1.Lines.Add('Sometimes ... negative.');
То резултата е:
"ABS alwais is positive."

п.п.
Ако се използва: "if abs(-maxint-1)>=0"
то компилатора ме предупреждава:
"Comparison always evaluates to False", т.е. "знае за проблема", че
ще получа резултат: "Sometimes ... negative."

======================================================

======================================================
X := '1';
Y := '2';
Z := 3;


X+Y+Z=15 - резултата ми изглежда логичен, защото: x+y='1'+'2'='12' => '12'+3=15;
======================================================

Прав си ... донякъде :)

за
Round(3.5)-Round(2.5) всъщност не си казал защо :)
(освен че накъде нещо е писано.
Round(4.5) - Round(3.5) ще е още "по-странно" - защо?)

за
"Грешно използване на "Copy()"
ами то не е "грешно" в смисъл че компилатора го "гълта"
въпроса е защо? ето даже твоя пример мога да преправя:

procedure TForm1.Button1Click(Sender: TObject);
const
cs: array[5..6] of char='01';
begin
ShowMessage(copy(cs,0,1)+copy(cs,1,1));
end;

така че КОЕ е грешно? (кое - в буквалня смисъл на въпроса)

за
При използване на НЕинициалицирани обекти резултата ще такъв:
"Not a Control"

:) 99% вярно
begin
FControl:=nil; // ето ти "инициализация"
if (FControl is TControl)
then ShowMessage('Is Control')
else ShowMessage('Not a Control');
end;

по-скоро намека беше откъде "is" "разбира" кое какво е :)
нали чинно съм си казал типа?


за
"Sometimes ... negative." - това вероятно е проблем

не, не е проблем - или по-точно не е там проблема
и int64 не го решава. ето: :)

procedure TForm1.Button1Click(Sender: TObject);
var
i:int64;
begin
i:=-High(Int64)-1;
if abs(i)>=0
then ShowMessage('ABS alwais is positive.')
else ShowMessage('Sometimes ... negative.');
end;


за
X+Y+Z=15 - резултата ми изглежда логичен

А за да съм честен преди да прочета хелпа - въобще не ми
се видя логично :) мислех че компилатора първо ще кастне
всичко към integer щото това стои отляво... ама така
си мисля аз, а в хелпа пише какво мисли компилатора :)
(ако се разменят местата на събираемите то
се получават "интересни" резултати :)



и още едно нещо се сетих което "открих" наскоро
в кода си, а после "открих" в хелпа :)

procedure TForm1.Button1Click(Sender: TObject);
var
i:cardinal;
begin
for i:=$0 to $FFFFFFFF do ShowMessage(IntToStr(i));
end;

колко пъти ще се изпълни цикъла?

Относно "странните" закръгления трябва да се знаят две неща:
1) аритметиката с плаваща запетая не прощава никому, и
2) симетрично и несиметрично закръгляне

за "Грешно използване на "Copy()"
Компилатора може да ти провери само типа на параметрите. Това, че ти подаваш невалидни стойности, които Copy не разбира е друго нещо. Нещата зависят само от реализацията на функцията и доколко тя ще ти позволи "да се застреляш в крака" - Copy returns a substring or sub array containing Count characters or elements starting at S[Index].

Проблемът с оператора is идва от незнанието какво върши той. То работи върху обекти: The is operator, which performs dynamic type checking, is used to verify the actual runtime class of an object. Ето защо не можеш да го позлваш да определиш типа на декларираната от теб променлива, а само за да определиш типа на съдържания в нея обект.

"X+Y+Z" примера е един чудесен пример за това как не трябва да се пише код. Не че не се компилира, но кому е нужно това чудо? Един от основните принципи, които трябва да се спазват е, че кода който пишеш трябва да е "максимално ясен". Аз например не мисля, че е ясно какво ще стане. Дали ще се отпечата "123", дали ще е "6". "15" пък е последното, което би ми хрумнало. Ако видя някой от моите колеги да напише нещо подобно собственоръчно ще му извия врата

Същото може да се каже и за цикъла накрая $FFFFFFFF е integer константа, която за 32 битови компилатори е равна на -1.

Накратко за Round():
Логиката е такава за да се намали грешката при действия(събирсне например) със закръглаване на "достатъчно" голям брой числа с плаща запетая;
Сега не ми се търсят статии за това, но и ти можеш да си намериш.
====================================================

====================================================
За Copy(): единствената "грешка" при Copy е, че за 0 и 1 елемент връща един и същи резултат. Т.е. програмистите свикнали да броят от 0 и тези от 1 няма да имат проблеми. Проблема ще се появи като реши да вземе нещо от средата на данните, но бързо ще си открие грешката.
====================================================

====================================================
procedure TForm1.Button1Click(Sender: TObject);
var
i:int64;
begin
i:=-High(Int64)-1;
if abs(i)>=0
then ShowMessage('ABS alwais is positive.')
else ShowMessage('Sometimes ... negative.');
end;

При мен дава "Integer owerflow" и е така.
====================================================


В крайна сметка няма софтуер без грешки, това не изключва и Delphi.


Скоро забелязах, че "Exit" не работи според Help-a, т.е. ако се използва в
тялото на try...finally;

Edit:
andrew_nikoloff ти е дал хубав линк за закръгляването.

Срам ме е да си призная, но моите забавления са в жълтия спекър - светла бира и руси жени...

чети и дишай по-леко

ок - предавам се :)

Беше отговорено на част от "загадките",
но по мое мнение не на всички и не така както
по мое мнение е правилно :)

Та затова "се предвам" и ще кажа "отговорите"
според мен.

За Round:
Отговора е на F1 :)
от хелпа: " Round returns an Int64 value that is the value of X rounded
to the nearest whole number. If X is exactly halfway between two
whole numbers, the result is always the even number"

Неправилното в отговорите за мен е, че вместо извадката
черно на бяло го пише в хелпа се цитират статии някъде.
(не че писаното там е грешно, но ние говорим за една
стандартна функция в езика и именно за нейната реализация)


За copy:
"Това, че ти подаваш невалидни стойности,
които Copy не разбира е друго нещо. "

Много добре си ги разбира :)

от хелпа: "Copy function"

function Copy(S; Index, Count: Integer): string;
function Copy(S; Index, Count: Integer): array;

!! за масиви и срингове !!
и за израза copy(cs,0,1)+copy(cs,1,1)
се викат РАЗЛИЧНИ функции copy
първия за динамически масиви които се номерират от 0,
а втория път за стрингове, които се номерират от 1.
Два пъти cs се преобразува към необходимия тип.

Неправилно беше отговорено според мен за този
въпрос защото никой не спомена ПРИЧИНАТА,
че се викат две различни функции copy.

За
FControl is TControl
:) нямам претенции - мисля че беше отговорено


за "X+Y+Z"

из "Operator precedence rules"
"In complex expressions ... while operators of equal precedence associate to the left."

из "Variants in expressions"
If an expression combines variants with statically-typed values,
the statically-typed values are automatically converted to variants.

В смисъл, че това обяснява защо резултата е такъв. А, че не е хубаво
да се пише такъв код съм съгласен :)


за ABS
най-банално препълване :)
дава "Integer overflow" само ако е компилирано с "Overflow checking"
иначе си не (което си е нормално :)


за for i:=$0 to $FFFFFFFF do...
"$FFFFFFFF е integer константа, която за 32 битови компилатори е равна на -1."

Цъ!! не е така! i е декларирана като cardinal така че не е -1 :))
причината е другаде - ама няма да кажа :) намерете си го сами :)


Pechenia, ... ъъъ , то жълтите забавления са си хубаво нещо
(и аз ги уважавам :) ама си мислех, че може и това да е забавно :)

В тази връзка в темата ти "Сборище" нещо е затихнала. Що така!
Времето до петък е малко -
ти модератор ли си или лукова глава?
я кажи къде ще бъде?

"...
за for i:=$0 to $FFFFFFFF do...
"$FFFFFFFF е integer константа, която за 32 битови компилатори е равна на -1."

Цъ!! не е така! i е декларирана като cardinal така че не е -1 :))
причината е другаде - ама няма да кажа :) намерете си го сами :)
..."

There is no Delphi variable type that is the equivalent of a C code Unsigned Integer, UINT. A C code UINT can have a Cardinal value from 0 to 4,294,967,294 AND a single negative value of -1. Delphi declares a UINT as a LongWord (Cardinal), but if this variable has a Value of (hex) $FFFFFFFF (const MAXDWORD), then it is a -1 to the Windows System.

не
"then it is a -1 to the Windows System" какво общо има
Windows System в случая. че не е така показва следващия пример:

var

    i:cardinal;

begin

  for i:=$FFFFFFF0 to $FFFFFFFF do ShowMessage(IntToStr(i));

end;

работи си като слънце

Анализирам тук едно забавяне на един компонент (tZQuery, от Zeos) и стигнах до нещо интересно в tStringList, което в момента изяснявам, но ще го постна за забавление :)

{}procedure TForm1.Button1Click(Sender: TObject);

    begin

      RichEdit1.Lines.LoadFromFile('D:\Data\MyProj\DPCS_RetrF8\ProbStrList\p.txt');

      RichEdit2.Lines.Text := StringReplace(RichEdit1.Lines.Text,#13#10,#1#2,[rfReplaceAll]);

      RichEdit3.Lines.Text := StringReplace(RichEdit2.Lines.Text,#1#2,#13#10,[rfReplaceAll]);

    end;

та файлчето ми p.txt започва с кирилица и е смесен текст от от кратки редове (подобно на ini файл, но с друго предназначение)
И когато размерът на p.txt е по-малко от 4094 байта (например 4093 :) всичко е ОК,
НО АКО СТАНЕ 4094 или повече байта - кирилицата се скапва :)

"Блокова схема. Версия Ver: A825."
";>:>20 AE5<0. 5@A8O Ver: A825."

Айде, кой ще е първи в решението :)

Нещо не е в ред тука :-)
И с 4093, и с 4094, и с доста по-голям файл - проблеми нямам. Възможно ли е двата файла да са ти различни, т.е в единия например кирилицата да е в unicode (въпреки, че тогава единият байт ще ти е #4, а не #1 или #2)?... Един вид искам да кажа, възможно ли е да имаш във файла някакви последователности от #1#2, дето да се омазва от тях работата?

Може би е от максимална дължина на линията
Ако след като заредя файла, тектса го присвоя на обикновен стринг, заменя CrLf (#13#10) с нещо друго (#1#2) и след това го върна в текста на стринглиста - няма проблем.
Аз и така реших да направя.
А Zeosът, докато прави формален контрол на SQL анализира линиите много бавно и с тази замяна работата се ускори около 30-40 пъти.

Малко въпроси:
Емил, ти как би реализирал функцията Round(), т.е. при "Round(2.5)+Round(3.5)+Round(4.5)+Round(5.5)" какъв резултат ще получиш според теб?


"за ABS
най-банално препълване :)
дава "Integer overflow" само ако е компилирано с "Overflow checking"
иначе си не (което си е нормално :)"

Нали точно за това е "Integer overflow". Не виждам никакъв смисъл в "чаша 100мл да наливаш 500мл(бира)"

Ако си решил да търсиш под вола теле, може и да го намериш, даже може и да осъдиш Borland, защото в щатите всичко е възможно.

Цитат:

Отново в САЩ: Жена си купува микровълнова печка, изкъпва си котката и я слага в печката да изсъхне. Котката няма да коментирам, но с две думи - умряла е. Жената съди компанията, произвела печката, че в инструкцията не пише, че ако сложиш котка да съхне, тя ще се спомине. Печели делото...

"Ако си решил да търсиш под вола теле..."

:)
Не, не търся под вола теле. Нито обвинявам Борланд :)
или някой друг.

Писах с мисълта, че примерите ще са забавни ... може би :)
Идеята беше, не че са са нещо "неправилно", а може би
малко неочаквано - с една дума беше замислено като
"fun", а не като заяждане :)

И против Round нямам нищо против :) работи си точно
както трябва и не бих я реализирал по друг начин :)
По-скоро търсех елемента на изненада :)

Например за abs машинално приемаш, че е не може да е
отрицателно - след примера си казваш - е, да може -
но обикновено не ти минава през ума по време на писане :)

Примера с TControl така поднесен е ясен :) но в реалния код
може да се срещне в такъв вариант:

if (FControl is TControl) then 

  begin

     if not Assigned(FControl) then FControl:=TControl.Create;

  end

  else ShowMessage('Error! Not a control');

така машинално записан може и да не се усетиш,
че си написал глупост :)

Та това беше "за забавление".
Съжалявам ако не се е харесало :(