Умные указатели Delphi XE7

Вы должны объявить свою ссылочную переменную как ISmartPointer<TPerson>:

var
  pperson : ISmartPointer<TPerson>;

Следующий код также будет компилироваться, но в этом случае он не будет автоматически освобождать память, потому что, когда вы сохраняете экземпляр объекта с подсчетом ссылок в ссылку на объект, вы нарушаете его механизм подсчета ссылок. В зависимости от кода это может привести к утечке памяти или преждевременному разрушению экземпляра базового объекта.

var
  pperson : TSmartPointer<TPerson>;

begin
  pperson := TSmartPointer<TPerson>.Create();
  pperson.Invoke.Name := 'John Doe';

Наконец, следующий код иллюстрирует правильное использование интеллектуального указателя:

var
  pperson : ISmartPointer<TPerson>;   // note pperson is ISmartPointer<TPerson>

begin
  pperson := TSmartPointer<TPerson>.Create();
  pperson.Name := 'John Doe';

Основные сведения об интерфейсе

Интерфейс определяет контракт - функциональность, которую должен иметь класс, реализующий интерфейс, без предоставления конкретной реализации. Объявление интерфейса IFoo означает, что когда у вас есть ссылка на IFoo, вы можете вызвать метод Foo для этой ссылки, но это все, что вы можете.

IFoo = interface
  procedure Foo;
end;

Когда класс реализует интерфейс, он должен реализовывать все методы из этого интерфейса. Метод Foo из IFoo будет отображаться в метод Foo из TFoo или TOtherFoo. Реализация конкретных интерфейсов может быть разной в разных классах.

TFoo = class(TInterfacedObject, IFoo)
public
  procedure Foo;
  procedure Bar;
end;

TOtherFoo = class(TInterfacedObject, IFoo)
public
  procedure Foo;
end;

procedure TFoo.Bar;
begin
  writeln('Bar');
end;

procedure TFoo.Foo;
begin
  writeln('Foo');
end;

procedure TOtherFoo.Foo;
begin
  writeln('Other Foo');
end;

var
  foo: IFoo;
  f: TFoo;

  foo := TFoo.Create;
  foo.Foo; // Output -> Foo

  // Compiler error -> foo is interface reference and only knows Foo from TFoo
  foo.Bar;

  foo := TOtherFoo.Create;
  foo.Foo; // Output -> Other Foo

  // Mixing object reference with reference counted object instance -> memory leaks
  f := TFoo.Create;
  foo.Foo; // output -> Foo
  foo.Bar; // f is TFoo object reference, and it knows everything from TFoo

Как на самом деле работает умный указатель

ISmartPointer<T> объявлен как анонимная функция.

ISmartPointer<T> = reference to function: T;

Вышеупомянутое объявление эквивалентно интерфейсу с функцией Invoke

ISmartPointer<T> = interface
  function Invoke: T;
end;

Разница между ними (интересующая нас здесь) заключается в том, что с анонимной функцией / методами вам не нужно явно вызывать Invoke; компилятор сделает это за вас.

Поскольку ISmartPointer<T> является анонимной функцией, которая фактически является интерфейсом в объявлении класса TSmartPointer<T>, метод Invoke будет сопоставлен с ISmartPointer<T>.

  TSmartPointer<T: class, constructor> = class(TInterfacedObject, ISmartPointer<T>)
  private
    FValue: T;
  public
    constructor Create; overload;
    constructor Create(AValue: T); overload;
    destructor Destroy; override;
    function Invoke: T;
  end;

var
  pperson : ISmartPointer<TPerson>;

Поэтому, когда вы пишете pperson.Name за кулисами, это переводится в pperson.Invoke вызов функции, который возвращает экземпляр TPerson из FValue, а TPerson имеет свойство Name, которое компилятор может распознать.

Поскольку TSmartPointer<T> является классом с подсчетом ссылок, при использовании ISmartPointer<T> ссылок базовый экземпляр объекта TSmartPointer<T> вместе с экземпляром T, который он содержит в FValue, будет автоматически освобожден, когда ссылка ISmartPointer<T> выходит за пределы области действия или вы устанавливаете для него nil в код.