HN 日本語サマリー

← 一覧へ戻る
プログラミング

プログラマーのためのモダンObject Pascal入門

Modern Object Pascal Introduction for Programmers (castle-engine.io)

204 pointsby birdculture90 コメント

要約

この記事は、クラス、ユニット、ジェネリクス、インターフェイスなどのモダンな機能を備えたObject Pascal言語を紹介する書籍の抜粋です。プログラミング経験者を対象に、基本的な構文からクラス、例外処理、ランタイムライブラリ、高度な機能までを網羅しています。Free Pascal Compiler (FPC) やLazarus、Delphiといった開発環境についても触れています。

全文翻訳

プログラマーのためのモダンObject Pascal入門

目次

1. この書籍について

私はモダンObject Pascalを説明したいと思いました。これは、クラス、ユニット、ジェネリクス、インターフェース、そしてあなたが期待する他のモダンな機能を持つプログラミング言語です。私は、基本的な機能から高度な機能まで、すべての言語機能がどのように一貫した全体として結びついているかを示したいと思いました。

また、この書籍を実用的で簡潔なものにしたいと思いました。そのため、あなたはすでにプログラミングの経験があると仮定し、「変数を宣言する方法」といったことについて話すことができ、「変数とは何か、その目的は何か」といった長い説明を避けることができます。基本をカバーする際には、簡単な説明をしてから次に進みます。変数とは、ある値のためのコンテナです。コンテナには名前があり、保持する値は時間とともに変化する可能性があります。

私はモダンObject Pascalにおけるモダンという言葉を強調します。なぜなら、Pascalは大きく進化しており、多くの人が昔学校で学んだTurbo Pascalなどとはかなり異なるからです。機能面では、モダンPascalはC++、Java、C#と非常に似ています。

  • クラス、ユニット、インターフェース、ジェネリクスなど、あなたが期待するすべてのモダンな機能があります。
  • 高速なネイティブコードにコンパイルされます。
  • 非常に型安全です。
  • ハイレベルですが、必要であればローレベルにも対応できます。

また、ツールやライブラリの活発なエコシステムもあります。いくつか例を挙げると:

  • Pascalには、Free Pascal Compilerと呼ばれる、優れた、ポータブルでオープンソースのコンパイラがあります。http://freepascal.org/
  • そして、Lazarusと呼ばれる、それに付随するIDE(エディタ、デバッガ、ビジュアルコンポーネントライブラリ、フォームデザイナ)があります。http://lazarus.freepascal.org/
  • Embarcadero製のプロプライエタリで商用のコンパイラおよびIDEであるDelphiもあります。https://www.embarcadero.com/products/Delphi
  • 多くのライブラリ(FPCとDelphiの両方用)が利用可能です。詳細はhttps://github.com/Fr0sT-Brutal/awesome-pascalを参照してください。
  • VS Codeのような既存のエディタもサポートしています。詳細はhttps://castle-engine.io/vscodeを参照してください。
  • 私自身は、Castle Game Engineの作成者です。https://castle-engine.io/これは、Windows、Linux、FreeBSD、macOS、Android、iOS、Nintendo Switch、WebGLなど、多くのプラットフォームでゲームを作成するためにモダンPascalを使用するオープンソースの3Dおよび2Dゲームエンジンです。

2. 基本

2.1. "Hello world"プログラム
// すべてのモダンなFPCソースでこの行を使用してください。
{$ifdef FPC} {$mode objfpc}{$H+}{$J-} {$endif}

// 以下はWindows上のコンソールプログラムに必要です。
// そうしないと(Delphiの場合)、デフォルトはコンソールなしのGUIプログラムになります。
{$ifdef MSWINDOWS} {$apptype CONSOLE} {$endif}

program MyProgram;
begin
  WriteLn('Hello world!');
end.

これはコンパイルして実行できる完全なプログラムです。

  • コマンドラインFPCを使用する場合、新しいファイルmyprogram.dprを作成し、fpc myprogram.dprを実行するだけです。
  • Lazarusを使用する場合、新しいプロジェクト(メニュー「Project → New Project → Simple Program」)を作成します。このコードをプログラムソースコードとして貼り付けます。「Run → Compile」メニュー項目(またはショートカットCtrl + F9)でコンパイルします。
  • Delphiを使用する場合も、新しいプロジェクト(メニュー「File → New → Console Application - Delphi」)を作成します。このコードをプログラムソースコードとして貼り付けます。「Project → Compile」メニュー項目(またはショートカットCtrl + F9)でコンパイルします。

これはコマンドラインプログラムなので、コンパイルされた実行可能ファイルをコマンドラインから実行するだけです。

注意LazarusまたはDelphi IDEから「Run」メニュー項目(両方のIDEでショートカットF9)を使用して実行することもできます。この場合、コンソールが表示されてすぐに消えることに注意してください。それを避ける最も簡単な方法は、アプリケーションの最後にReadln(Enterキーを待つ)を追加することです。

この記事の残りの部分はObject Pascal言語について説明しているので、コマンドラインのものよりも派手なものは期待しないでください。クールなものを見たい場合は、Lazarus(「Project → New Project → Application」)またはDelphi(「File → New → Multi-Device Application」)で新しいGUIプロジェクトを作成してください。これで、快適なビジュアルコンポーネントライブラリを使用した、クロスプラットフォームでネイティブなルックアンドフィールの動作するGUIアプリケーションが完成します。

Pascalコンパイラには、ネットワーキング、GUI、データベース、ファイルフォーマット(XML、JSON、画像…)、スレッディングなど、必要なものがすべて揃った標準ユニットがたくさん付属しています。私はすでにCastle Game Engineについて言及しましたね!:)

2.2. コンパイラとFPCの"構文モード"

この書籍、すべてのテキストとPascalの例は、2つのモダンなPascalコンパイラをサポートするように書かれています:

  1. Free Pascal Compiler (FPC)、オープンソースのPascalコンパイラで、Lazarus IDEでも使用されます。
  2. Delphi、Embarcadero製のプロプライエタリなPascalコンパイラ。

この書籍では、両方のコンパイラを完全にサポートします。

話を少し複雑にするために、FPCコンパイラには複数の「構文モード」があります。この書籍では、FPC開発者によって推奨されており、LazarusまたはCastle Game Engineで作成された新しいPascalプロジェクトのデフォルトであるObjFpc構文モードを示すことにしました。これはDelphi構文モードとは少し異なります。Delphi構文モードは、Delphiで実装されているPascal言語と最も互換性があります。私たちはここで詳細な比較を書いています。

しかし、Pascalを学び始めたばかりのあなたが今、これらの違いについて読みたくはないでしょう!

コンパイラ間でも、FPCのObjFpcモードとDelphiモード間でも、違いはわずかです。例の中で{$ifdef FPC} …​ {$endif}句が表示されることがあるかもしれませんが、これはコードをFPC ObjFpcモードとDelphiの両方で有効にします。これらのケースの一部で{$ifdef FPC_OBJFPC} …​ {$endif}を使用すると、より正確になりますが、さらに複雑に見えます。プロジェクトがこれらのコンパイラのいずれかのみをターゲットにしている場合は、コードを単純化できます。コンパイラ用のバリアントを選択し、{$ifdef …​}, {$endif}の部分を削除してください。

2.3. 関数、プロシージャ、プリミティブ型
{$ifdef FPC} {$mode objfpc}{$H+}{$J-} {$endif}
{$ifdef MSWINDOWS} {$apptype CONSOLE} {$endif}

program MyProgram;

procedure MyProcedure(const A: Integer);
begin
  WriteLn('A + 10 is: ', A + 10);
end;

function MyFunction(const S: string): string;
begin
  Result := S + 'strings are automatically managed';
end;

var
  X: Single;
begin
  WriteLn(MyFunction('Note: '));
  MyProcedure(5);

  // "/" を使用した除算は常に浮動小数点の結果になります。
  // 整数除算には "div" を使用してください。
  X := 15 / 5;
  WriteLn('X is now: ', X); // 科学表記
  WriteLn('X is now: ', X:1:2); // 小数点以下2桁
end.

関数から値を返すには、特別な変数Resultに何かを代入します。Resultはローカル変数のように自由に読み書きできます。

function MyFunction(const S: string): string;
begin
  Result := S + 'something';
  Result := Result + ' something more!';
  Result := Result + ' and more!';
end;

関数の名前(上記の例ではMyFunction)を変数のように扱って代入することもできます。しかし、代入式の右辺で使用すると「怪しく」見えるため、新しいコードでは推奨しません。関数の結果を読み取ったり設定したりしたい場合は、常にResultを使用してください。

関数自体を再帰的に呼び出すことができます。引数なしの関数を再帰的に呼び出す場合は、括弧()を必ず指定してください(Pascalでは通常、引数なしの関数の括弧を省略できますが)。これにより、引数なしの関数への再帰呼び出しが、その関数の現在の結果へのアクセスと区別されます。例:

function SumIntegersUntilZero: Integer;
var
  I: Integer;
begin
  ReadLn(I);
  Result := I;
  if I <> 0 then
    Result := Result + SumIntegersUntilZero();
end;

Exitを呼び出すと、プロシージャまたは関数の実行が終了し、最後のend;に到達する前に終了します。引数なしのExitを関数で呼び出すと、最後にResultとして設定された値が返されます。Exit(X)という構文を使用して、関数の結果を設定してすぐに終了することもできます。これはC言語のような言語のreturn X構文と似ています。

function AddName(const ExistingNames, NewName: string): string;
begin
  if ExistingNames = '' then
    Exit(NewName);
  Result := ExistingNames + ', ' + NewName;
end;

関数の結果は破棄できることに注意してください。任意の関数をプロシージャのように使用できます。これは、関数が結果を計算する以外に何らかの副作用(例:グローバル変数を変更する)を持つ場合に意味があります。例:

var
  Count: Integer;
  MyCount: Integer;

function CountMe: Integer;
begin
  Inc(Count);
  Result := Count;
end;

begin
  Count := 10;
  CountMe; // 関数の結果は破棄されますが、関数は実行され、Countは11になります
  MyCount := CountMe; // 関数の結果を使用します。MyCountはCount(現在は12)と等しくなります。
end.
2.4. テスト(if)

if .. thenまたはif .. then .. elseを使用して、ある条件が満たされた場合にコードを実行します。C言語のような言語とは異なり、Pascalでは条件を括弧で囲む必要はありません。

var
  A: Integer;
  B: boolean;
begin
  if A > 0 then
    DoSomething;

  if A > 0 then
  begin
    DoSomething;
    AndDoSomethingMore;
  end;

  if A > 10 then
    DoSomething
  else
    DoSomethingElse;

  // 上記と同等
  B := A > 10;
  if B then
    DoSomething
  else
    DoSomethingElse;
end;

elseは最後のifとペアになります。したがって、これは期待どおりに機能します:

if A <> 0 then
  if B <> 0 then
    AIsNonzeroAndBToo
  else
    AIsNonzeroButBIsZero;

上記のネストしたifの例は正しいですが、このような場合、ネストしたifをbegin…endブロック内に配置する方が良いことが多いです。これにより、コードが読者にとってより明白になり、インデントを間違えても明白なままになります。以下の例は改善されたバージョンです。コードにelse句を追加または削除すると、それがAテストまたはBテストのどちらに適用されるかが明白になるため、エラーが発生しにくくなります。

if A <> 0 then
begin
  if B <> 0 then
    AIsNonzeroAndBToo
  else
    AIsNonzeroButBIsZero;
end;
2.5. 論理演算子、関係演算子、ビット演算子

論理演算子はand、or、not、xorと呼ばれます。それらの意味はおそらく明白でしょう(xorが何をするか不確かな場合は、「排他的論理和」を検索してください!)。これらはブール値引数を取り、ブール値を返します。両方の引数が整数値の場合、ビット演算子としても機能し、整数を返します。

関係(比較)演算子は=、<>、>、<、<=、>=です。C言語のような言語に慣れている場合、Pascalでは2つの値を比較する(それらが等しいかどうかをチェックする)ために単一の等号A = Bを使用することに注意してください(C言語のA == Bとは異なります)。Pascalの特別な代入演算子は:=です。

論理演算子(またはビット演算子)は、関係演算子よりも高い優先順位を持ちます。計算の順序を希望どおりにするために、一部の式を括弧で囲む必要がある場合があります。

例えば、これはコンパイルエラーになります:

var
  A, B: Integer;
begin
  if A = 0 and B <> 0 then ... // 間違った例

上記はコンパイルに失敗します。なぜなら、コンパイラは最初に式の途中でビット演算andを実行しようとするからです:(0 and B)。これは整数値を返すビット演算です。次に、コンパイラは=演算子を適用し、ブール値A = (0 and B)を生成します。そして最後に、ブール値A = (0 and B)と整数値0を比較しようとした後に「型不一致」エラーが発生します。

これは正しいです:

var
  A, B: Integer;
begin
  if (A = 0) and (B <> 0) then ...

短絡評価が使用されます。この式を検討してください:

if MyFunction(X) and MyOtherFunction(Y) then...
  • MyFunction(X)が最初に評価されることが保証されます。

  • そして、MyFunction(X)がfalseを返した場合、式の値はわかります(false and whateverの値は常にfalseです)、そしてMyOtherFunction(Y)はまったく実行されません。

  • or式にも同様のルールがあります。式がtrueであることがわかっている場合(最初のオペランドがtrueであるため)、2番目のオペランドは評価されません。

  • これは特に次のような式を書く場合に役立ちます:

    if (A <> nil) and A.IsValid then...
    

    これは、Aがnilの場合でも正常に機能します。キーワードnilは、数値として表現された場合にゼロと等しいポインタです。多くの他のプログラミング言語ではヌルポインタと呼ばれます。

2.6. 単一の式を複数の値でテストする(case)

ある式の値に応じて異なるアクションを実行する必要がある場合、case .. of .. endステートメントが役立ちます。

case SomeValue of
  0: DoSomething;
  1: DoSomethingElse;
  2: begin
       IfItsTwoThenDoThis;
       AndAlsoDoThis;
     end;
  3..10: DoSomethingInCaseItsInThisRange;
  11, 21, 31: AndDoSomethingForTheseSpecialValues;
  else DoSomethingInCaseOfUnexpectedValue;
end;

else句はオプションです(C言語のような言語のdefaultに対応します)。どの条件も一致せず、elseもない場合、何も起こりません。

