Defensive programming

[taazz]

I see. Thanks!

Now I'm understanding a bit more. Another question: objects in local variables inside a function are not initialized with nil?

True local variables are not initialized. but you can write statements like

Code: Pascal  [Select][+][-]

1. procedure Test;
2. var
3.   MyObj :TLabel = nil;
4.   MyText:String = '';
5.   MyInt  :Integer = 0;
6. begin
7. end;
8.  

which will add initialization code to your variables. (if you are not pulling my leg that is).

Because I had that problems today. Checking for nil to an uninstantiated object something like

If assigned (obj1) then obj1.free;

And I get exceptions.

Sorry I'm more used to JS that starts with undefined or null.

yeah the initialization of the global and class fields is more of a function of the memory manager returning memory filled with zeros than a deliberate field initialization from the compiler.

[howardpc]

How about iterations through lists? Like TList and TStrings and descendants. Is it it somehow possible to use the IN keyword there?

Code: Pascal  [Select][+][-]

1. for ii in MyList.___ do;

Provided the list has an enumerator (of type TEnumerator) you can iterate using the Object Pascal "for x in list_of_x do ..." syntax.
Most RTL container classes come with one or more enumerators already.
If there is no built-in enumerator, you can write one yourself, and FPC is sufficiently well-designed to use the enumerator you provide.
The enumeration, of course, is based on the type of the element in the container. So for TList and TFPList which which are basically arrays of pointers the enumerator assumes a pointer element, which then usually required casting. For TObjectList the enumerator is a TObject, which usually requires casting, and so on. But delphi mode is not as strict as objfpc mode, so in some cases a cast is not required.
From the point of view of defensive programming, the looser delphi mode is less type-safe, but perhaps more convenient.

A dynamic array of TLabel gives you both type-safety and built-in "for ... in ... do" syntax, and no need for any casting.
Of course it is not "generic" either, like TList, holding only TLabel references and nothing else.

Code: Pascal  [Select][+][-]

1. type
2.   TLabelList = array of TLabel;
3. ...
4. var
5.   Llist: TLabelList;
6.   lbl: TLabel;
7. begin
8.   // initialise Llist ...
9.   for lbl in Llist do
10.     lbl.Color := clRed;
11.     ...

In this code the compiler will stop you using anything but a TLabel as the enumerator.
The compiler also prevents you from doing any kind of assignment to the loop variable lbl. It is read-only.

[ASerge]

...For TObjectList the enumerator is a TObject, which usually requires casting, and so on.

Amendment. TObjectList does not override enumerator, i.e. it uses inherited from TList.

[Thaddy]

That's true, but it works without a cast because of the result type of TObjectList. That should - but not tested - also work in ObjFpc mode not only in delphi mode.

[lainz]

True local variables are not initialized. but you can write statements like

Code: Pascal  [Select][+][-]

1. procedure Test;
2. var
3.   MyObj :TLabel = nil;
4.   MyText:String = '';
5.   MyInt  :Integer = 0;
6. begin
7. end;
8.  

which will add initialization code to your variables. (if you are not pulling my leg that is).

Thanks, I did not use that too much.

And no, I'm beign serious, I really don't know everything about Pascal.

Maybe I've readed that some day in the manual, but with no using it directly, problems happens, and I sometimes can't figure why.

[damieiro]

Hi thaddy!

Sorry for kicking this topic (>120 days) but i liked a lot the view of the tutorial, and even oldies can learn from it (me too )

Really I like it like a "good practices" in coding not only for defensive programming (and even offensive ones, i like this branch of defensive coding too)

Is this project continuated or something like good practices and book of examples (more than code snipets) i have see on wiki?

I think not knowing only what to do, but knowing why is should be do is a great engineer job. And i see this article as a little gem.
Are there more communty jobs like it? How can be started this job or continue yours? (i would like to make a "good practices wiki reviewed/written by all community).

[ArminLinder]

Advocate this! Being somewhere in between beginner and mediocre Pascal programmer I read the wiki with interest, and looked forward for the missing parts. They'd provide more insight into why some code looks over-complicated at first, but here you get the reasons why the really experienced guys do sometimes write a couple of lines more to prevent common mistakes.

Unfortunately it was never continued.

Armin.

Btw ...

Code: Pascal  [Select][+][-]

1. [....]
2. var
3.       I: Low(anArray)..High(anArray);
4. [....]
5. begin
6.       for i := Low(anArray) to High(anArray) do anArray[i] := 100+i;
7. end;
8.  

What's the gain to subrange the loop counter (I)? Does that really make sense if it is used in a for low(...) to high(...) loop? Looks like overkill to me.

[ccrause]

Btw ...

Code: Pascal  [Select][+][-]

1. [....]
2. var
3.       I: Low(anArray)..High(anArray);
4. [....]
5. begin
6.       for i := Low(anArray) to High(anArray) do anArray[i] := 100+i;
7. end;
8.  

What's the gain to subrange the loop counter (I)? Does that really make sense if it is used in a for low(...) to high(...) loop? Looks like overkill to me.

In this specific example it may seem like overkill since the loop range is also limited to valid values.  However it will guard against some faulty refactoring of say the for loop in future, for example substituting the low(anArray) with 0 in the for loop (because it is more "compact"):

Code: Pascal  [Select][+][-]

1. [....]
2. var
3.       I: Low(anArray)..High(anArray);
4. [....]
5. begin
6.       for i := 0 to High(anArray) do anArray[i] := 100+i;
7. end;

Now if anArray is declared as follows:

Code: Pascal  [Select][+][-]

1. var
2.   anArray: array[1..10] of integer;

and the above modified for loop is compiled you should get a compile time error, as explained in the article.

[Zvoni]

Addition to ccrause: Don't forget the use of Sets.
Like the article explained it's very easy that way to walk through an array just accessing the "odd" members

[damieiro]

I love the Sets part of the article. I have misused them a lot.

For the defensive techiques are some universal ones (not only languaje driven)
A classic "defense" for indexes is like that:

Code: Pascal  [Select][+][-]

1. program dtp_1d2;
2. {$mode objfpc}{$R+}
3.  
4. const
5.   anArrayIdxL=0;  //or other kind of naming
6.   anArrayIdxH=9;
7.  
8. var
9.   anArray:array [anArrayIdxL..anArrayIdxH] of integer;
10.   i:shortint; // it can be as a set, like thaddy shows. i:anArrayIdxL..anArrayIdxH, but too verbose to my taste
11.  
12. begin
13.   // data to show what for in do does
14.   for i := anArrayidxL to anArrayidxH do
15.   begin
16.     anArray[i] := i;
17.     write(anArray[i]:3);
18.   end;
19.  
20.   readln;
21. end.  

[Thaddy]

Finally, from Oct 1st I have some time left to add to my article. I will keep you posted for updates.