Question

I have a class that implements an interface, which is made available for plugins.
The declaration of class is quite simple. There is only one instance of this class for an entire application. When the function that returns the interface is called, it calls _AddRef on the retrieved interface before passing it back as result. Unfortunately it works until I try to free the object (see “finalization” section) – it reports Invalid Pointer Operation. If I comment it out, it works fine (however FastMM reports memory leaks, so the object is not being freed).

Here is the part of the code in the function that returns the interface (in fact it is an overridden QueryInterface of my “ServicesManager” class).

if ConfigManager.GetInterface(IID, obj) then
begin
  ISDK_ConfigManager(obj)._AddRef;
  result:= 0;
end

and the code of ConfigManager class …

type
  TConfigManager = class(TInterfacedObject, ISDK_ConfigManager)
  private
  ... 
  end;

var
  ConfigManager: TConfigManager;
implementation

...

initialization
  ConfigManager:= TConfigManager.Create();
finalization
  if ConfigManager <> nil then
    FreeAndNil(ConfigManager); //if I comment it out, it leaks the memory but no Invalid Ptr. Op. raises

What am I doing wrong?
I need to pass a reference to exactly this instance of ConfigManager.

Answer 1

The number one piece of advice you’ll hear when dealing with interfaces is to never mix interface references with object references. What this means is that once you start referring to an object via an interface reference, you cease to refer to it via an object reference. Ever.

The reason is that the first time you assign an interface variable, the reference count of the object will become 1. When that variable goes out of scope or gets assigned a new value, the reference count becomes zero, and the object frees itself. This is all without any modification of the original object-reference variable, so when you later try to use that variable, it’s not a null pointer, but the object it referred to is gone — it’s a dangling reference. When you try to free something that doesn’t exist, you get an invalid-pointer-operation exception.

Declare your ConfigManager variable as an interface. Don’t free it yourself. Once you do that, you can move the entire declaration of TConfigManager into the implementation section because no code outside that unit will ever refer to it.

Also, there’s rarely any reason to provide your own implementation of QueryInterface. (You said you overrode it, but that’s impossible since it’s not virtual.) The one provided by TInterfacedObject should be sufficient. The one you’re providing is actually causing a memory leak because you’re incrementing the reference count when you shouldn’t be. GetInterface already calls _AddRef (by performing an interface assignment), so you’re returning objects with inflated reference counts.