C言語のような言語から来て、この言語のswitchステートメントと比較すると、自動的なフォールスルーがないことに気づくでしょう。これはPascalにおける意図的な恩恵です。break命令を覚える必要はありません。各実行で、caseのブランチは最大で1つだけ実行されます。それだけです。

2.7. 列挙型と順序型、セット、固定長配列

Pascalの列挙型は非常に便利で不透明な型です。他の言語のenumよりもはるかに頻繁に使用するでしょう!:)

type
  TAnimalKind = (akDuck, akCat, akDog);

慣習として、enumの名前には型の2文字のショートカットをプレフィックスとして付けます。したがって、akは「Animal Kind」のショートカットです。これは他の言語のenumよりもはるかに頻繁に使用するでしょう。これは便利な慣習です。なぜなら、enumの名前はユニット(グローバル)の名前空間にあるからです。したがって、akプレフィックスを付けることで、他の識別子との衝突の可能性を最小限に抑えることができます。

注意名前での衝突は致命的な問題ではありません。異なるユニットが同じ識別子を定義しても問題ありません。しかし、コードを理解しやすくgrepしやすくするために、衝突を避けることは良い考えです。

| | |
| 注意 | コンパイラディレクティブ{$scopedenums on}を使用すると、enum名をグローバル名前空間に配置するのを避けることができます。これにより、TAnimalKind.akDuckのように型名で修飾してアクセスする必要があります。この状況ではakプレフィックスの必要性がなくなり、おそらくenumをDuck, Cat, Dogと呼ぶだけになるでしょう。これはC#のenumに似ています。 |

列挙型が不透明であるということは、整数との間で直接代入できないことを意味します。しかし、特別な用途のために、Ord(MyAnimalKind)を使用してenumを強制的にintに変換したり、TAnimalKind(MyInteger)と型キャストしてintを強制的にenumに変換したりできます。後者の場合、MyIntegerが良い範囲(0からOrd(High(TAnimalKind))まで)にあるかどうかを最初に確認してください。

列挙型と順序型は配列インデックスとして使用できます:

type
  TArrayOfTenStrings = array [0..9] of string;
  TArrayOfTenStrings1Based = array [1..10] of string;

  TMyNumber = 0..9;
  TAlsoArrayOfTenStrings = array [TMyNumber] of string;

  TAnimalKind = (akDuck, akCat, akDog);
  TAnimalNames = array [TAnimalKind] of string;

これらを使用してセット(内部的にはビットフィールド)を作成することもできます:

type
  TAnimalKind = (akDuck, akCat, akDog);
  TAnimals = set of TAnimalKind;
var
  A: TAnimals;
begin
  A := [];
  A := [akDuck, akCat];
  A := A + [akDog];
  A := A * [akCat, akDog];
  Include(A, akDuck);
  Exclude(A, akDuck);
end;
2.8. ループ(for, while, repeat, for .. in)
{$ifdef FPC} {$mode objfpc}{$H+}{$J-} {$endif}
{$ifdef MSWINDOWS} {$apptype CONSOLE} {$endif}
{$R+} // 範囲チェックオン - デバッグに便利

var
  MyArray: array [0..9] of Integer;
  I: Integer;
begin
  // 初期化
  for I := 0 to 9 do
    MyArray[I] := I * I;

  // 表示
  for I := 0 to 9 do
    WriteLn('Square is ', MyArray[I]);

  // 上記と同じ
  for I := Low(MyArray) to High(MyArray) do
    WriteLn('Square is ', MyArray[I]);

  // 上記と同じ
  I := 0;
  while I < 10 do
  begin
    WriteLn('Square is ', MyArray[I]);
    I := I + 1; // または "I += 1", または "Inc(I)"
  end;

  // 上記と同じ
  I := 0;
  repeat
    WriteLn('Square is ', MyArray[I]);
    Inc(I);
  until I = 10;

  // 上記と同じ
  // 注意: ここではIはMyArrayの値ではなく、インデックスを列挙します
  for I in MyArray do
    WriteLn('Square is ', I);
end.

repeatとwhileループについて:

これらのループタイプの間には2つの違いがあります:

  1. ループ条件の意味が逆です。while .. doでは継続するタイミングを指示しますが、repeat .. untilでは停止するタイミングを指示します。
  2. repeatの場合、条件は最初にチェックされません。したがって、repeatループは少なくとも1回は必ず実行されます。

for I := …​ループについて:

for I := .. to .. do …​構文はC言語のようなforループに似ています。ただし、ループの反復を制御するために任意の操作/テストを指定できないため、より制約があります。これは厳密に連続する数値(または他の順序型)を反復処理するためのものです。唯一の柔軟性は、数値を降順にするためにtoの代わりにdowntoを使用できることです。

その見返りとして、見た目がクリーンで、実行時に非常に最適化されています。特に、下限と上限の式はループが開始される前に一度だけ計算されます。

ループカウンタ変数(この例ではI)の値は、最適化の可能性により、ループが終了した後は未定義と見なされるべきです。ループ後のIの値へのアクセスは、コンパイラ警告を引き起こす可能性があります。ただし、BreakまたはExitでループを早期に終了した場合を除きます。その場合、カウンタ変数は最後の値を保持することが保証されます。

for I in …​ループについて:

for I in .. do ..は、多くのモダンな言語のforeach構文に似ています。多くの組み込み型でインテリジェントに動作します:

  • 配列内のすべての値を反復処理できます(上記の例)。

  • 列挙型のすべての値を反復処理できます:

    var
      AK: TAnimalKind;
    begin
      for AK in TAnimalKind do...
    
  • セットに含まれるすべての項目を反復処理できます:

    var
      Animals: TAnimals;
      AK: TAnimalKind;
    begin
      Animals := [akDog, akCat];
      for AK in Animals do ...
    
  • そして、カスタムリスト型(ジェネリックか否かに関わらず)、例えばTObjectListやTFPGObjectListでも動作します。

    {$ifdef FPC} {$mode objfpc}{$H+}{$J-} {$endif}
    {$ifdef MSWINDOWS} {$apptype CONSOLE} {$endif}
    
    uses
      SysUtils, Generics.Collections;
    
    type
      TMyClass = class
        I, Square: Integer;
      end;
      TMyClassList = {$ifdef FPC}specialize{$endif} TObjectList<TMyClass>;
    
    var
      List: TMyClassList;
      C: TMyClass;
      I: Integer;
    begin
      List := TMyClassList.Create(true); // true = 子オブジェクトを所有する
      try
        for I := 0 to 9 do
        begin
          C := TMyClass.Create;
          C.I := I;
          C.Square := I * I;
          List.Add(C);
        end;
    
        for C in List do
          WriteLn('Square of ', C.I, ' is ', C.Square);
      finally
        FreeAndNil(List);
      end;
    end.
    

    まだクラスの概念を説明していないので、最後の例はまだ理解できないかもしれません。そのまま進んでください。後で理解できるようになります:)

2.9. 出力、ロギング

Pascalで文字列を単純に出力するには、WriteまたはWriteLnルーチンを使用します。後者は自動的に末尾に改行を追加します。

これはPascalの「魔法の」ルーチンです。可変個の引数を取り、それらはすべて表示時に文字列に変換されます。パディングと数値の精度を指定するための特別な構文があります。

WriteLn('Hello world!');
WriteLn('You can output an integer: ', 3 * 4);
WriteLn('You can pad an integer: ', 666:10);
WriteLn('You can output a float: ', Pi:1:4);

文字列に明示的に改行を使用するには、LineEnding定数(FPC RTLから)を使用します。(Castle Game Engineは、より短いNL定数も定義しています。)Pascal文字列はバックスラッシュの特殊シーケンスを解釈しないため、次のように記述しても:

