How to use interfaces

[trev]

The Wiki has a demo program in the article How to use interfaces to which someone has recently added:

this code contains memory leaks and incorrect use of interfaces. Please pay attention to this.

Could someone who understands the use of interfaces take a look? If it is incorrect it needs to be either fixed or deleted.

[Warfley]

First of all, yes it produces a memory leak, which can be verified by compiling with the heaptrc unit.

The reason for this is the following: GetInterface returns not an interface reference of R, but of Hook, as it is defined in:

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

1.     //Here we tell the compiler that our class
2.     //interface implementation is provided by
3.     //a member field wich we initialize in this case
4.     //on the constructor
5.     property Hook: ITestInterface read FHook implements ITestInterface;

Therefore R will not be handled as an interface reference which circumvents the reference counting of it. Therefore it will not get freed.

Only references of the hook will be incresed and decreased by the use of the variable I, but as R still holds a reference, it will not drop to 0 and therefore not freed.
This causes two memory leaks, first R doesn't get freed and second the Hook of R doesn't get freed.

Solution: 1. remove the destructor of TRealClass, this is not needed as reference counting does the job.
2. Add an R.Free to the end of the program.


That said, IMHO this example is pretty bad and probably causes more confusion than helping anyone (the existance of this thread proof of that), this probably needs a rework and/or some explaination. There is no reason why TRealClass actually implements the TBaseObject, this let it seem like it itself provides the interface functionality while the whole example is to show that you can delegate that to a member/property. This makes this very confusing.

Generally speaking, an article called "How To Use Interfaces" could use more than one example, especially if that example only showcases a very corner case of interface usage (i would say delegating the interface implementation to a property is not really the main use case for interfaces), but could take more examples and maybe some explaination.
IMHO this article does more harm than good, as it is very confusing (and also simply broken), while not really giving any insight on how to use interfaces. It probably just scares people away of using interfaces rather than helping to understand them

[zamtmn]

>>to which someone has recently added:
I added that. I was dealing with interfaces and this example put me confused.
But I don't know how to make simple visual examples, so I did this.

>>2. Add an R.Free to the end of the program.
no, this causes av in THook(FHook).Free;

[Warfley]

>>2. Add an R.Free to the end of the program.
no, this causes av in THook(FHook).Free;

Thats what Step 1 is for, when removing the destructor this removes the free of the hook, which will then be taken care of by the ref counter

[ccrause]

Generally speaking, an article called "How To Use Interfaces" could use more than one example, especially if that example only showcases a very corner case of interface usage (i would say delegating the interface implementation to a property is not really the main use case for interfaces), but could take more examples and maybe some explaination.
IMHO this article does more harm than good, as it is very confusing (and also simply broken), while not really giving any insight on how to use interfaces. It probably just scares people away of using interfaces rather than helping to understand them

I agree, this page should state clearly that the focus is interface delegation.  It is not a general overview of interfaces, there are other wiki pages that give a more general overview of interfaces.

[Thaddy]

Ouch... Who wrote that?
I will correct it. e.g.

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

1. program interfacesygenerics;
2. {$mode objfpc}{$H+}
3. type
4.   ITestInterface = interface
5.     ['{3FB19775-F5FA-464C-B10C-D8137D742088}']
6.     procedure DoSomething;
7.     procedure DoItAll;
8.   end;
9.  
10.   TBaseObject = class(TInterfacedObject,ITestInterface)
11.     procedure DoSomething;
12.     procedure DoItAll;
13.   end;
14.  
15.   TderivedObect = class(TBaseObject,ITestInterface)
16.     procedure DoSomething;
17.     procedure DoItAll;
18.   end;
19.  
20.   procedure TBaseObject.DoSomething;
21.   begin
22.     Writeln('TBaseObject DoSomething !');
23.   end;
24.  
25.   procedure TBaseObject.DoItAll;
26.   begin
27.     Writeln('TBaseObject DoItAll !');
28.   end;
29.   procedure TderivedObect.DoSomething;
30.   begin
31.     Writeln('TderivedObect DoSomething !');
32.   end;
33.  
34.   procedure TderivedObect.DoItAll;
35.   begin
36.     Writeln('TderivedObect DoItAll !');
37.   end;
38.  
39. var
40.   I: ITestInterface;
41. begin
42.   Writeln('Using regular interfaces');
43.   I := TderivedObect.Create as ITestInterface;
44.   if I <> nil then
45.     Writeln('Got interface OK. Calling it');
46.   I.DoSomething;
47.   I.DoItAll;
48. end.

The rest of the code was complete and utter nonsense, so it might be better to remove it completely.
At least now the code works and does not leak anymore. Two minutes...

[engkin]

That page was written in 2009.

[Thaddy]

That page was written in 2009.

In 2009 the rules were the same. I corrected it (somewhat). At least no leaks and a similar intention. Still demands further attention. (COM vs CORBA).
You can do a lot of DIY on that entry, but at least part of it is repaired.

[Warfley]

Well your example (even though I think it is more useful) does not show the same thing as the one in the wiki article.  In the wiki it shows how to delegate the interface functionality to a member, your just shows how to use interfaces "normally".

[Thaddy]

Agree, hence I added DIY. A two minutes edit can not provide the spectrum.
I will see if I can come up with a simple example of proper delegation.

(My first concern was leaks)

[PierceNg]

Agree, hence I added DIY. A two minutes edit can not provide the spectrum.
I will see if I can come up with a simple example of proper delegation.

(My first concern was leaks)

How about an example where the two classes implementing the interface are not related to each other? I think that'll demonstrate the value of interfaces even better than having TDerivedObject subclass TBaseObject.

[Thaddy]

Will do. Adapted example

[Zvoni]

Will do. Adapted example

Since you're cleaning up the Wiki, would you mind take a look at this article?
https://wiki.lazarus.freepascal.org/Understanding_Interfaces

IMO, this Article shed's no light on the power of interfaces (especially the last code-sample. Basically you could remove the IRecycable-Type, change the class-def of the other two classes - No TInterfacedObject etc., and the code would still work)

[devEric69]

Hello @everyone,

Would an article with a T[Contained|Aggregated]Object example (explaining how to use interfaces in such classes in order to remain in the explicit origineelle Free Object Pascal (Create..Free) memory management paradigm) be useful ( source: https://forum.lazarus.freepascal.org/index.php/topic,46181.msg328478.html#msg328478; personally, I don't like reference counting. I prefer to keep control over explicitly destroy everything that I've previously created)?

[Thaddy]

You are right, but that takes a bit more effort. We have to review all entries related to interfaces. And there are morons advocating CORBA over COM: that is not a bad thing, but we will need to exlpain that CORBA interfaces are nor automatically released. And so forth.
wiki's are in more ways than one unreliable.