Новое ключевое слово static в Delphi

Недавно я переводил пост Почему методы класса должны быть помечены словом "static", чтобы их можно было использовать в качестве функции обратного вызова? Реймонда Чена. Там я оставил весь код "как есть" - на C++. Здесь я рассмотрю этот вопрос с точки зрения Delphi.

Как известно, в языке есть такие сущности как процедуры/функции и методы. Причём начинающие программисты часто путают эти два понятия.

Функция (в дальнейшем здесь будет также подразумеваться и процедура) - это код. Процедурная переменная - это указатель на код. Например:

type
  TDoSomethingFunc = function(const P1, P2, P3: Integer): Integer;

function DoSomething(const A, B, C: Integer): Integer;
begin
  Result := (A + B) * C;
end;

...

var
  Func: TDoSomethingFunc;
  I: Integer;

...

  Func := DoSomething;
  I := Func(1, 2, 3);
  ShowMessage(IntToStr(I));

Метод - это тоже код, но код, связанный с классом. Указатель на метод - это ссылка на код + ссылка на конкретный объект. Например:

type
  TDoSomethingFunc = function(const P1, P2, P3: Integer): Integer of object;

type
  TSomeObj = class
    function DoSomething(const A, B, C: Integer): Integer;
  end;

function TSomeObj.DoSomething(const A, B, C: Integer): Integer;
begin
  Result := (A + B) * C;
end;

...

var
  Func: TDoSomethingFunc;
  Obj: TSomeObj;
  I: Integer;

...

  Obj := TSomeObj.Create;
  try
    Func := Obj.DoSomething;
    I := Func(1, 2, 3);
  finally
    Obj.Free;
  end;
  ShowMessage(IntToStr(I));

Когда путают одно с другим компилятор чаще всего показывает такое сообщение: "Incompatible types: regular procedure and method pointer". Чаще всего или забывают писать "of object" в объявлении своих процедурных типов или пытаются передать в функцию (чаще всего как callback - т.е. функцию обратного вызова) метод класса вместо обычной функции (а самым упорным это иногда удаётся).

Что делает эти две сущности такими принципиально несовместимыми? Функция - это просто код. Она не имеет связи с данными, отличными от тех, что передаются в её параметры. Методы класса помимо работы с параметрами (как и обычная функция) ещё могут оперировать с данными объекта (вот оно: "код" vs "код + данные"), например:

type
  TDoSomethingFunc = function(const P1, P2: Integer): Integer of object;

type
  TSomeObj = class
    P3: Integer;
    function DoSomething(const A, B: Integer): Integer;
  end;

function TSomeObj.DoSomething(const A, B: Integer): Integer;
begin
  Result := (A + B) * P3;
end;

...

var
  Func: TDoSomethingFunc;
  Obj: TSomeObj;
  I: Integer;

...

  Obj := TSomeObj.Create;
  try
    Obj.P3 := 3;
    Func := Obj.DoSomething;
    I := Func(1, 2);
  finally
    Obj.Free;
  end;
  ShowMessage(IntToStr(I));

С функциями такое невозможно - обратите внимание, как вы манипулируете с P3 (он же: Self.P3) в методе. Собственно сам объект (это встроенная переменная Self) неявно передаётся в метод первым параметром. Поэтому, если метод объявлен как function(const P1, P2: Integer): Integer of object - с двумя параметрами, то, на самом деле, он трактуется как функция с тремя параметрами: function(Self: TSomeObj; const P1, P2: Integer): Integer. Именно это различие (на бинарном уровне) делает несовместимыми обычные функции и методы.

Соответственно, указатель на обычную функцию - это просто указатель (pointer), только что типизированный (это я про TDoSomethingFunc) - т.е. 4 байта. А вот указатель на метод - это уже запись или, если будет угодно, два указателя - один на код, второй - на данные, т.е. всего 8 байт.

Понятно, что если у вас что-то предназначено для передачи указателя на функцию, то никакими силами указатель на метод вы туда не пропихнёте. Хотя бы потому, что размер у них разный.

Ещё в Delphi есть классовые методы. Это такие методы, которые можно вызывать не имея на руках объект. В этом случае вместо объекта в неявный параметр Self передаётся информация о классе. Т.е. в классовых методах вы не можете использовать информацию о конкретном объекте (например, читать/писать его поля), но можете использовать информацию о классе - например, вызывать конструктор класса. Также методы класса могут быть виртуальными. Заметим, что сигнатура функции, реализующей метод, всё ещё совпадает с сигнатурой обычного метода: неявный параметр (данные класса вместо Self) + все явные параметры метода.

Например:

type
  TDoSomethingFunc = function(const P1, P2: Integer): Integer of object;