WriteLn('One line.
Second line.'); // 間違った例

あなたが思うように動作しません。これは機能します:

WriteLn('One line.' + LineEnding + 'Second line.');

または単に:

WriteLn('One line.');
WriteLn('Second line.');

これはコンソールアプリケーションでのみ機能することに注意してください。メインプログラムファイルに{$apptype CONSOLE}({$apptype GUI}ではない)が定義されていることを確認してください。一部のオペレーティングシステムでは実際には関係なく常に機能しますが(Unix)、一部のオペレーティングシステムではGUIアプリケーションから何かを書き込もうとするとエラーになります(Windows)。

Castle Game Engine内:デバッグ情報を出力するには、WriteLnではなく、WriteLnLogまたはWriteLnWarningを使用してください。これらは常に有用な出力にリダイレクトされます。Unixでは標準出力。Windows GUIアプリケーションではログファイル。AndroidではAndroidロギング機能(adb logcatを使用すると表示されます)。WriteLnの使用は、コマンドラインアプリケーション(3Dモデルコンバータ/ジェネレータなど)を作成し、標準出力が利用可能であることを知っている場合に限定されるべきです。

2.10. 文字列への変換

任意の数の引数を(直接出力する代わりに)文字列に変換するには、いくつかのオプションがあります。

  • IntToStrやFloatToStrのような特殊な関数を使用して、特定の型を文字列に変換できます。さらに、Pascalでは文字列を単純に加算して連結できるため、次のような文字列を作成できます:'My int number is ' + IntToStr(MyInt) + ', and the value of Pi is ' + FloatToStr(Pi)。

    • 利点:絶対的に柔軟です。多くの型をカバーするXxxToStrのオーバーロードされたバージョンやそれに類するもの(FormatFloatなど)があります。それらのほとんどはSysUtilsユニットにあります。

    • もう一つの利点:逆関数との一貫性があります。文字列(例えばユーザー入力)を整数または浮動小数点数に戻すには、StrToInt、StrToFloatおよびそれに類するもの(StrToIntDefなど)を使用します。

    • 欠点:多くのXxxToStr呼び出しと文字列の長い連結は、見た目が良くありません。

  • Format関数は、Format('%d %f %s', [MyInt, MyFloat, MyString])のように使用されます。これはC言語のような言語のsprintf関数に似ています。パターン内のプレースホルダーに引数を挿入します。プレースホルダーはフォーマットを影響させるための特別な構文を使用できます。例えば、%.4fは小数点以下4桁の浮動小数点フォーマットになります。

    • 利点:パターン文字列と引数の分離がきれいに見えます。パターン文字列を変更したい場合(例えば翻訳時)に、引数に触れることなく簡単に行えます。

    • もう一つの利点:コンパイラマジックはありません。同じ構文を使用して、任意の型の任意の数の引数を独自のルーチンに渡すことができます(パラメータをarray of constとして宣言します)。その後、これらの引数をFormatに渡したり、パラメータリストを分解して好きなように処理したりできます。

    • 欠点:コンパイラはパターンが引数と一致するかどうかをチェックしません。間違ったプレースホルダ型を使用すると、実行時に例外が発生します(アクセス違反(セグメンテーション違反)エラーではなく、EConvertError例外)。

  • WriteStr(TargetString, …​)ルーチンはWrite(…​)とほぼ同じように動作しますが、結果はTargetStringに保存されます。

    • 利点:Writeのすべての機能、特にフォーマットの特殊構文(Pi:1:4など)をサポートします。

    • 欠点:フォーマットの特殊構文は「コンパイラマジック」であり、この種のルーチン専用に実装されています。これは時々問題になります。例えば、Pi:1:4のような特殊構文も許可する独自のルーチンMyStringFormatter(…​)を作成することはできません。この理由(および主要なPascalコンパイラでは長い間実装されていなかったため)から、この構文はあまり人気がありません。

3. ユニット

3.1. 概要

ユニットを使用すると、他のユニットやプログラムで使用するために、共通の(宣言可能なものすべて)ものをグループ化できます。これらは他の言語のモジュールやパッケージに相当します。それらは、他のユニットやプログラムで利用可能なものを宣言するインターフェースセクションと、その後の実装セクションを持ちます。

unit MyUnit;

{$ifdef FPC} {$mode objfpc}{$H+}{$J-} {$endif}

interface

procedure MyProcedure(const A: Integer);
function MyFunction(const S: string): string;

implementation

procedure MyProcedure(const A: Integer);
begin
  WriteLn('A + 10 is: ', A + 10);
end;

function MyFunction(const S: string): string;
begin
  Result := S + 'strings are automatically managed';
end;

end.

プログラムはusesキーワードを使用してユニットを使用できます:

{$ifdef FPC} {$mode objfpc}{$H+}{$J-} {$endif}
{$ifdef MSWINDOWS} {$apptype CONSOLE} {$endif}

program MyProgram;

uses
  MyUnit;

begin
  WriteLn(MyFunction('Note: '));
  MyProcedure(5);
end.
3.2. ユニットとプログラムで使用される拡張機能

ユニットファイルをMyUnitとしてmyunit.pasに保存します。つまり、小文字で.pas拡張子を付けます。

注意他の規約も可能です。例えば、FPCはユニットに他のファイル拡張子を許可します。また、一部のユーザーはユニットファイルに.ppを使用します(例:myunit.pp)。大文字小文字の使い分けも可能です。Windowsファイルシステムでは、大文字小文字は関係ありません。しかし、Unixファイルシステムでは重要であり、FPCはPascalのuses句で指定された正確な大文字小文字と同じ(つまりMyUnit.pas)またはすべて小文字(つまりmyunit.pas)のみを許可します。Pascalは大文字小文字を区別しないため、最初のルールは、ユーザーが異なる場所でユニット名を異なる大文字小文字で指定した場合に問題を引き起こすことがあります。全体として、プロジェクトでは単純な上記のルール「すべて小文字、.pas拡張子」を推奨します。これは最も一般的な確立された慣習と一致し、すべてのコンパイラとファイルシステムで問題なく動作します。

programをファイルに保存するには:

  • プロジェクトがFPC/LazarusとDelphiの両方と互換性があるようにしたい場合は、.dpr拡張子(「Delphi Project」の略)を使用します。
  • FPC/Lazarusのみを使用したい場合は、.lpr拡張子(「Lazarus Project」の略)を使用します。
注意他の規約も可能であり、一部のプロジェクトで使用されています。例えば、一部のプロジェクトではメインプログラムファイルに.pasを使用します。一部のプロジェクトではユニットまたはプログラムに.dpを使用します。これには合理的な理由があります(例えば、Lazarus LCLを使用しないFPCプログラムの場合、「Lazarus Project」または「Delphi Project」という説明は厳密には正しくありません)…​しかし、単純さのために、最も一般的な確立された慣習をカバーする上記の規約(.dprまたは.lpr)を推奨します。
3.3. 初期化と終了処理

ユニットは、initializationとfinalizationセクションを持つこともできます。これは、プログラムの開始と終了時に実行されるコードです。

unit initialization_finalization;

{$ifdef FPC} {$mode objfpc}{$H+}{$J-} {$endif}

interface

implementation

initialization
  WriteLn('Hello world!');
finalization
  WriteLn('Goodbye world!');
end.
3.4. ユニット間の相互利用

1つのユニットが別のユニットを使用することもできます。別のユニットはインターフェースセクションで使用することも、実装セクションのみで使用することもできます。前者は、他のユニットやプログラムのために新しい公開されたもの(プロシージャ、型など)を定義することを可能にします。後者はより限定的です(ユニットを実装セクションのみで使用する場合、その識別子は実装内でのみ使用できます)。

unit AnotherUnit;

{$ifdef FPC} {$mode objfpc}{$H+}{$J-} {$endif}

interface

uses
  Classes;

{ "TComponent" 型(クラス)は Classes ユニットで定義されています。
  そのため、上記の Classes ユニットを使用する必要がありました。}
procedure DoSomethingWithComponent(var C: TComponent);

implementation

uses SysUtils;

procedure DoSomethingWithComponent(var C: TComponent);
begin
  { "FreeAndNil" プロシージャは SysUtils ユニットで定義されています。
    実装セクションでのみその名前を参照していたため、
    "implementation" セクションで SysUtils ユニットを使用しても問題ありませんでした。}
  FreeAndNil(C);
end;

end.

インターフェースでの循環ユニット依存関係は許可されていません。つまり、2つのユニットがインターフェースセクションで互いに使用することはできません。その理由は、ユニットのインターフェースセクションを「理解」するために、コンパイラが最初にインターフェースセクションで使用されているすべてのユニットを「理解」する必要があるからです。Pascal言語はこのルールを厳密に守っており、高速なコンパイルと、どのユニットを再コンパイルする必要があるかのコンパイラ側での完全な自動検出を可能にします。単純なコンパイルタスクのために複雑なMakefileファイルを使用する必要はなく、すべての依存関係が正しく更新されていることを確認するためにすべてを再コンパイルする必要もありません。

少なくとも1つの「使用」が実装セクションのみにある場合、ユニット間で循環依存関係を作成することは可能です。したがって、ユニットAがインターフェースでユニットBを使用し、次にユニットBが実装でユニットAを使用することは問題ありません。

3.5. ユニット名による識別子の修飾

異なるユニットが同じ識別子を定義する場合があります。コードを読みやすく検索しやすくするために、通常は避けるべきですが、常に可能とは限りません。そのような場合、uses句の最後のユニットが「勝ち」ます。これは、それが導入する識別子が、前のユニットによって導入された同じ識別子を隠すことを意味します。

MyUnit.MyIdentifierのように使用することで、常に特定のユニットの識別子を明示的に指定できます。これは、MyUnitから使用したい識別子が他のユニットによって隠されている場合の通常の解決策です。もちろん、uses句のユニットの順序を並べ替えることもできますが、これは修正しようとしている宣言以外の他の宣言に影響を与える可能性があります。

program showcolor;

{$ifdef FPC} {$mode objfpc}{$H+}{$J-} {$endif}
{$ifdef MSWINDOWS} {$apptype CONSOLE} {$endif}

// Graphics と GoogleMapsEngine の両方のユニットが TColor 型を定義しています。
uses Graphics, GoogleMapsEngine;

var
  // これは期待どおりに機能しません。なぜなら、TColor は最終的に GoogleMapsEngine によって定義されるからです。
  // Color: TColor;
  { これは正常に機能します。}
  Color: Graphics.TColor;
begin
  Color := clYellow;
  WriteLn(Red(Color), ' ', Green(Color), ' ', Blue(Color));
end.

ユニットの場合、それらには2つのuses句があることを覚えておいてください:インターフェースセクションと実装セクションです。後のユニットが前のユニットのものを隠すというルールはここで一貫して適用されます。これは、実装セクションで使用されるユニットが、インターフェースセクションで使用されるユニットの識別子を隠す可能性があることを意味します。しかし、インターフェースセクションを読む際には、インターフェースで使用されるユニットのみが関係することを覚えておいてください。これは、一見同じように見える2つの宣言がコンパイラによって異なるものとして扱われるという混乱した状況を生み出す可能性があります:

unit UnitUsingColors;

{$ifdef FPC} {$mode objfpc}{$H+}{$J-} {$endif}

// 間違った例

interface

uses Graphics;

procedure ShowColor(const Color: TColor);

implementation

uses GoogleMapsEngine;

procedure ShowColor(const Color: TColor);
begin
  // WriteLn(ColorToString(Color));
end;

end.

Graphicsユニット(Lazarus LCLから)はTColor型を定義します。しかし、コンパイラは、インターフェース宣言に一致するプロシージャShowColorを実装していないと主張して、上記のユニットをコンパイルできません。問題は、GoogleMapsEngineユニットもTColor型を定義していることです。そして、それは実装セクションでのみ使用されるため、実装内でのみTColor定義をシャドウします。上記のユニットの、エラーが明白な同等のバージョンは次のようになります:

unit UnitUsingColors;

{$ifdef FPC} {$mode objfpc}{$H+}{$J-} {$endif}

// 間違った例。
// 前の例をコンパイルしようとするときにコンパイラが「見る」ものです。

interface

uses Graphics;

procedure ShowColor(const Color: Graphics.TColor);

implementation

uses GoogleMapsEngine;

procedure ShowColor(const Color: GoogleMapsEngine.TColor);
begin
  // WriteLn(ColorToString(Color));
end;

end.

この場合、GraphicsユニットからTColorを使用するように実装を変更するだけで、解決策は簡単です。GoogleMapsEngineの使用をインターフェースセクションに移動し、Graphicsよりも前に配置することでも修正できますが、これは実際のケースでは他の結果をもたらす可能性があります。UnitUsingColorsがさらに多くのものを定義する場合などです。

unit UnitUsingColors;

{$ifdef FPC} {$mode objfpc}{$H+}{$J-} {$endif}

interface

uses Graphics;

procedure ShowColor(const Color: TColor);

implementation

uses GoogleMapsEngine;

procedure ShowColor(const Color: Graphics.TColor);
begin
  // WriteLn(ColorToString(Color));
end;

end.
3.6. あるユニットの識別子を別のユニットから公開する

あるユニットから識別子を取得し、新しいユニットで公開したい場合があります。最終的な結果は、新しいユニットを使用すると、その識別子が名前空間で利用可能になることです。

これは、以前のユニットバージョンとの後方互換性を維持するために必要な場合があります。これは、内部ユニットをこのように「隠す」のに便利です。

これは、新しいユニットで識別子を再定義することで実現できます。

unit MyUnit;

{$ifdef FPC} {$mode objfpc}{$H+}{$J-} {$endif}

interface

uses Graphics;

type
  { Graphics ユニットから TColor を TMyColor として公開します。}
  TMyColor = TColor;

  { または、同じ名前で公開します。
    この場合、ユニット名で修飾します。そうしないと、
    "TColor = TColor" の定義で自分自身を参照することになります。}
  TColor = Graphics.TColor;

const
  { これは定数にも機能します。}
  clYellow = Graphics.clYellow;
  clBlue = Graphics.clBlue;

implementation

end.

このトリックは、グローバルなプロシージャ、関数、変数ではそれほど簡単には実行できないことに注意してください。プロシージャや関数の場合、別のユニットのプロシージャへの定数ポインタを公開できます(コールバック(イベント、関数ポインタ、プロシージャ変数とも呼ばれる)を参照)。しかし、それはかなり汚く見えます。

通常の解決策は、内部ユニットの関数を呼び出すだけの「ラッパー」関数を作成し、必要に応じてパラメータと戻り値を渡すことです。

グローバル変数でこれを機能させるには、グローバル(ユニットレベル)プロパティを使用できます。詳細はプロパティを参照してください。

4. クラス

4.1. 基本

クラスがあります。基本的なレベルでは、クラスは単なるコンテナです:

  • フィールド(クラス内の変数のための fancy name)

  • メソッド(クラス内のプロシージャまたは関数のための fancy name)

  • そしてプロパティ(取得と設定を行う一対のメソッドを呼び出すことを意味するフィールドのように見える fancy syntax。詳細はプロパティを参照)。

  • 実際には、さらに多くの可能性があります。クラス内のその他の要素とネストしたクラスで説明されています。

type
  TMyClass = class
    MyInt: Integer; // これはフィールドです
    property MyIntProperty: Integer read MyInt write MyInt; // これはプロパティです
    procedure MyMethod; // これはメソッドです
  end;

procedure TMyClass.MyMethod;
begin
  WriteLn(MyInt + 10);
end;
4.2. 継承、仮想メソッド、override、reintroduce

継承と仮想メソッドがあります。

以下の例では、クラスTMyClassDescendantはクラスTMyClassを継承しています。TMyClassDescendantはTMyClassの派生クラスであり、TMyClassはTMyClassDescendantの親クラスです。

program MyProgram;

{$ifdef FPC} {$mode objfpc}{$H+}{$J-} {$endif}
{$ifdef MSWINDOWS} {$apptype CONSOLE} {$endif}

uses
  SysUtils;

type
  TMyClass = class
    MyInt: Integer;
    procedure MyVirtualMethod; virtual;
  end;

  TMyClassDescendant = class(TMyClass)
    procedure MyVirtualMethod; override;
  end;

procedure TMyClass.MyVirtualMethod;
begin
  WriteLn('TMyClass shows MyInt + 10: ', MyInt + 10);
end;

procedure TMyClassDescendant.MyVirtualMethod;
begin
  WriteLn('TMyClassDescendant shows MyInt + 20: ', MyInt + 20);
end;

var
  C: TMyClass;
begin
  C := TMyClass.Create;
  try
    C.MyVirtualMethod;
  finally
    FreeAndNil(C);
  end;

  C := TMyClassDescendant.Create;
  try
    C.MyVirtualMethod;
  finally
    FreeAndNil(C);
  end;
end.

メソッドが仮想である場合、コンパイラはインスタンスの実際のクラスに基づいて、実行時にメソッドの実装を検索します。これは実際には何を意味するのでしょうか?

  • 上記の例をそのまま実行してください。メソッドMyVirtualMethodが仮想であることに注意してください。C.MyVirtualMethodの呼び出しは、インスタンスCの実際のクラスに基づいて適切な実装を選択します。CがTMyClassDescendantクラスの場合、TMyClassDescendant.MyVirtualMethodの実装が呼び出されます。したがって、出力は次のようになります:

    TMyClass shows MyInt + 10: 10
    TMyClassDescendant shows MyInt + 20: 20
    
  • 次に、上記の例からvirtual;とoverride;の部分を削除して変更します。C.MyVirtualMethodの呼び出しは両方ともTMyClassの実装を呼び出すようになります。なぜなら、CはTMyClassとして宣言されているため、コンパイル時にコンパイラが知っているのはCがTMyClassであることだけだからです。出力は次のようになります:

    TMyClass shows MyInt + 10: 10
    TMyClass shows MyInt + 10: 20
    

    要するに、これは通常あなたが望むものではありません。あなたは仮想メソッドを望みます。

デフォルトではメソッドは仮想ではありません。virtualキーワードで宣言して仮想にします。オーバーライドはoverrideでマークする必要があります。そうしないと警告が表示されます。メソッドを隠す(親クラスでvirtualとして宣言されたものを、オーバーライドせずに隠す。通常は、何をしているか分からない限り、これを行う必要はありません)には、reintroduceを使用します。

4.3. クラスとクラスインスタンス、コンストラクタ、デストラクタ

上記のセクションの例はTMyClass(および別のクラスTMyClassDescendant)と呼ばれるクラスを示しています。クラスは型であり、テンプレートと考えることもできます。クラス自体は値を持っていません。例で宣言されたフィールドMyInt: Integerのためにメモリは予約されていません。

注意実際には、クラス変数を使用してクラスが「値を持つ」ことは可能ですが、今のところこの可能性については忘れてください。単純なクラスに焦点を当て、通常のフィールドのみを持つようにします。

フィールドのためにメモリを予約するには、クラスインスタンスを作成する必要があります。

クラスインスタンスの作成は、コンストラクタを呼び出すことによって行われます。

  • コンストラクタは特別な種類のメソッドで、constructorキーワードを使用します。
  • コンストラクタを呼び出す前に、クラスインスタンスのためにメモリが割り当てられ、その後コンストラクタコードが呼び出されます。
  • すべてのクラスでコンストラクタを定義する必要はありません。すべてのクラスは暗黙的にTObjectを継承しており、Createと呼ばれる引数なしのコンストラクタを持っています。したがって、定義していなくても常にコンストラクタがあります。
  • しかし、クラスにコンストラクタを定義できます。これはクラスインスタンスを初期化する最良の方法です。後で「フィールドXの初期値はYである」ということに依存したい場合は、コンストラクタでそのようにします(X := Y;)。
  • あなた自身のコンストラクタは通常、単にCreateと呼ばれます。コンストラクタとデストラクタの名前付けに関する詳細は、仮想デストラクタ Destroyを参照してください。

コンストラクタを呼び出してクラスインスタンスを割り当てる方法は次のとおりです。

X := TMyClass.Create;

独自のコンストラクタを次のように定義します。

type
  TMyClass = class
  public
    X: Integer;
    constructor Create;
  end;

constructor TMyClass.Create;
begin
  inherited Create; // 親クラスのコンストラクタを呼び出す
  // ここに初期化コード
  X := 123;
end;

逆に、クラスが破棄されるとき、デストラクタが呼び出されます。

  • これは再び特別な種類のメソッドで、destructorキーワードを使用します。
  • デストラクタを呼び出した後、クラスインスタンスのためにメモリが解放されます。破棄されたインスタンスのフィールドにアクセスすることはもはや許可されません。
  • 再び、すべてのクラスでデストラクタを定義する必要はありません。すべてのクラスは暗黙的にTObjectを継承しており、Destroyと呼ばれる引数なしのデストラクタを持っています。
  • しかし、クラスにデストラクタを定義できます。これは、何らかの「クリーンアップ」を行うための最後のチャンスです。例えば、クラスインスタンスが内部で他のクラスインスタンスを作成し、それらを解放する必要があるかもしれません。
  • 定義する場合、デストラクタは1つだけであるべきで、常にoverride;でマークされたDestroyと呼ばれます。なぜそうすべきかの詳細は、仮想デストラクタ Destroyを参照してください。

例を挙げます:

{$ifdef FPC} {$mode objfpc}{$H+}{$J-} {$endif}
{$ifdef MSWINDOWS} {$apptype CONSOLE} {$endif}

uses
  SysUtils;

type
  TMyClass = class
  private
    InternalStuff: TObject;
  public
    constructor Create;
    destructor Destroy; override;
  end;

constructor TMyClass.Create;
begin
  inherited Create; // 親クラスのコンストラクタを最初に呼び出す
  InternalStuff := TObject.Create;
  Writeln('TMyClass.Create');
end;

destructor TMyClass.Destroy;
begin
  Writeln('TMyClass.Destroy');
  FreeAndNil(InternalStuff); // InternalStuff.Destroy を呼び出す
  inherited Destroy; // 親クラスのデストラクタを最後に呼び出す
end;

var
  C: TMyClass;
begin
  C := TMyClass.Create;
  try
    // C を使用
  finally
    FreeAndNil(C); // C.Destroy を呼び出す
  end;
end.
4.4. クラスのテスト(is)、型キャスト(as, TMyClass(X))

実行時にインスタンスのクラスをテストするには、is演算子を使用します。インスタンスを特定のクラスに型キャストするには、as演算子を使用します。

program is_as;

{$ifdef FPC} {$mode objfpc}{$H+}{$J-} {$endif}
{$ifdef MSWINDOWS} {$apptype CONSOLE} {$endif}

uses
  SysUtils;

type
  TMyClass = class
    procedure MyMethod;
  end;

  TMyClassDescendant = class(TMyClass)
    procedure MyMethodInDescendant;
  end;

procedure TMyClass.MyMethod;
begin
  WriteLn('MyMethod');
end;

procedure TMyClassDescendant.MyMethodInDescendant;
begin
  WriteLn('MyMethodInDescendant');
end;

var
  Descendant: TMyClassDescendant;
  C: TMyClass;
begin
  Descendant := TMyClassDescendant.Create;
  try
    Descendant.MyMethod;
    Descendant.MyMethodInDescendant;

    { Descendant は TMyClass として期待されるすべての機能を持っているため、
      この代入はOKです。}
    C := Descendant;
    C.MyMethod;

    { このメソッドは TMyClass では定義されていないため、機能しません}
    //C.MyMethodInDescendant;
    if C is TMyClassDescendant then
      (C as TMyClassDescendant).MyMethodInDescendant;

  finally
    FreeAndNil(Descendant);
  end;
end.

X as TMyClassを使用してキャストする代わりに、チェックなしの型キャストTMyClass(X)を使用することもできます。これはより高速ですが、Xが実際にはTMyClassの派生クラスでない場合、未定義の動作を引き起こします。したがって、TMyClass(X)型キャストを使用しないか、isでテストした後など、それが明らかに正しいコードでのみ使用してください。

if A is TMyClass then
  (A as TMyClass).CallSomeMethodOfMyClass;
// 以下はわずかに高速です
if A is TMyClass then
  TMyClass(A).CallSomeMethodOfMyClass;
4.5. プロパティ

プロパティは、次の目的のための非常に便利な「シンタックスシュガー」です:

  1. フィールドのように見えるもの(読み書き可能)を作成しますが、実際にはゲッターとセッターメソッドを呼び出します。典型的な使用法は、ある値が変更されるたびに副作用(例:画面の再描画)を実行することです。
  2. フィールドのように見えるが、読み取り専用のものを作成します。実際には、定数または引数なしの関数のようなものです。
type
  TWebPage = class
  private
    FURL: string;
    FColor: TColor;
    function SetColor(const Value: TColor);
  public
    { 直接設定する方法はありません。
      Load メソッドを Load('http://www.freepascal.org/') のように呼び出して、
      ページをロードし、このプロパティを設定してください。}
    property URL: string read FURL;
    procedure Load(const AnURL: string);
    property Color: TColor read FColor write SetColor;
  end;

procedure TWebPage.Load(const AnURL: string);
begin
  FURL := AnURL;
  NetworkingComponent.LoadWebPage(AnURL);
end;

function TWebPage.SetColor(const Value: TColor);
begin
  if FColor <> Value then
  begin
    FColor := Value;
    // 例として、値が変更されるたびに更新をトリガーします
    Repaint;
    // 別の例として、「RenderingComponent」(それが何であれ)のような
    // 基盤となるインスタンスに Color の同期された値があることを確認します。
    RenderingComponent.Color := Value;
  end;
end;

メソッドを指定する代わりに、フィールド(通常はプライベートフィールド)を指定して直接取得または設定することもできます。上記の例では、ColorプロパティはセッターメソッドSetColorを使用しています。しかし、値を取得するためには、ColorプロパティはプライベートフィールドFColorを直接参照しています。フィールドを直接参照することは、単純なゲッターまたはセッターメソッドを実装するよりも高速です(あなたにとって高速であり、実行時にも高速です)。

プロパティを宣言する際に指定するのは次のとおりです:

  1. 読み取り可能かどうか、およびどのように読み取るか(フィールドを直接読み取るか、「ゲッター」メソッドを使用するか)。
  2. そして同様の方法で、設定可能かどうか、およびどのように設定するか(指定されたフィールドに直接書き込むか、「セッター」メソッドを呼び出すか)。

コンパイラは、指定されたフィールドとメソッドの型とパラメータがプロパティの型と一致するかどうかを確認します。例えば、Integerプロパティを読み取るには、Integerフィールドを提供するか、Integerを返す引数なしのメソッドを提供する必要があります。

技術的には、コンパイラにとって、「ゲッター」および「セッター」メソッドは通常のメソッドであり、完全に任意の処理を実行できます(副作用やランダム化を含む)。しかし、プロパティをフィールドとほぼ同じように動作するように設計することは良い慣習です:

  • ゲッター関数は、目に見える副作用を持たないべきです(例:ファイル/キーボードから入力を読み取るべきではありません)。決定論的であるべきです(ランダム化、擬似ランダム化さえも!)。プロパティを複数回読み取っても有効であり、それらの間に何も変更されなければ同じ値を返すはずです。

    ゲッターがキャッシュのような見えない副作用を持つことは問題ありません。例えば、ある計算の結果(与えられたインスタンスに対して同じ結果を生成することがわかっている)をキャッシュして、次回より速く返すことができます。これは実際、「ゲッター」関数のクールな可能性の1つです。

  • セッター関数は、要求された値を設定し、ゲッターがそれを返せるようにすべきです。無効な値をサイレントに拒否しないでください(必要であれば例外を発生させてください)。要求された値を変換またはスケーリングしないでください。アイデアは、MyClass.MyProperty := 123;の後、プログラマはMyClass.MyProperty = 123を期待できるということです。

  • 読み取り専用プロパティは、一部のフィールドを外部から読み取り専用にするためによく使用されます。ここでも、良い慣習は、少なくともこのオブジェクトインスタンスとその状態に対して定数のように動作させることです。プロパティの値は予期せず変更されるべきではありません。副作用がある場合やランダムなものを返す場合は、プロパティではなく関数にしてください。

  • プロパティの「バッキング」フィールドは、プロパティのアイデアはそれへのすべての外部アクセスをカプセル化することであるため、ほぼ常にプライベートです。

  • 技術的には書き込み専用プロパティを作成することは可能ですが、そのようなものの良い例はまだ見たことがありません:)

注意プロパティはクラスの外、ユニットレベルで定義することもできます。その場合、同様の目的を果たします:グローバル変数のように見えますが、ゲッターとセッタールーチンによってバックアップされます。
4.5.1. プロパティのシリアライズ

公開プロパティは、Pascalにおけるシリアライズ(コンポーネントストリーミングとも呼ばれる)の基盤です。シリアライズとは、インスタンスデータがストリーム(ファイルのようなもの)に記録され、そこから後で復元できることを意味します。

Lazarusがxxx.lfmファイルからコンポーネントの状態を読み書きするときにシリアライズが発生します(Delphiでは、同等のファイルは.dfm拡張子を持ちます)。LResourcesユニットのReadComponentFromTextStreamのようなルーチンを使用して、このメカニズムを明示的に使用することもできます。また、例えばFpJsonRttiユニット(JSONへのシリアライズ)のような他のシリアライズアルゴリズムを使用することもできます。

Castle Game Engine内:UIおよび変換コンポーネント階層のシリアライズには、FpJsonRttiに基づくCastleComponentSerializeユニットを使用します。

各プロパティで、任意のシリアライズアルゴリズムに役立つ追加のものを宣言できます:

  • プロパティのデフォルト値(defaultキーワードを使用)を指定できます。ただし、コンストラクタでこのデフォルト値にプロパティを初期化する必要があります(自動的には行われません)。default宣言は、シリアライズアルゴリズムへの情報にすぎません:「コンストラクタが終了したとき、指定されたプロパティは指定された値を持つ」ということです。
  • プロパティを保存するかどうか(storedキーワードを使用)。
4.6. 例外 - クイック例

例外があります。これらはtry … except … end句で捕捉でき、try … finally … endのようなfinallyセクションもあります。

{$ifdef FPC} {$mode objfpc}{$H+}{$J-} {$endif}
{$ifdef MSWINDOWS} {$apptype CONSOLE} {$endif}

program MyProgram;

uses
  SysUtils;

type
  TMyClass = class
    procedure MyMethod;
  end;

procedure TMyClass.MyMethod;
begin
  if Random > 0.5 then
    raise Exception.Create('Raising an exception!');
end;

var
  C: TMyClass;
begin
  Randomize;
  C := TMyClass.Create;
  try
    C.MyMethod;
  finally
    FreeAndNil(C);
  end;
end.

finally節は、例外が発生したかどうかに関わらず実行されることに注意してください。例外が発生した場合でも、Exit(関数/プロシージャ/メソッドから)、Break、Continue(ループ本体から)でブロックを終了した場合でも実行されます。

4.7. 可視性指定子

ほとんどのオブジェクト指向言語と同様に、フィールド/メソッド/プロパティを隠すための可視性指定子があります。

基本的な可視性レベルは次のとおりです:

public

誰でもアクセスでき、他のユニットのコードも含まれます。

private

このクラス内でのみアクセス可能です。

protected

このクラスとその派生クラス内でのみアクセス可能です。

上記のprivateとprotectedの可視性の説明は正確ではありません。同じユニット内のコードは、それらの制限を克服して、privateおよびprotectedの要素に自由にアクセスできます。これは、密接に関連するクラスを実装するのに便利な機能となる場合があります。クラスをより厳密に保護するには、strict privateまたはstrict protectedを使用してください。private と strict privateを参照してください。

可視性を指定しない場合、宣言された要素の可視性はpublicになります。例外は、{$M+}でコンパイルされたクラス、または{$M+}でコンパイルされたクラスの派生クラス(TComponentのすべての派生クラスを含む。TComponentはTPersistentを継承しているため)です。これらの場合、デフォルトの可視性指定子はpublishedであり、これはpublicに似ていますが、ストリーミングシステムがそれを処理できるという利点があります。

すべてのフィールドとプロパティ型がpublishedセクションで許可されているわけではありません(すべての型がストリーム可能ではなく、クラスのみが単純なフィールドからストリーム可能です)。ストリーミングを気にしないが、すべての人に公開したい場合は、単にpublicを使用してください。

4.8. デフォルトの親クラス

親クラス型を宣言しない場合、すべてのclassはTObjectを継承します。

4.9. Self

特別なキーワードSelfは、クラス実装内で自身のインスタンスを明示的に参照するために使用できます。これはC++、Java、および類似言語のthisに相当します。

4.10. 継承メソッドの呼び出し

メソッド実装内で別のメソッドを呼び出す場合、デフォルトでは自身のクラスのメソッドが呼び出されます。以下の例のコードでは、TMyClass2.MyOtherMethodはMyMethodを呼び出し、結果としてTMyClass2.MyMethodが呼び出されます。

{$ifdef FPC} {$mode objfpc}{$H+}{$J-} {$endif}
{$ifdef MSWINDOWS} {$apptype CONSOLE} {$endif}

uses SysUtils;

type
  TMyClass1 = class
    procedure MyMethod;
  end;

  TMyClass2 = class(TMyClass1)
    procedure MyMethod;
    procedure MyOtherMethod;
  end;

procedure TMyClass1.MyMethod;
begin
  Writeln('TMyClass1.MyMethod');
end;

procedure TMyClass2.MyMethod;
begin
  Writeln('TMyClass2.MyMethod');
end;

procedure TMyClass2.MyOtherMethod;
begin
  MyMethod; // これは TMyClass2.MyMethod を呼び出します
end;

var
  C: TMyClass2;
begin
  C := TMyClass2.Create;
  try
    C.MyOtherMethod;
  finally FreeAndNil(C)
  end;
end.

メソッドが特定のクラスで定義されていない場合、親クラスのメソッドが呼び出されます。実質的に、TMyClass2のインスタンスでMyMethodを呼び出す場合:

  • コンパイラはTMyClass2.MyMethodを検索します。
  • 見つからない場合、TMyClass1.MyMethodを検索します。
  • 見つからない場合、TObject.MyMethodを検索します。
  • 見つからない場合、コンパイルは失敗します。

上記の例でTMyClass2.MyMethodの定義をコメントアウトすることでテストできます。実質的に、TMyClass2.MyOtherMethodによってTMyClass1.MyMethodが呼び出されます。

時々、自身のクラスのメソッドを呼び出したくない場合があります。親クラスのメソッド(またはその親の親など)を呼び出したい場合があります。これを行うには、inheritedキーワードをMyMethodの呼び出しの前に付けます。例:

inherited MyMethod;

これにより、コンパイラは親クラスからメソッドの検索を開始することが強制されます。この例では、コンパイラはTMyClass1.MyMethod、次にTObject.MyMethod内でMyMethodを検索し、その後失敗します。TMyClass2.MyMethodの実装を使用することは考慮されません。

ヒント上記の例でTMyClass2.MyOtherMethodの実装をinherited MyMethodを使用するように変更して、出力の違いを確認してください。

inherited呼び出しは、しばしば同じ名前の親メソッドを呼び出すために使用されます。これにより、派生クラスは親クラスの機能を維持しつつ、機能を拡張できます(親クラスの機能を置き換えるのではなく)。以下の例のように。

{$ifdef FPC} {$mode objfpc}{$H+}{$J-} {$endif}
{$ifdef MSWINDOWS} {$apptype CONSOLE} {$endif}

uses SysUtils;