type
  TSomeObj = class
    P3: Integer;
    class function DoSomething(const A, B: Integer): Integer;
  end;

class function TSomeObj.DoSomething(const A, B: Integer): Integer;
begin
  Result := (A + B); // поскольку P3 имеет смысл только при наличии конкретного объекта, то здесь его использовать не получится
end;

...

var
  Func: TDoSomethingFunc;
  I: Integer;

...

  // Можно использовать классовый метод без экземпляра:
  Func := TSomeObj.DoSomething;
  I := Func(1, 2);
  ShowMessage(IntToStr(I));

Теперь ещё один шажок и мы переходим к тому, о чём говорил Реймонд Чен. Классовый метод можно объявить статическим (только в новых версиях Delphi). В этом случае у него не будет неявного параметра. Разумеется, при этом он не может использовать информацию экземпляра и класса. Зато он и не отличается от обычной функции.

Рассматривая пример с потоком, вот что мы могли бы написать в старых Delphi без поддержки статических классовых методов:

type
  TMyThread = class
  private
    FHandle: THandle;
    FID: Cardinal;
    function Execute: DWord;
  public
    constructor Create;
    destructor Destroy; override;
  end;

// Вспомогательная функция, не принадлежащая классу
function ThreadProc(Param: Pointer): DWord; stdcall;
begin
  TMyThread(Param).Execute;
end;

{ TMyThread }

constructor TMyThread.Create;
begin
  IsMultiThread := True;
  FHandle := CreateThread(nil, 0, @ThreadProc, Self, 0, FID);
end;

destructor TMyThread.Destroy;
begin
  CloseHandle(FHandle);
  FHandle := 0;
  FID := 0;
  inherited;
end;

function TMyThread.Execute: DWord;
begin
  MessageBox(0, 'Hello from thread', 'Information', MB_OK or MB_ICONINFORMATION);
  Result := 0;
end;

Теперь, с введением нового ключевого слова static, появилась возможность писать так:

type
  TMyThread = class
  private
    FHandle: THandle;
    FID: Cardinal;
    class function ThreadProc(Param: Pointer): DWord; stdcall; static;
    function Execute: DWord;
  public
    constructor Create;
    destructor Destroy; override;
  end;

{ TMyThread }

constructor TMyThread.Create;
begin
  IsMultiThread := True;
  FHandle := CreateThread(nil, 0, @ThreadProc, Self, 0, FID);
end;

destructor TMyThread.Destroy;
begin
  CloseHandle(FHandle);
  FHandle := 0;
  FID := 0;
  inherited;
end;

class function TMyThread.ThreadProc(Param: Pointer): DWord;
begin
  Result := TMyThread(Param).Execute;
end;

function TMyThread.Execute: DWord;
begin
  MessageBox(0, 'Hello from thread', 'Information', MB_OK or MB_ICONINFORMATION);
  Result := 0;
end;

При этом Реймонд говорит о том, что если у Execute сделать модель вызова stdcall, то бинарные сигнатуры параметра CreateThread, методов ThreadProc и Execute совпадут - поэтому, мол, умный компилятор уменьшит код ThreadProc до простого jmp. Увы, но компилятор Delphi не настолько умён - в этом случае он генерирует полный вызов вместе с передачей параметра.

Разумеется, можно сделать и так (обратите внимание на stdcall):

type
  TMyThread = class
  private
    FHandle: THandle;
    FID: Cardinal;
    function Execute: DWord; stdcall;
  public
    constructor Create;
    destructor Destroy; override;
  end;

{ TMyThread }

constructor TMyThread.Create;
begin
  IsMultiThread := True;
  FHandle := CreateThread(nil, 0, @TMyThread.Execute, Self, 0, FID);
end;

destructor TMyThread.Destroy;
begin
  CloseHandle(FHandle);
  FHandle := 0;
  FID := 0;
  inherited;
end;

function TMyThread.Execute: DWord;
begin
  MessageBox(0, 'Hello from thread', 'Information', MB_OK or MB_ICONINFORMATION);
  Result := 0;
end;

Но, как было сказано, это не рекомендуется, т.к. здесь во-первых, есть шанс сильно напутать (так можно делать только при условии полной бинарной совместимости, что будет далеко не всегда - ключевой момент здесь: передача контекста именно первым параметром), кроме того, последний вариант опирается на тот факт, что параметр у CreateThread "случайно" совпал с сигнатурой TMyThread.Execute - это называется использование деталей реализации.

Ещё ссылки для дальнейшего чтения:
- Перевод справки Delphi.
- Основы работы с Win API в VCL-приложениях.
- Про локальные функции.
- Методы vs функции, классовые vs статик методы и всё остальное.