type
  TMyClass1 = class
    constructor Create;
    procedure MyMethod(const A: Integer);
  end;

  TMyClass2 = class(TMyClass1)
    constructor Create;
    procedure MyMethod(const A: Integer);
  end;

constructor TMyClass1.Create;
begin
  inherited Create; // これは TObject.Create を呼び出します
  Writeln('TMyClass1.Create');
end;

procedure TMyClass1.MyMethod(const A: Integer);
begin
  Writeln('TMyClass1.MyMethod ', A);
end;

constructor TMyClass2.Create;
begin
  inherited Create; // これは TMyClass1.Create を呼び出します
  Writeln('TMyClass2.Create');
end;

procedure TMyClass2.MyMethod(const A: Integer);
begin
  inherited MyMethod(A); // これは TMyClass1.MyMethod を呼び出します
  Writeln('TMyClass2.MyMethod ', A);
end;

var
  C: TMyClass2;
begin
  C := TMyClass2.Create;
  try
    C.MyMethod(123);
  finally FreeAndNil(C)
  end;
end.

同じ名前、同じ引数を持つメソッドを呼び出すためにinheritedを使用することは非常に一般的なケースであるため、特別なショートカットがあります。単にinherited;(inheritedキーワードの直後にセミコロン、メソッド名の代わり)と書くだけです。これは「現在のメソッドに渡されたのと同じ引数を使用して、親メソッドを呼び出す」ことを意味します。

ヒント上記の例では、すべてのinherited …​;呼び出しを単純なinherited;に置き換えることができます。

注意1:inherited;は、同じ変数を現在のメソッドに渡された引数として親メソッドに渡すためのショートカットです。現在のパラメータ(constでない場合)を変更した場合、親メソッドは子から異なる入力値を受け取ることができます。これを検討してください:

procedure TMyClass2.MyMethod(A: Integer);
begin
  Writeln('TMyClass2.MyMethod beginning ', A);
  A := 456;
  { これは、このメソッド(TMyClass2.MyMethod)に渡されたAの値に関わらず、
    A = 456 で TMyClass1.MyMethod を呼び出します。}
  inherited;
  Writeln('TMyClass2.MyMethod ending ', A);
end;

注意2:通常、メソッドを仮想にしたい場合は、多くのクラス(「継承チェーン」)がそれを定義する場合です。詳細は以下のセクションで説明します。しかし、inheritedキーワードは、メソッドが仮想であるかどうかにかかわらず機能します。inheritedは常にコンパイラが親からメソッドを検索し始めることを意味し、仮想メソッドと非仮想メソッドの両方に意味があります。

4.11. 仮想メソッド、overrideとreintroduce

デフォルトでは、メソッドは仮想ではありません。これはC++に似ており、Javaとは異なります。

メソッドが仮想でない場合、コンパイラは、実際に作成されたクラスタイプではなく、現在宣言されているクラスタイプに基づいて、どのメソッドを呼び出すかを決定します。この違いは微妙に見えますが、変数がTFruitのようなクラスを持つように宣言されているが、実際にはTAppleのような派生クラスである可能性がある場合に重要です。

オブジェクト指向プログラミングの考え方は、派生クラスは常に親クラスと同等であるということです。そのため、コンパイラは親が期待される場合に常に派生クラスを使用することを許可します。メソッドが仮想でない場合、これは望ましくない結果を招く可能性があります。以下の例を検討してください:

{$ifdef FPC} {$mode objfpc}{$H+}{$J-} {$endif}
{$ifdef MSWINDOWS} {$apptype CONSOLE} {$endif}

uses SysUtils;

type
  TFruit = class
    procedure Eat;
  end;

  TApple = class(TFruit)
    procedure Eat;
  end;

procedure TFruit.Eat;
begin
  Writeln('Eating a fruit');
end;

procedure TApple.Eat;
begin
  Writeln('Eating an apple');
end;

procedure DoSomethingWithAFruit(const Fruit: TFruit);
begin
  Writeln('We have a fruit with class ', Fruit.ClassName);
  Writeln('We eat it:');
  Fruit.Eat;
end;

var
  Apple: TApple; // 注意:ここでは "Apple: TFruit" と宣言することもできます
begin
  Apple := TApple.Create;
  try
    DoSomethingWithAFruit(Apple);
  finally FreeAndNil(Apple)
  end;
end.

この例は次のように出力します:

We have a fruit with class TApple
We eat it:
Eating a fruit

実質的に、Fruit.Eatの呼び出しはTFruit.Eatの実装を呼び出し、TApple.Eatの実装は呼び出されませんでした。

コンパイラがどのように動作するかを考えると、これは自然です。Fruit.Eatと書いたとき、Fruit変数はTFruitクラスを保持するように宣言されていました。そのため、コンパイラはTFruitクラス内でEatという名前のメソッドを検索しました。TFruitクラスにそのようなメソッドが含まれていない場合、コンパイラは親(この例ではTObject)を検索します。しかし、コンパイラは派生クラス(例:TApple)内を検索することはできません。なぜなら、Fruitの実際のクラスがTAppleなのか、TFruitなのか、あるいは他のTFruitの派生クラス(例:例には示されていないTOrange)なのかを知ることができないからです。

言い換えれば、呼び出されるメソッドはコンパイル時に決定されます。

仮想メソッドを使用すると、この動作が変更されます。Eatメソッドが仮想である場合(例を以下に示します)、呼び出される実際のメソッドは実行時に決定されます。Fruit変数がTFruitとして宣言されていてもTAppleクラスのインスタンスを保持している場合、EatメソッドはまずTAppleクラス内で検索されます。

Object Pascalでは、メソッドを仮想として定義するには、次の操作が必要です:

  • その最初の定義(最も上位の親クラス)をvirtualキーワードでマークします。
  • すべての他の定義(派生クラス内)をoverrideキーワードでマークします。オーバーライドされたすべてのバージョンは、まったく同じパラメータを持ち、関数の場合、同じ型を返す必要があります。
{$ifdef FPC} {$mode objfpc}{$H+}{$J-} {$endif}
{$ifdef MSWINDOWS} {$apptype CONSOLE} {$endif}

uses SysUtils;

type
  TFruit = class
    procedure Eat; virtual;
  end;

  TApple = class(TFruit)
    procedure Eat; override;
  end;

procedure TFruit.Eat;
begin
  Writeln('Eating a fruit');
end;

procedure TApple.Eat;
begin
  Writeln('Eating an apple');
end;

procedure DoSomethingWithAFruit(const Fruit: TFruit);
begin
  Writeln('We have a fruit with class ', Fruit.ClassName);
  Writeln('We eat it:');
  Fruit.Eat;
end;

var
  Apple: TApple; // 注意:ここでは "Apple: TFruit" と宣言することもできます
begin
  Apple := TApple.Create;
  try
    DoSomethingWithAFruit(Apple);
  finally FreeAndNil(Apple)
  end;
end.

この例は次のように出力します:

We have a fruit with class TApple
We eat it:
Eating an apple

内部的には、仮想メソッドは、各クラスに関連付けられたいわゆる仮想メソッドテーブルによって機能します。このテーブルは、そのクラスの仮想メソッドの実装へのポインタのリストです。Eatメソッドを呼び出すとき、コンパイラはFruitの実際のクラスに関連付けられた仮想メソッドテーブルを参照し、そこに格納されているEat実装へのポインタを使用します。

overrideキーワードを使用しない場合、コンパイラは、仮想でない定義で親の仮想メソッドを隠蔽しているという警告を表示します。これが意図したものであると確信している場合は、reintroduceキーワードを追加できます。しかし、ほとんどの場合、メソッドを仮想のままにしてoverrideキーワードを追加し、常に正しく呼び出されるようにしたいでしょう。

5. クラスの解放

5.1. クラスインスタンスの解放を忘れない

クラスインスタンスは手動で解放する必要があります。そうしないとメモリリークが発生します。

メモリリークを自動的に検出することをお勧めします:

  • FPCコマンドラインオプション-gl -gh
  • Delphi ReportMemoryLeaksOnShutdown := true
  • Castle Game Engine CastleEngineManifest.xmlのdetect_memory_leaks="true"
注意例外として発生したインスタンスを解放する必要はありません。例外を発生させるときに通常のクラスインスタンスを作成しますが、そのクラスインスタンスは自動的に解放されます。
5.2. 解放方法

クラスインスタンスを解放するには、SysUtilsユニットのFreeAndNil(A)をクラスインスタンスに対して呼び出すのが最善です。これはAがnilかどうかをチェックし、nilでない場合はデストラクタを呼び出し、Aをnilに設定します。したがって、連続して複数回呼び出してもエラーになりません。

これは実質的に次のようなショートカットです:

if A <> nil then
begin
  A.Destroy;
  A := nil;
end;

実際には、これは単純化しすぎです。FreeAndNilは、適切な参照に対してデストラクタを呼び出す前に、受け取った変数をnilに設定するという便利なトリックを実行します。これはある種のバグを防ぐのに役立ちます。つまり、「外部」コードは、半破棄されたクラスインスタンスにアクセスすべきではないということです。

多くの場合、A.Freeメソッドを使用している人も見かけます。これは次のような操作に似ています:

if A <> nil then
  A.Destroy;

これはAを解放しますが、nilでない場合のみです。

通常の状況では、nilのインスタンスに対してメソッドを呼び出すべきではありません。したがって、A.Freeの呼び出しは、Aがnilになる可能性がある場合、一見すると疑わしいかもしれません。しかし、Freeメソッドはこのルールの例外です。実装内で何か「汚い」ことをします。つまり、Self <> nilかどうかをチェックします。

注意このトリック(メソッドがSelfがnilの場合でも使用できることを公式に許可する)は、非仮想メソッドでのみ可能です。そのようなメソッドの実装では、Self = nilが可能である限り、nilインスタンスで呼び出された場合にアクセス違反(セグメンテーション違反)エラーを引き起こすため、仮想メソッドを呼び出したり、フィールドにアクセスしたりすることはできません。例のコードmethod_with_self_nil.dprを参照してください。通常の用途とは逆行するため、このトリックを独自のコード(仮想または非仮想メソッドの場合)で使用することは推奨しません。一般的に、すべてのインスタンスメソッドは、有効な(nilでない)インスタンスで動作することを想定し、フィールドにアクセスしたり、他のメソッド(仮想か否か)を呼び出したりできるはずです。

FreeAndNil(A)を常に、例外なく使用することを推奨します。直接FreeメソッドやDestroyデストラクタを呼び出すことは避けてください。

Castle Game Engineはそれをそのように行います。これにより、「すべての参照はnilであるか、有効なインスタンスを指している」という良いアサーションを維持するのに役立ちます。ただし、FreeAndNil(A)を使用してもこのアサーションは保証されないことに注意してください。例えば、インスタンス参照をコピーして、一方のコピーでFreeAndNil(A)を呼び出すと、もう一方のコピーはnilでないダングリングポインタになります。

A := TObject.Create;
B := A;
FreeAndNil(A);
// この時点でAまたはBにアクセスするとどうなるか?

それでも、FreeAndNil(A)は最も単純なケースを処理するため、使用する習慣を身につけることは良いことです。デバッグ中に、「Xはすでに解放されています。なぜならXは現在nilだからです」というような観察が容易になるため、感謝するでしょう。

5.3. 手動解放と自動解放

多くの場合、インスタンスを解放する必要性はそれほど問題になりません。コンストラクタと一致するデストラクタを書き、コンストラクタ(またはより完全に、クラスの全寿命)で割り当てられたすべてを解放します。各ものを一度だけ解放するように注意してください。通常、解放された参照をnilに設定することは良い考えです。FreeAndNil(A)を呼び出すことで、通常は最も快適です。

したがって、次のようになります:

uses SysUtils;

type
  TGun = class
  end;

  TPlayer = class
    Gun1, Gun2: TGun;
    constructor Create;
    destructor Destroy; override;
  end;

constructor TPlayer.Create;
begin
  inherited;
  Gun1 := TGun.Create;
  Gun2 := TGun.Create;
end;

destructor TPlayer.Destroy;
begin
  FreeAndNil(Gun1);
  FreeAndNil(Gun2);
  inherited;
end;

インスタンスを明示的に解放する必要を避けるために、「所有権」のTComponent機能を使用することもできます。所有されているオブジェクトは、所有者によって自動的に解放されます。このメカニズムはスマートで、すでに解放されたインスタンスを解放することはありません(したがって、手動で所有されたオブジェクトを早期に解放した場合でも正しく機能します)。前の例を次のように変更できます:

uses SysUtils, Classes;

type
  TGun = class(TComponent)
  end;

  TPlayer = class(TComponent)
    Gun1, Gun2: TGun;
    constructor Create(AOwner: TComponent); override;
  end;

constructor TPlayer.Create(AOwner: TComponent);
begin
  inherited;
  Gun1 := TGun.Create(Self);
  Gun2 := TGun.Create(Self);
end;

ここで仮想TComponentコンストラクタをオーバーライドする必要があることに注意してください。したがって、コンストラクタパラメータを変更することはできません。(実際には、reintroduceで新しいコンストラクタを宣言することで変更できます。しかし、注意してください。一部の機能(例:ストリーミング)は仮想コンストラクタを使用し続けるため、どちらの場合でも正しく機能することを確認してください。)

所有者の値としてnilを使用できることに注意してください。これにより、このコンポーネントに対して「所有権」メカニズムが使用されなくなります。これは、TComponent派生クラスを使用する必要があるが、常に手動で解放したい場合に意味があります。これを行うには、次のようにコンポーネント派生クラスを作成します:ManualGun := TGun.Create(nil);。

自動解放のもう1つのメカニズムは、TFPGObjectListやTObjectListのようなリストクラスのOwnsObjects機能です(デフォルトで既にtrueです)。したがって、次のように書くこともできます:

uses SysUtils, Classes, FGL;

type
  TGun = class
  end;

  TGunList = {$ifdef FPC}specialize{$endif} TFPGObjectList<TGun>;

  TPlayer = class
    Guns: TGunList;
    Gun1, Gun2: TGun;
    constructor Create;
    destructor Destroy; override;
  end;

constructor TPlayer.Create;
begin
  inherited;
  // 実際には、パラメータ true (OwnsObjects) は既にデフォルトです
  Guns := TGunList.Create(true);
  Gun1 := TGun.Create;
  Guns.Add(Gun1);
  Gun2 := TGun.Create;
  Guns.Add(Gun2);
end;

destructor TPlayer.Destroy;
begin
  { リストを解放する必要があります。
    これにより、その内容も自動的に解放されます。}
  FreeAndNil(Guns);

  { Gun1 と Gun2 を解放する必要はもうありません。
    それらが解放されたことがわかっているので、
    それらの参照を "nil" に設定するのは良い習慣です。
    この単純なクラスでは、デストラクタが非常に単純なので、
    それらがそれ以上アクセスできないことは明らかです。
    しかし、より大きく複雑なデストラクタの場合、これは役立ちます。

    あるいは、Gun1 と Gun2 を宣言するのを避け、
    代わりに自分のコードで Guns[0] と Guns[1] を使用することもできます。
    または Gun1 のようなメソッドを作成して Guns[0] を返すこともできます。}
  Gun1 := nil;
  Gun2 := nil;
  inherited;
end;

リストクラスの「所有権」メカニズムは単純なので、リスト内に含まれているインスタンスを他の手段で解放した場合、エラーが発生することに注意してください。解放せずにリストから削除するにはExtractメソッドを使用し、解放の責任は自分で負うようにしてください。

Castle Game Engine内:TX3DNodeの派生クラスは、別のTX3DNodeの子として挿入されると自動メモリ管理を行います。ルートX3DノードであるTX3DRootNodeは、通常TCastleSceneCoreによって所有されます。他のいくつかのものも単純な所有権メカニズムを持っています。OwnsXxxと呼ばれるパラメータやプロパティを探してください。

5.4. 仮想デストラクタ Destroy

上記の例で見たように、クラスが破棄されるとき、そのdestructorであるDestroyが呼び出されます。

理論的には複数のデストラクタを持つことも可能ですが、実際にはほとんど良い考えではありません。単一のデストラクタであるDestroyを持つ方がはるかに簡単です。これは、Freeメソッドによって呼び出され、さらにFreeAndNilプロシージャによって呼び出されます。

TObjectのDestroyデストラクタは仮想メソッドとして定義されているため、すべてのクラスはTObjectを継承しているため、すべてのクラスでoverrideキーワードでマークする必要があります。これにより、Freeメソッドが正しく機能します。仮想メソッドがどのように機能するかについては、仮想メソッド、overrideとreintroduceを参照してください。

注意このデストラクタに関する情報は、コンストラクタに関する情報とは実際には一貫性がありません。クラスが複数のコンストラクタを持つのは普通です。通常、それらはすべてCreateと呼ばれ、パラメータが異なるだけですが、コンストラクタに別の名前を付けることも問題ありません。また、TObjectのCreateコンストラクタは仮想ではありません。そのため、派生クラスでoverrideキーワードでマークする必要はありません。これらすべてにより、コンストラクタを定義する際にいくらかの柔軟性が得られます。それらを仮想にする必要は通常ないため、デフォルトでは強制されません。ただし、TComponentの派生クラスについては状況が変わります。TComponentは仮想コンストラクタCreate(AOwner: TComponent)を定義します。ストリーミングシステムが機能するためには仮想コンストラクタが必要です。TComponentの派生クラスを定義する際には、このコンストラクタをオーバーライドし(overrideキーワードでマークして)、すべての初期化をその中で実行する必要があります。追加のコンストラクタを定義することも依然として可能ですが、それらは「ヘルパー」としてのみ機能するはずです。インスタンスは、Create(AOwner: TComponent)コンストラクタを使用して作成された場合に常に機能するはずです。そうしないと、ストリーミング時に正しく構築されません。ストリーミングは、例えばLazarusフォームにこのコンポーネントを保存およびロードするときに使用されます。
5.5. 解放通知

インスタンスへの参照をコピーして、同じメモリへの参照が2つある場合、一方の参照が解放されると、もう一方はダングリングポインタになります。それはアクセスされるべきではありません。なぜなら、それはもはや割り当てられていないメモリを指しているからです。それにアクセスすると、実行時エラーが発生したり、ガベージデータが返されたりする可能性があります(メモリがプログラムの他の部分に再利用される可能性があるため)。

インスタンスを解放するためにFreeAndNilを使用しても、これは役立ちません。FreeAndNilは、受け取った参照のみをnilに設定します。他のすべての参照を自動的にnilに設定する方法はありません。このコードを検討してください:

var
  Obj1, Obj2: TObject;
begin
  Obj1 := TObject.Create;
  Obj2 := Obj1;
  FreeAndNil(Obj1);

  // ここで Obj1 または Obj2 にアクセスするとどうなるか?
end;
  1. このブロックの最後に、Obj1はnilになります。他のコードがそれにアクセスする必要がある場合、if Obj1 <> nil then …​を使用して、解放されたインスタンスのメソッド呼び出しを避けることができます。

    if Obj1 <> nil then
      WriteLn(Obj1.ClassName);
    

    nilインスタンスのフィールドにアクセスしようとすると、予測可能な実行時例外が発生します。したがって、他のコードがObj1 <> nilをチェックせず、盲目的にObj1フィールドにアクセスした場合でも、明確な実行時例外が発生します。

    仮想メソッドの呼び出し、またはnilインスタンスでフィールドにアクセスする非仮想メソッドの呼び出しも同様です。

  2. Obj2の場合、状況はそれほど予測可能ではありません。nilではありませんが、無効です。nilでない無効なインスタンスのフィールドにアクセスしようとすると、予測不能な動作が発生します。場合によってはアクセス違反例外が発生したり、ガベージデータが返されたりします。

これにはさまざまな解決策があります:

  • 1つの解決策は、注意してドキュメントを読むことです。参照の寿命について、それが他のコードによって作成された場合、何も仮定しないでください。クラスTCarがTWheelインスタンスを指すフィールドを持っている場合、ホイールへの参照は車への参照が存在する限り有効であり、車はそのホイールをデストラクタ内で解放するという規約があります。しかし、それは単なる規約であり、ドキュメントにはそれ以上の複雑なことが起こっている場合は記載されるべきです。

  • 上記の例では、Obj1インスタンスを解放した直後に、Obj2変数を明示的にnilに設定できます。この単純なケースでは、これは簡単です。

  • 最も将来性のある解決策は、TComponentクラスの「解放通知」メカニズムを使用することです。一方のコンポーネントは、もう一方のコンポーネントが解放されたときに通知され、その参照をnilに設定できます。

    これにより、弱参照のようなものが得られます。さまざまな使用シナリオに対応でき、例えば、クラス外のコードが参照を設定できるようにし、外部コードがいつでもインスタンスを解放できるようにすることができます。

    これには両方のクラスがTComponentを継承する必要があります。一般的にこれを使用することは、FreeNotification、RemoveFreeNotificationを呼び出し、Notificationをオーバーライドすることに集約されます。

    以下に、このメカニズムの使用方法を示す完全な例を示します。コンストラクタ/デストラクタとセッタープロパティと組み合わせています。時にはもっと単純にできることもありますが、これは常に正しい完全なバージョンです:)

    type
      TControl = class(TComponent)
      end;
    
      TContainer = class(TComponent)
      private
        FSomeSpecialControl: TControl;
        procedure SetSomeSpecialControl(const Value: TControl);
      protected
        procedure Notification(AComponent: TComponent; Operation: TOperation); override;
      public
        destructor Destroy; override;
        property SomeSpecialControl: TControl
          read FSomeSpecialControl write SetSomeSpecialControl;
      end;
    
    implementation
    
    procedure TContainer.Notification(AComponent: TComponent; Operation: TOperation);
    begin
      inherited;
      if (Operation = opRemove) and (AComponent = FSomeSpecialControl) then
        { きれいにクリーンアップするために nil に設定します}
        SomeSpecialControl := nil;
    end;
    
    procedure TContainer.SetSomeSpecialControl(const Value: TControl);
    begin
      if FSomeSpecialControl <> Value then
      begin
        if FSomeSpecialControl <> nil then
          FSomeSpecialControl.RemoveFreeNotification(Self);
        FSomeSpecialControl := Value;
        if FSomeSpecialControl <> nil then
          FSomeSpecialControl.FreeNotification(Self);
      end;
    end;
    
    destructor TContainer.Destroy;
    begin
      { 解放通知を解除するために nil に設定します}
      SomeSpecialControl := nil;
      inherited;
    end;
    
5.6. 解放通知オブザーバー(Castle Game Engine)

Castle Game Engine内:CastleClassUtilsユニットのTFreeNotificationObserverの使用を推奨します。これは、FreeNotification、RemoveFreeNotificationを直接呼び出したりNotificationをオーバーライドしたりするよりも推奨されます。

一般的に、TFreeNotificationObserverを使用することは、FreeNotificationメカニズムを直接使用するよりも少し簡単です(ただし、好みの問題であることは認めます)。しかし、特に同じクラスインスタンスが複数の理由で監視される必要がある場合、TFreeNotificationObserverは使用がはるかに簡単です(この場合、直接FreeNotificationを使用すると複雑になる可能性があります。なぜなら、通知を早すぎないように解除しないように注意する必要があるからです)。

これは、前のセクションの例と同じ効果を達成するための、TFreeNotificationObserverを使用したコード例です:

type
  TControl = class(TComponent)
  end;

  TContainer = class(TComponent)
  private
    FSomeSpecialControlObserver: TFreeNotificationObserver;
    FSomeSpecialControl: TControl;
    procedure SetSomeSpecialControl(const Value: TControl);
    procedure SomeSpecialControlFreeNotification(const Sender: TFreeNotificationObserver);
  public
    constructor Create(AOwner: TComponent); override;
    property SomeSpecialControl: TControl
      read FSomeSpecialControl write SetSomeSpecialControl;
  end;

implementation

uses CastleComponentSerialize;

constructor TContainer.Create(AOwner: TComponent);
begin
  inherited;
  FSomeSpecialControlObserver := TFreeNotificationObserver.Create(Self);
  FSomeSpecialControlObserver.OnFreeNotification := {$ifdef FPC}@{$endif} SomeSpecialControlFreeNotification;
end;

procedure TContainer.SetSomeSpecialControl(const Value: TControl);
begin
  if FSomeSpecialControl <> Value then
  begin
    FSomeSpecialControl := Value;
    FSomeSpecialControlObserver.Observed := Value;
  end;
end;

procedure TContainer.SomeSpecialControlFreeNotification(const Sender: TFreeNotificationObserver);
begin
  // 参照されているコンポーネントが解放されたときにプロパティを nil に設定します
  SomeSpecialControl := nil;
end;

6. 例外

6.1. 概要

例外は、コードの通常の実行を中断することを可能にします。

  • プログラムの任意の時点で、raiseキーワードを使用して例外を発生させることができます。実際には、raise …​呼び出しの後のコード行は実行されません。

  • 例外は、try … except … end構文を使用して捕捉できます。例外を捕捉することは、例外を何らかの方法で「処理」し、後続のコードは通常どおり実行されるべきであり、例外はそれ以上上に伝播されません。

    注意:例外が発生したが捕捉されなかった場合、アプリケーション全体がエラーで停止します。

    • ただし、LCLアプリケーションでは、例外が早期に捕捉されない場合、イベント(およびLCLダイアログボックス)の周りで例外が常に捕捉されます。

    • Castle Game EngineアプリケーションでCastleWindowを使用している場合も同様に、イベントの周りで例外が常に捕捉され、適切なダイアログボックスが表示されます。

    • そのため、どこにも捕捉されない例外を発生させることはそれほど簡単ではありません(コードで捕捉されず、LCLコード、CGEコード…​でも捕捉されない)。

  • 例外は実行を中断しますが、try … finally … end構文を使用して、例外が発生した場合でも常にコードを実行できます。

    try … finally … end構文は、BreakまたはContinueまたはExitキーワードでコードが中断された場合でも機能します。ポイントは、finallyセクションのコードを常に実行することです。

「例外」は、一般的に、任意のクラスインスタンスです。

  • コンパイラは特定のクラスを強制しません。XXXが任意のクラスのインスタンスである場合にraise XXXを呼び出すだけで済みます。任意のクラス(つまり、TObjectを継承するすべて)で問題ありません。

  • 例外クラスは、慣習として、特別なExceptionクラスを継承する名前を持ちます。ExceptionクラスはTObjectを拡張し、Message文字列プロパティと、このプロパティを簡単に設定するためのコンストラクタを追加します。標準ライブラリによって発生するすべての例外はExceptionを継承します。この慣習に従うことをお勧めします。

  • 例外クラスの名前は、慣習として、TではなくEで始まります。例:ESomethingBadHappened。

  • コンパイラは、例外オブジェクトが処理されたときに自動的に解放します。自分で解放しないでください。

    ほとんどの場合、raiseを呼び出すのと同時に例外インスタンスを構築します。例:raise ESomethingBadHappened.Create('何らかの悪いことが発生したことの説明。')。

6.2. 例外の発生(Raising)

独自の例外を発生させたい場合は、それを宣言し、適切なタイミングでraise …​を呼び出します:

type
  EInvalidParameter = class(Exception);

function ReadParameter: String;
begin
  Result := Readln;
  if Pos(' ', Result) <> 0 then
    raise EInvalidParameter.Create('Invalid parameter, space is not allowed');
end;

raiseの後の式は、発生させる有効なクラスインスタンスである必要があることに注意してください。ほとんどの場合、ここで例外インスタンスを作成します。

CreateFmtコンストラクタを使用することもできます。これは、例外メッセージにさらに情報を提供するための便利なショートカットです。これは、例外メッセージをフォーマットするための便利なショートカットです。前の例を次のように改善できます:

type
  EInvalidParameter = class(Exception);

function ReadParameter: String;
begin
  Result := Readln;
  if Pos(' ', Result) <> 0 then
    raise EInvalidParameter.CreateFmt('Invalid parameter %s, space is not allowed', [Result]);
end;
6.3. 例外の捕捉(Catching)

例外は次のように捕捉できます:

var
  Parameter1, Parameter2, Parameter3: String;
begin
  try
    WriteLn('Input 1st parameter:');
    Parameter1 := ReadParameter;
    WriteLn('Input 2nd parameter:');
    Parameter2 := ReadParameter;
    WriteLn('Input 3rd parameter:');
    Parameter3 := ReadParameter;
  except
    // 上記の ReadParameter のいずれかの呼び出しで発生した EInvalidParameter を捕捉します
    on EInvalidParameter do
      WriteLn('EInvalidParameter exception occurred');
  end;
end;

上記の例を改善するために、例外インスタンスの名前(例ではEを使用)を宣言できます。これにより、例外メッセージを印刷できます:

try
...
except
  on E: EInvalidParameter do
    WriteLn('EInvalidParameter exception occurred with message: ' + E.Message);
end;

複数の例外クラスをテストすることもできます:

try
...
except
  on E: EInvalidParameter do
    WriteLn('EInvalidParameter exception occurred with message: ' + E.Message);
  on E: ESomeOtherException do
    WriteLn('ESomeOtherException exception occurred with message: ' + E.Message);
end;

on式を使用しない場合、発生したすべての例外に対応することもできます:

try
...
except
  WriteLn('Warning: Some exception occurred');
end;
// 警告:以下の「すべての例外を捕捉する」に関する警告を読まずにこの例に従わないでください

一般的に、特定のクラスの例外で、それを処理する方法を知っているものだけを捕捉すべきです。一般的な型の例外を捕捉すること(例えば、すべてのExceptionまたはすべてのTObjectを捕捉すること)には注意してください。なぜなら、あまりにも多くを捕捉してしまい、後で他の問題のデバッグ時に問題を引き起こす可能性があるからです。例外処理を備えたすべてのプログラミング言語と同様に、従うべき良いルールは、処理方法を知らない例外は決して捕捉しないことです。特に、例外が発生する理由を最初に調査せずに、単なる簡単な回避策として例外を捕捉しないでください。

  • 例外がユーザー入力の問題を示している場合、ユーザーに報告すべきです。
  • 例外がコードのバグを示している場合、例外が発生しないようにコードを修正すべきです。

すべての例外を捕捉する別の方法は次のとおりです:

try
...
except
  on E: TObject do
    WriteLn('Warning: Some exception occurred');
end;
// 警告:上記の「すべての例外を捕捉する」に関する警告を読まずにこの例に従わないでください

通常はExceptionを捕捉するだけで十分です:

try
...
except
  on E: Exception do
    WriteLn('Warning: Some exception occurred: ' + E.ClassName + ', message: ' + E.Message);
end;
// 警告:上記の「すべての例外を捕捉する」に関する警告を読まずにこの例に従わないでください

例外をexcept … endブロック内で「再発生」させることができます。例外インスタンスがEの場合、単にraise Eを行うことができます。パラメータなしのraiseを使用することもできます。例:

try
...
except
  on E: EInvalidSoundFile do
  begin
    if E.InvalidUrl = 'http://example.com/blablah.wav' then
      WriteLn('Warning: loading http://example.com/blablah.wav failed, ignore it')
    else
      raise;
  end;
end;

例外はオブジェクトのインスタンスですが、発生させた後に手動で解放してはならないことに注意してください。コンパイラは、例外オブジェクトが処理されると正しく解放されることを保証する適切なコードを生成します。

6.4. Finally(例外発生の有無にかかわらず実行する処理)

多くの場合、try .. finally .. end構文を使用して、例外が発生したかどうかに関わらず、あるオブジェクトのインスタンスを解放します。書き方は次のようになります:

procedure MyProcedure;
var
  MyInstance: TMyClass;
begin
  MyInstance := TMyClass.Create;
  try
    MyInstance.DoSomething;
    MyInstance.DoSomethingElse;
  finally
    FreeAndNil(MyInstance);
  end;
end;

これは常に機能し、MyInstance.DoSomethingまたはMyInstance.DoSomethingElseが例外を発生させた場合でも、メモリリークを引き起こしません。

ローカル変数(上記のMyInstanceなど)は、最初の代入前に未定義の値(ランダムな「メモリガベージ」を含む可能性がある)を持つことを考慮すると、これは有効です。つまり、次のような記述は有効ではありません:

// 間違った例:
procedure MyProcedure;
var
  MyInstance: TMyClass;
begin
  try
    CallSomeOtherProcedure;
    MyInstance := TMyClass.Create;
    MyInstance.DoSomething;
    MyInstance.DoSomethingElse;
  finally
    FreeAndNil(MyInstance);
  end;
end;

上記の例は有効ではありません。TMyClass.Create(コンストラクタも例外を発生させる可能性がある)内、またはCallSomeOtherProcedure内で例外が発生した場合、MyInstance変数は初期化されていません。FreeAndNil(MyInstance)を呼び出すと、MyInstanceのデストラクタを呼び出そうとしますが、これはほとんどの場合アクセス違反(セグメンテーション違反)エラーでクラッシュします。実際には、1つの例外が別の例外を引き起こし、エラーレポートが非常に役に立たなくなります。元の例外のメッセージが表示されません。

時々、すべてのローカル変数をnilに初期化すること(それに対してFreeAndNilを呼び出すのは安全であり、何も行いません)で上記のコードを修正することが正当化される場合があります。これは、多くのクラスインスタンスを解放する場合に意味があります。したがって、次の2つのコード例はどちらも同様に機能します:

procedure MyProcedure;
var
  MyInstance1: TMyClass1;
  MyInstance2: TMyClass2;
  MyInstance3: TMyClass3;
begin
  MyInstance1 := TMyClass1.Create;
  try
    MyInstance1.DoSomething;

    MyInstance2 := TMyClass2.Create;
    try
      MyInstance2.DoSomethingElse;

      MyInstance3 := TMyClass3.Create;
      try
        MyInstance3.DoYetAnotherThing;
      finally
        FreeAndNil(MyInstance3);
      end;
    finally
      FreeAndNil(MyInstance2);
    end;
  finally
    FreeAndNil(MyInstance1);
  end;
end;

次の形式の方がおそらく読みやすいでしょう:

procedure MyProcedure;
var
  MyInstance1: TMyClass1;
  MyInstance2: TMyClass2;
  MyInstance3: TMyClass3;
begin
  MyInstance1 := nil;
  MyInstance2 := nil;
  MyInstance3 := nil;
  try
    MyInstance1 := TMyClass1.Create;
    MyInstance1.DoSomething;

    MyInstance2 := TMyClass2.Create;
    MyInstance2.DoSomethingElse;

    MyInstance3 := TMyClass3.Create;
    MyInstance3.DoYetAnotherThing;
  finally
    FreeAndNil(MyInstance3);
    FreeAndNil(MyInstance2);
    FreeAndNil(MyInstance1);
  end;
end;
注意この単純な例では、コードを3つの個別のプロシージャに分割して、互いに呼び出すことができるという有効な議論もできます。

try .. finally .. endブロックの最後のセクションは、メインコードを離れるほとんどすべてのシナリオで実行されます。これを検討してください:

try
  A;
finally
  B;
end;

したがって、Bは次の場合に実行されます:

  • Aが例外を発生させた(そして捕捉しなかった)場合。
  • または、Exit(ループ内の場合はBreakまたはContinue)をAの呼び出しの直後に呼び出した場合。
  • または、上記のいずれも発生せず、Aのコードが例外なしで実行され、Exit、Break、またはContinueも呼び出されなかった場合。

Bの実行を本当に回避する唯一の方法は、Haltまたはプラットフォーム固有のAPI(Unixのlibc exitなど)を使用してA内で無条件にアプリケーションプロセスを中断することです。これは一般的に行うべきではありません。例外を使用してアプリケーションを中断する方が柔軟性があります。なぜなら、他のコードがクリーンアップする機会を与えるからです。

注意try .. finally .. endは例外を捕捉しません。例外は依然として上に伝播し、このブロックの外側のtry .. except .. endブロックによって捕捉される可能性があります。

Exit呼び出しと組み合わせたtry .. finally .. endの例:

procedure MyProcedure;
begin
  try
    WriteLn('Do something');
    Exit;
    WriteLn('This will not happen');
  finally
    WriteLn('This will happen regardless of whether we have left the block through Exception, Exit, Continue, Break, etc.');
  end;
  WriteLn('This will not happen');
end;

例外の章で、例外の発生方法やtry … except … endを使用して捕捉する方法を含む、例外の詳細な説明を参照してください。

6.5. 各ライブラリによる例外の表示方法
  • Lazarus LCLの場合、イベント中に発生した例外(LCLコンポーネントのOnXxxプロパティに割り当てられたさまざまなコールバック)は捕捉され、ユーザーがアプリケーションを続行または停止できる便利なダイアログメッセージになります。これは、独自の例外がApplication.ProcessMessagesから「漏れ出さない」ことを意味するため、自動的にアプリケーションをクラッシュさせることはありません。TApplicationProperties.OnExceptionを使用して、何が起こるかを構成できます。

  • 同様に、Castle Game EngineでCastleWindowを使用している場合:例外は内部的に捕捉され、便利なエラーメッセージになります。したがって、例外はApplication.ProcessMessagesから「漏れ出さない」ません。ここでも、Application.OnExceptionを使用して、何が起こるかを構成できます。

  • その他のGUIライブラリも上記と同様のことを行う場合があります。

  • その他のアプリケーションの場合、OnHaltProgramにグローバルコールバックを割り当てることで、例外の表示方法を構成できます。

7. ランタイムライブラリ

7.1. ストリームを使用した入出力

モダンなプログラムは、入出力を行うためにTStreamクラスとその多くの派生クラスを使用する必要があります。TFileStream、TMemoryStream、TStringStreamなど、多くの便利な派生クラスがあります。

{$ifdef FPC} {$mode objfpc}{$H+}{$J-} {$endif}
{$ifdef MSWINDOWS} {$apptype CONSOLE} {$endif}

uses
  SysUtils, Classes;

var
  S: TStream;
  InputInt, OutputInt: Integer;
begin
  InputInt := 666;

  S := TFileStream.Create('my_binary_file.data', fmCreate);
  try
    S.WriteBuffer(InputInt, SizeOf(InputInt));
  finally
    FreeAndNil(S);
  end;

  S := TFileStream.Create('my_binary_file.data', fmOpenRead);
  try
    S.ReadBuffer(OutputInt, SizeOf(OutputInt));
  finally
    FreeAndNil(S);
  end;

  WriteLn('Read from file got integer: ', OutputInt);
end.

Castle Game Engine内:Download関数を使用して、任意のURLからデータを取得するストリームを作成する必要があります。通常のファイル、HTTPおよびHTTPSリソース、Androidアセットなどがサポートされています。さらに、ゲームデータ内のリソース(dataサブディレクトリ内)を開くには、特別なcastle-data:/xxx URLを使用します。例:

EnableNetwork := true;
S := Download('https://castle-engine.io/latest.zip');
S := Download('file:///home/michalis/my_binary_file.data');
S := Download('castle-data:/gui/my_image.png');

テキストファイルを読み取るには、TCastleTextReaderクラスの使用を推奨します。これは行指向のAPIを提供し、内部でTStreamをラップします。TCastleTextReaderコンストラクタは、準備済みのURLを受け取るか、カスタムTStreamソースを渡すことができます。

Text := TCastleTextReader.Create('castle-data:/my_data.txt');
try
  while not Text.Eof do
    WriteLnLog('NextLine', Text.ReadLn);
finally
  FreeAndNil(Text);
end;

Download関数とTCastleTextReaderクラスを含む、ストリームの読み書きをロードするためのCastle Game Engineのすべての機能のドキュメントは、https://castle-engine.io/urlにあります。

7.2. コンテナ(リスト、辞書)とジェネリクス

言語とランタイムライブラリは、さまざまな柔軟なコンテナを提供します。非ジェネリッククラス(ContnrsユニットのTListやTObjectListなど)が多数あり、動的配列(array of TMyType)もあります。しかし、最も柔軟性と型安全性を得るためには、ほとんどのニーズにジェネリックコンテナを使用することを推奨します。

ジェネリックコンテナは、追加、削除、反復、検索、ソートなどの多くの便利なメソッドを提供します。コンパイラは、コンテナが適切な型の項目のみを保持していることを認識し(そしてチェックします)。

現在、FPCには3つのライブラリがジェネリックコンテナを提供しています:

  • Generics.Collectionsユニットとその関連(FPC >= 3.2.0以降)
  • FGLユニット
  • GVectorユニットとその関連(fcl-stlにまとめられています)

Generics.Collectionsユニットの使用を推奨します。実装されているジェネリックコンテナは:

  • 便利な機能が満載です。
  • 非常に効率的です(特にキーによる辞書へのアクセスに重要)。
  • FPCとDelphiの間で互換性があります。
  • 名前付けは、標準ライブラリの他の部分(Contnrsユニットの非ジェネリックコンテナなど)と一貫しています。

Castle Game Engine内:エンジン全体でGenerics.Collectionsを頻繁に使用しており、アプリケーションでもGenerics.Collectionsの使用を推奨します!

Generics.Collectionsユニットの最も重要なクラスは次のとおりです:

TList

型のジェネリックリスト。
TObjectList

オブジェクトインスタンスのジェネリックリスト。子オブジェクトを「所有」でき、自動的に解放します。
TDictionary

ジェネリック辞書。
TObjectDictionary

キーおよび/または値オブジェクトを「所有」できるジェネリック辞書。

ここでは、単純なジェネリックTObjectListの使用例を示します:

{$ifdef FPC} {$mode objfpc}{$H+}{$J-} {$endif}
{$ifdef MSWINDOWS} {$apptype CONSOLE} {$endif}

uses SysUtils, Generics.Collections;

type
  TApple = class
    Name: string;
  end;

  TAppleList = {$ifdef FPC}specialize{$endif} TObjectList<TApple>;

var
  A: TApple;
  Apples: TAppleList;
begin
  Apples := TAppleList.Create(true);
  try
    A := TApple.Create;
    A.Name := 'my apple';
    Apples.Add(A);

    A := TApple.Create;
    A.Name := 'another apple';
    Apples.Add(A);

    Writeln('Count: ', Apples.Count);
    Writeln(Apples[0].Name);
    Writeln(Apples[1].Name);
  finally FreeAndNil(Apples)
  end;
end.

ソートや検索(例:SortおよびIndexOfメソッドによる)のような比較が必要な操作には、コンパイラが使用されます。Generics.Collectionsコンテナはコンパイラを使用します。デフォルトコンパイラは、すべての型に対して合理的です。レコードの場合でさえ(その場合、メモリ内容を比較します。これは少なくともIndexOfを使用した検索のデフォルトとしては合理的です)。

リストをソートする場合、カスタムコンパイラをパラメータとして提供できます。コンパイラはIComparerインターフェースを実装するクラスです。実際には、通常は適切なコールバックを定義し、TComparer<T>.Constructメソッドを使用してこのコールバックをIComparerインスタンスにラップします。これを行う例を以下に示します:

{$ifdef FPC} {$mode objfpc}{$H+}{$J-} {$endif}
{$ifdef MSWINDOWS} {$apptype CONSOLE} {$endif}

{ GENERICS_CONSTREF が定義されている場合、Generics.Collections で使用される様々なルーチン
  (TComparer に渡すコールバック、OnNotify コールバック、Notify 仮想メソッドなど)
  は "const" ではなく "constref" パラメータを持つべきです。
  これは FPC <= 3.2.0 の場合でした。
  FPC は constref->const に変更しました
  https://gitlab.com/freepascal.org/fpc/source/-/commit/693491048bf2c6f9122a0d8b044ad0e55382354d
  そして、この変更は FPC fixes ブランチ 3.2.3 およびそれ以降の 3.2.4(rc1) に存在します。}
{$ifdef VER3_0} {$define GENERICS_CONSTREF} {$endif}
{$ifdef VER3_2_0} {$define GENERICS_CONSTREF} {$endif}
{$ifdef VER3_2_2} {$define GENERICS_CONSTREF} {$endif}

uses SysUtils, Generics.Defaults, Generics.Collections;

type
  TApple = class
    Name: string;
  end;

  TAppleList = {$ifdef FPC}specialize{$endif} TObjectList<TApple>;

function CompareApples(
  {$ifdef GENERICS_CONSTREF}constref{$else}const{$endif}
  Left, Right: TApple): Integer;
begin
  Result := AnsiCompareStr(Left.Name, Right.Name);
end;

type
  TAppleComparer = {$ifdef FPC}specialize{$endif} TComparer<TApple>;
var
  A: TApple;
  L: TAppleList;
begin
  L := TAppleList.Create(true);
  try
    A := TApple.Create;
    A.Name := '11';
    L.Add(A);

    A := TApple.Create;
    A.Name := '33';
    L.Add(A);

    A := TApple.Create;
    A.Name := '22';
    L.Add(A);

    L.Sort(TAppleComparer.Construct({$ifdef FPC}@{$endif} CompareApples));

    Writeln('Count: ', L.Count);
    Writeln(L[0].Name);
    Writeln(L[1].Name);
    Writeln(L[2].Name);
  finally FreeAndNil(L)
  end;
end.

TDictionaryクラスは辞書、別名マップ(キー → 値)、別名連想配列を実装します。そのAPIはC#のTDictionaryクラスと少し似ています。キー、値、およびキー→値のペアの便利なイテレータがあります。

辞書を使用する例:

{$ifdef FPC} {$mode objfpc}{$H+}{$J-} {$endif}
{$ifdef MSWINDOWS} {$apptype CONSOLE} {$endif}

uses SysUtils, Generics.Collections;

type
  TApple = class
    Name: string;
  end;

  TAppleDictionary = {$ifdef FPC}specialize{$endif} TDictionary<String, TApple>;

var
  Apples: TAppleDictionary;
  A, FoundA: TApple;
  ApplePair: {$ifdef FPC} TAppleDictionary.TDictionaryPair {$else} TPair<String, TApple> {$endif};
  AppleKey: string;
begin
  Apples := TAppleDictionary.Create;
  try
    A := TApple.Create;
    A.Name := 'my apple';
    Apples.AddOrSetValue('apple key 1', A);

    if Apples.TryGetValue('apple key 1', FoundA) then
      Writeln('Found apple under key "apple key 1" with name: ' +
        FoundA.Name);

    for AppleKey in Apples.Keys do
      Writeln('Found apple key: ' + AppleKey);
    for A in Apples.Values do
      Writeln('Found apple value: ' + A.Name);
    for ApplePair in Apples do
      Writeln('Found apple key->value: ' +
        ApplePair.Key + '->' + ApplePair.Value.Name);

    { 下の行も機能しますが、*既存の*辞書キーを設定するためにのみ使用できます。
      代わりに、必要に応じて新しいキーを設定または追加するために、
      通常は AddOrSetValue を使用します。}
    // Apples['apple key 1'] := ... ;

    Apples.Remove('apple key 1');

    { TDictionary はアイテムを所有しないことに注意してください。
      自分で解放する必要があります。
      自動所有権メカニズムを持つ TObjectDictionary を使用することもできます。}
    A.Free;
  finally FreeAndNil(Apples)
  end;
end.

FGLユニットをGenerics.Collectionsの代わりに好む場合、FGLユニットの最も重要なクラスは次のとおりです:

TFPGList

型のジェネリックリスト。
TFPGObjectList

オブジェクトインスタンスのジェネリックリスト。子オブジェクトを「所有」できます。
TFPGMap

ジェネリック辞書。

FGLユニットでは、TFPGListは等号演算子(=)が定義されている型にのみ使用できます。TFPGMapの場合、キー型の「より大きい」(>)および「より小さい」(<)演算子を定義する必要があります。これらのリストを組み込み比較演算子を持たない型(例:レコード)で使用したい場合は、演算子オーバーロードで示されているように演算子をオーバーロードする必要があります。

Castle Game Engine内:CastleGenericListsユニットには、TGenericStructListとTGenericStructMapクラスが追加されています。これらはTFPGListとTFPGMapに似ていますが、適切な型の比較演算子の定義を必要としません(代わりに、メモリ内容を比較します。これはレコードやメソッドポインタにとってしばしば適切です)。しかし、CastleGenericListsユニットはエンジンバージョン6.3以降非推奨であり、代わりにGenerics.Collectionsを使用することを推奨します。

ジェネリクスについてさらに知りたい場合は、ジェネリクスを参照してください。

7.3. クローニング: TPersistent.Assign

単純な代入演算子によるクラスインスタンスのコピーは、参照をコピーします。

var
  X, Y: TMyObject;
begin
  X := TMyObject.Create;
  Y := X;
  // X と Y は今や同じデータへの2つのポインタです
  Y.MyField := 123; // これは X.MyField も変更します
  FreeAndNil(X);
end;

クラスインスタンスの内容をコピーするには、標準的なアプローチは、クラスをTPersistentから派生させ、そのAssignメソッドをオーバーライドすることです。TMyObjectで適切に実装されたら、次のように使用します:

var
  X, Y: TMyObject;
begin
  X := TMyObject.Create;
  Y := TMyObject.Create;
  Y.Assign(X);
  Y.MyField := 123; // これは X.MyField を変更しません
  FreeAndNil(X);
  FreeAndNil(Y);
end;

これを機能させるには、コピーしたいフィールドを実際にコピーするようにAssignメソッドを実装する必要があります。ソースクラスが現在のクラスの派生クラスである可能性があることを考慮して、Assignメソッドを慎重に実装する必要があります。

{$ifdef FPC} {$mode objfpc}{$H+}{$J-} {$endif}
{$ifdef MSWINDOWS} {$apptype CONSOLE} {$endif}

uses
  SysUtils, Classes;

type
  TMyClass = class(TPersistent)
  public
    MyInt: Integer;
    procedure Assign(Source: TPersistent); override;
  end;

  TMyClassDescendant = class(TMyClass)
  public
    MyString: string;
    procedure Assign(Source: TPersistent); override;
  end;

procedure TMyClass.Assign(Source: TPersistent);
var
  SourceMyClass: TMyClass;
begin
  if Source is TMyClass then
  begin
    SourceMyClass := TMyClass(Source);
    MyInt := SourceMyClass.MyInt;
    // Xxx := SourceMyClass.Xxx; // ここに新しいフィールドを追加します
  end else
    { TMyClass は TPersistent の直接の派生クラスであるため、
      Source クラスを処理できない場合にのみ inherited を呼び出します。
      以下のコメントを参照してください。}
    inherited Assign(Source);
end;

procedure TMyClassDescendant.Assign(Source: TPersistent);
var
  SourceMyClassDescendant: TMyClassDescendant;
begin
  if Source is TMyClassDescendant then
  begin
    SourceMyClassDescendant := TMyClassDescendant(Source);
    MyString := SourceMyClassDescendant.MyString;
    // Xxx := SourceMyClassDescendant.Xxx; // ここに新しいフィールドを追加します
  end;

  { TMyClassDescendant は既に Assign をオーバーライドした親クラス(TMyClass.Assign)を持っているため、
    常に inherited を呼び出し、TMyClass.Assign が残りのフィールドを処理できるようにします。
    詳細な理由については、以下のコメントを参照してください。}
  inherited Assign(Source);
end;

var
  C1, C2: TMyClass;
  CD1, CD2: TMyClassDescendant;
begin
  // TMyClass.Assign のテスト
  C1 := TMyClass.Create;
  C2 := TMyClass.Create;
  try
    C1.MyInt := 666;
    C2.Assign(C1);
    WriteLn('C2 state: ', C2.MyInt);
  finally
    FreeAndNil(C1);
    FreeAndNil(C2);
  end;

  // TMyClassDescendant.Assign のテスト
  CD1 := TMyClassDescendant.Create;
  CD2 := TMyClassDescendant.Create;
  try
    CD1.MyInt := 44;
    CD1.MyString := 'blah';
    CD2.Assign(CD1);
    WriteLn('CD2 state: ', CD2.MyInt, ' ', CD2.MyString);
  finally
    FreeAndNil(CD1);
    FreeAndNil(CD2);
  end;
end.

場合によっては、宛先クラスでAssignメソッドをオーバーライドする代わりに、ソースクラスでAssignToメソッドをオーバーライドする方が便利です。

Assign実装でinheritedを呼び出す際には注意が必要です。2つの状況があります:

クラスがTPersistentクラスの直接の派生クラスである場合。(または、TPersistentの直接の派生クラスではないが、親クラスのいずれもAssignメソッドをオーバーライドしていない場合)

この場合、クラスはinheritedキーワードを使用するべきです(TPersistent.Assignを呼び出すため)。ただし、コードで代入を処理できる場合は、それを行う必要はありません。

クラスが既にAssignメソッドをオーバーライドしたクラスを継承している場合。

この場合、クラスは常にinheritedキーワードを使用するべきです(親のAssignを呼び出すため)。一般的に、オーバーライドされたメソッドでinheritedを呼び出すことは、通常は良い考えです。

上記のルール(Assign実装からいつinheritedを呼び出すべきか、いつ呼び出すべきでないか)の理由と、それがAssignToメソッドとどのように関連するかを理解するために、TPersistent.AssignとTPersistent.AssignToの実装を見てみましょう:

procedure TPersistent.Assign(Source: TPersistent);
begin
  if Source <> nil then
    Source.AssignTo(Self)
  else
    raise EConvertError...
end;

procedure TPersistent.AssignTo(Destination: TPersistent);
begin
  raise EConvertError...
end;
注意これはTPersistentの正確な実装ではありません。FPC標準ライブラリのコードをコピーしましたが、その後、重要でない詳細を隠すために簡略化しました。

上記のコードから得られる結論は次のとおりです:

  • AssignもAssignToもオーバーライドされていない場合、それらを呼び出すと例外が発生します。
  • また、TPersistentの実装には、クラスのすべてのフィールド(または公開フィールドすべて)を自動的にコピーするコードはありません。そのため、すべてのクラスでAssignをオーバーライドして自分でコピーする必要があります。RTTI(実行時型情報)を使用できますが、単純なケースでは、おそらくフィールドを手動でリストアップするだけでしょう。

TAppleのようなクラスがある場合、TApple.Assign実装は通常、TAppleクラス固有のフィールド(TFruitのようなTAppleの親クラスのものではなく)のコピーを処理します。したがって、TApple.Assign実装は通常、Source is TAppleを最初にチェックしてから、Apple関連のフィールドをコピーします。次に、inheritedを呼び出して、TFruitが残りのフィールドを処理できるようにします。

TFruit.AssignとTApple.Assignを標準パターン(上記の例のように)に従って実装したと仮定すると、効果は次のようになります:

  • TAppleインスタンスをTApple.Assignに渡した場合、機能し、すべてのフィールドがコピーされます。
  • TOrangeインスタンスをTApple.Assignに渡した場合、機能し、両方のTOrangeとTAppleに共通のフィールドのみがコピーされます。つまり、TFruitで定義されたフィールドです。
  • TWerewolfインスタンスをTApple.Assignに渡した場合、例外が発生します(TApple.AssignがTFruit.Assignを呼び出し、それがTPersistent.Assignを呼び出し、例外が発生するため)。
注意TPersistentから派生する場合、デフォルトの可視性指定子はpublishedであり、TPersistent派生クラスのストリーミングを許可します。すべてのフィールドとプロパティ型がpublishedセクションで許可されているわけではありません。エラーが発生し、ストリーミングを気にしない場合は、単に可視性をpublicに変更してください。詳細は可視性指定子を参照してください。

8. その他の言語機能

8.1. ローカル(ネストした)ルーチン

より大きなルーチン(関数、プロシージャ、メソッド)の中に、ヘルパールーチンを定義できます。

ローカルルーチンは、親のすべてのパラメータ、およびその親の上で宣言されたすべてのローカル変数に自由にアクセス(読み書き)できます。これは非常に強力です。多くの場合、多くの労力をかけずに長いルーチンをいくつかの小さなルーチンに分割できます(必要な情報をすべてパラメータで渡す必要がないため)。この機能を過度に使用しないように注意してください。多くのネストした関数が親の同じ変数を使用(または変更)する場合、コードの追跡が困難になる可能性があります。

これら2つの例は同等です:

function SumOfSquares(const N: Integer): Integer;

  function Square(const Value: Integer): Integer;
  begin
    Result := Value * Value;
  end;

var
  I: Integer;
begin
  Result := 0;
  for I := 0 to N do
    Result := Result + Square(I);
end;

ローカルルーチンSquareがIに直接アクセスできるようにした別のバージョン:

function SumOfSquares(const N: Integer): Integer;
var
  I: Integer;

  function Square: Integer;
  begin
    Result := I * I;
  end;

begin
  Result := 0;
  for I := 0 to N do
    Result := Result + Square;
end;

ローカルルーチンは任意の深さまでネストできます。つまり、別のローカルルーチン内にローカルルーチンを定義できます。したがって、ワイルドに行けます(ただし、コードが読みにくくなるため、あまりにもワイルドに行かないでください:)。

8.2. コールバック(イベント、関数ポインタ、プロシージャ変数とも呼ばれる)

これらは、変数を通じて関数を間接的に呼び出すことを可能にします。変数は実行時に、パラメータの型と戻り値の型が一致する任意の関数を指すように割り当てることができます。

コールバックは次のいずれかになります:

  • ノーマル:これは、任意のノーマルルーチン(メソッドやローカルルーチンではない)を指すことができます。