Delphi 程式碼效能最佳化技巧與記憶體管理

– 13 分鐘閱讀

Delphi 編譯器本身的自動最佳化能力有限，因此開發者需要深入理解程式邏輯和語言特性，才能有效地進行程式碼最佳化。本文將探討一些常見的 Delphi 最佳化技巧，例如計運算元表示式的最佳化、字串操作的最佳化、以及不同資料型別（如陣列和記錄）的內部運作機制。透過 CPU 視窗，開發者可以觀察程式碼的執行狀況，進而找出效能瓶頸並進行最佳化。瞭解 Delphi 的記憶體管理機制，例如複製寫入（Copy-on-Write）機制，對於編寫高效的程式碼至關重要。

Delphi 的最佳化限制

Delphi 是一種強大的程式設計語言，但其最佳化能力有限。Delphi 的編譯器並不能夠自動最佳化程式碼，需要程式設計師自己進行最佳化。這就需要程式設計師對程式的邏輯和語言有深入的理解，並且能夠找到合適的最佳化方法。

計運算元表示式的最佳化

在程式設計中，計運算元表示式是非常常見的。然而，計運算元表示式的方式可能會影響程式的效能。例如，以下程式碼就展示了計運算元表示式的兩種不同的方式：

// 第一種方式
ListBox1.Items[i] := Copy(ListBox1.Items[i], Pos('-', ListBox1.Items[i]) + 1, Length(ListBox1.Items[i])) + '-' + Copy(ListBox1.Items[i], 1, Pos('-', ListBox1.Items[i]) - 1);

// 第二種方式
s := ListBox1.Items[i];
p := Pos('-', s);
ListBox1.Items[i] := Copy(s, p + 1, Length(s)) + '-' + Copy(s, 1, p - 1);

第二種方式比第一種方式更有效率，因為它只計算了一次 Pos('-', s) 和 ListBox1.Items[i]。

CPU 視窗的幫助

Delphi 提供了一個 CPU 視窗，可以用來檢視程式的低階別狀態和電腦的狀態。這個視窗可以用來檢視程式的執行情況和系統資源的消耗。透過 CPU 視窗，可以檢視程式的每一行指令和系統的狀態，從而找到最佳化的方法。

瞭解程式碼背後的運作機制

在撰寫高效程式碼的過程中，瞭解程式碼背後的運作機制是非常重要的。這包括瞭解編譯器如何實作不同資料型別、記憶體如何被組態和釋放，以及如何最佳化程式碼以提高效能。

資料型別的分類

Delphi 中的資料型別可以分為幾個類別，包括：

  • 簡單型別（Simple Types）：例如整數、字元、布林值等。
  • 指標型別（Pointer Types）：例如指標、記憶體地址等。
  • 字串型別（String Types）：例如 AnsiString、UnicodeString 等。
  • 結構化型別（Structured Types）：例如陣列、記錄、類別等。

字串型別的實作

字串型別是 Delphi 中最常用的資料型別之一，它的實作也是非常有趣的。字串型別可以分為兩種：AnsiString 和 UnicodeString。

  • AnsiString：這種字串型別使用 ANSI 編碼，儲存為一個指標，指向一塊記憶體區域。
  • UnicodeString：這種字串型別使用 Unicode 編碼，儲存為一個指標，指向一塊記憶體區域。

當你修改一個字串的長度時，例如使用 s := s + s 的陳述式，Delphi 會重新組態記憶體，並將原有的字串資料複製到新的記憶體區域中。這是一個相對昂貴的操作，因為它涉及到記憶體的重新組態和資料的複製。

修改字串的實作

當你修改一個字串的內容時，Delphi 會使用一個叫做「複製於寫入」（Copy-on-Write）的機制。這個機制可以確保當你修改一個分享的字串時，不會影響到其他分享同一字串的變數。

例如，當你執行 s1 := s 的陳述式時，Delphi 會將 s1 指向同一塊記憶體區域，並增加參照計數（Reference Count）。如果你之後修改 s1 的內容，Delphi 會重新組態記憶體，並將原有的字串資料複製到新的記憶體區域中。然後，Delphi 會將 s1 指向新的記憶體區域，並減少參照計數。

範例程式碼

// 示例：字串型別的實作
var
  s: string;
  s1: string;
begin
  s := 'Hello, World!';
  s1 := s; // 將 s1 指向同一塊記憶體區域
  // 修改 s1 的內容
  s1 := s1 + '!';
  // 輸出 s 和 s1 的內容
  writeln(s);
  writeln(s1);
end.

在這個範例中，s 和 s1 是兩個字串變數，最初都指向同一塊記憶體區域。當我們修改 s1 的內容時，Delphi 會重新組態記憶體，並將原有的字串資料複製到新的記憶體區域中。最終，s 和 s1 的內容會不同。

字串與陣列的實作細節

在Delphi中，字串的實作是一個複雜的過程。當一個字串被初始化從一個常數值時，編譯器會簡單地將字串變數指向程式資料區域中該字串被建立的位置。為了表示這是一個特殊的、不能被修改的字串，編譯器會將其參考計數設為-1。

當你嘗試修改這樣一個字串時，會觸發「寫時複製」（copy-on-write）機制，該機制會將字串資料複製到一個可以被修改的記憶體區域中。這個過程可以透過UniqueString函式來實作，該函式會將字串資料移到一個可寫的記憶體區域中。

陣列是Delphi中另一種重要的資料結構。Delphi支援兩種陣列：靜態陣列和動態陣列。靜態陣列的大小是固定的，且其下限和上限是可設定的。動態陣列則有一個固定的下限（為0），而其上限是可變的，可以增長或縮小。

以下是一個示例程式碼，展示了靜態陣列和動態陣列的宣告：

var
  sarr1: array [2..22] of integer; // 靜態陣列
  sarr2: array [byte] of string; // 靜態陣列
  darr1: array of TDateTime; // 動態陣列

這個示例中，sarr1和sarr2是靜態陣列，分別具有固定大小和下限、上限。darr1則是一個動態陣列，其上限是可變的。

實作細節

在Delphi中，字串和陣列的實作涉及到記憶體管理和資料結構的複雜細節。以下是一些關於字串和陣列實作的重要細節：

  • 字串的實作涉及到「寫時複製」機制，該機制可以確保字串資料的安全性和效率。
  • 陣列的實作涉及到記憶體管理和資料結構的設計，包括靜態陣列和動態陣列的宣告和使用。
  • Delphi中的UniqueString函式可以用來將字串資料移到一個可寫的記憶體區域中，從而實作「寫時複製」機制。

動態陣列與記錄型別

在 Delphi 中，陣列可以分為靜態陣列和動態陣列。靜態陣列的大小在編譯時就已經確定，而動態陣列的大小可以在執行時動態調整。

動態陣列

動態陣列的宣告方式如下：

darr2: TArray<string>;

動態陣列的大小可以使用 SetLength 函式進行調整。當調整陣列大小時，Delphi 會重新組態記憶體，並將新的記憶體地址儲存在陣列變數中。

SetLength(darr2, 10);

動態陣列的元素可以使用標準的陣列索引方式進行存取。例如：

darr2[0] := 'Hello';

當將一個動態陣列指定給另一個動態陣列時，Delphi 會將兩個陣列的記憶體地址進行複製。這意味著兩個陣列現在指向相同的記憶體位置。

darr1 := darr2;

如果修改其中一個陣列的元素，另一個陣列的元素也會受到影響。這是因為兩個陣列現在指向相同的記憶體位置。

darr1[0] := 'World';
// darr2[0] 也會變成 'World'

如果想要建立一個動態陣列的副本，可以使用 Copy 函式：

darr3 := Copy(darr1);

記錄型別

記錄型別（record）是 Delphi 中的一種複合資料型別，可以包含多個不同型別的欄位。

type
  TRecord = record
    a: Integer;
    b: string;
    c: Boolean;
  end;

記錄型別的欄位可以使用點符號進行存取。例如：

var
  rec: TRecord;
begin
  rec.a := 10;
  rec.b := 'Hello';
  rec.c := True;
end;

記錄型別的初始化可以使用 Default 函式進行。Default 函式會將記錄型別的所有欄位初始化為預設值。

var
  rec: TRecord;
begin
  rec := Default(TRecord);
end;

這樣，rec 變數的所有欄位都會被初始化為預設值。例如，a 欄位會被初始化為 0，b 欄位會被初始化為空字串，c 欄位會被初始化為 False。

記錄型別的初始化和複製

在Delphi中，記錄型別（record）是一種用於儲存多個變數的複合資料結構。當我們建立一個記錄型別的例項時，系統並不會自動初始化其成員變數。這意味著，如果我們不手動初始化記錄型別的成員變數，它們將包含隨機的數值。

記錄型別的初始化

下面的程式碼示範瞭如何初始化一個記錄型別：

type
  TRecord = record
    a: integer;
    b: string;
    c: integer;
  end;

procedure TfrmDataTypes.ShowRecord(const rec: TRecord);
begin
  ListBox1.Items.Add(Format('a = %d, b = ''%s'', c = %d', [rec.a, rec.b, rec.c]));
end;

procedure TfrmDataTypes.btnRecordInitClick(Sender: TObject);
var
  rec: TRecord;
begin
  ShowRecord(rec);
  rec := Default(TRecord);
  ShowRecord(rec);
end;

在這個例子中，TRecord是一個記錄型別，包含三個成員變數：a、b和c。ShowRecord程式式用於顯示記錄型別的成員變數的值。btnRecordInitClick程式式示範瞭如何初始化記錄型別的成員變數。第一次呼叫ShowRecord時，記錄型別的成員變數包含隨機的數值。第二次呼叫ShowRecord時，記錄型別的成員變數已經被初始化為預設值。

記錄型別的複製

當我們將一個記錄型別的例項指定給另一個記錄型別的例項時，系統會自動複製記錄型別的成員變數。然而，如果記錄型別包含管理型別（managed type）的成員變數，系統會呼叫一個通用的複製方法，這個方法可能不是最佳化的。

下面的程式碼示範瞭如何比較未管理記錄型別和管理記錄型別的複製效率：

type
  TUnmanaged = record
    a, b, c, d: NativeUInt;
  end;

  TManaged = record
    a, b, c, d: IInterface;
  end;

procedure TfrmDataTypes.btnCopyRecClick(Sender: TObject);
var
  u1, u2: TUnmanaged;
  m1, m2: TManaged;
  i: Integer;
  sw: TStopwatch;
begin
  u1 := Default(TUnmanaged);
  sw := TStopwatch.StartNew;
  for i := 1 to 1000000 do
    u2 := u1;
  sw.Stop;
  ListBox1.Items.Add(Format('TUnmanaged: %d ms', [sw.ElapsedMilliseconds]));
  m1 := Default(TManaged);
  sw := TStopwatch.StartNew;
  for i := 1 to 1000000 do
    m2 := m1;
  sw.Stop;
  ListBox1.Items.Add(Format('TManaged: %d ms', [sw.ElapsedMilliseconds]));
end;

在這個例子中，TUnmanaged是一個未管理記錄型別，包含四個NativeUInt成員變數。TManaged是一個管理記錄型別，包含四個IInterface成員變數。btnCopyRecClick程式式示範瞭如何比較這兩個記錄型別的複製效率。結果顯示，未管理記錄型別的複製速度明顯快於管理記錄型別。

記錄型別的建構函式

Delphi允許我們定義記錄型別的建構函式。建構函式是一種特殊的方法，用於初始化記錄型別的成員變數。下面的程式碼示範瞭如何定義一個記錄型別的建構函式：

type
  TRecValue = record
    Value: integer;
    constructor Create(AValue: integer);
    class function Create: TRecValue;
  end;

constructor TRecValue.Create(AValue: integer);
begin
  Value := AValue;
end;

class function TRecValue.Create: TRecValue;
begin
  Result := Default(TRecValue);
end;

在這個例子中，TRecValue是一個記錄型別，包含一個Value成員變數。Create建構函式用於初始化Value成員變數。Create類函式用於傳回一個預設初始化的記錄型別例項。

圖表翻譯：

  graph LR
    A[記錄型別] --> B[初始化]
    B --> C[複製]
    C --> D[建構函式]
    D --> E[初始化]
    E --> F[傳回預設初始化例項]

這個圖表顯示了記錄型別的初始化、複製和建構函式之間的關係。

Delphi 記錄型別的初始化和終結

Delphi 的記錄型別（record）是一種用於儲存多個欄位的複合資料型別。雖然記錄型別不能像類別（class）一樣具有建構子（constructor）和解構子（destructor），但 Delphi 10.4 Sydney 引入了初始值設定項（initializer）和終結值設定項（finalizer）來提供類似的功能。

記錄型別的建構子和類別建構子

記錄型別的建構子與類別建構子不同，記錄型別的建構子不會真正地建立和銷毀記錄例項，而是隻是一種方便的語法糖。記錄型別的建構子可以用來初始化記錄的欄位，但不會有任何記憶體分配或釋放的動作。

type
  TRecValue = record
    Value: integer;
  public
    constructor Create(AValue: integer);
  end;

constructor TRecValue.Create(AValue: integer);
begin
  Value := AValue;
end;

自訂管理記錄

Delphi 10.4 Sydney 引入了初始值設定項和終結值設定項來提供自訂管理記錄的功能。這些設定項可以用來初始化和終結記錄例項。

type
  TCustomRecord = record
  private
    class var GNextID: integer;
  public
    Value: integer;
    Name: string;
    class constructor Create;
    constructor Create(AValue: integer; const AName: string);
    class operator Initialize(out Dest: TCustomRecord);
    class operator Finalize(var Dest: TCustomRecord);
    class operator Assign(var Dest: TCustomRecord; const [ref] Src: TCustomRecord);
  end;

初始值設定項和終結值設定項

初始值設定項和終結值設定項是用來初始化和終結記錄例項的特殊方法。這些方法可以用來設定記錄的初始值和終結值。

class operator TCustomRecord.Initialize(out Dest: TCustomRecord);
begin
  // 初始化 Dest 記錄例項
  Dest.Name := 'Record ' + IntToStr(GNextID);
  Inc(GNextID);
end;

class operator TCustomRecord.Finalize(var Dest: TCustomRecord);
begin
  // 終結 Dest 記錄例項
  // ...
end;

指派運運算元

指派運運算元是用來複製記錄例項的特殊方法。這個方法可以用來設定記錄的欄位值。

class operator TCustomRecord.Assign(var Dest: TCustomRecord; const [ref] Src: TCustomRecord);
begin
  // 複製 Src 記錄例項到 Dest 記錄例項
  Dest.Value := Src.Value;
  Dest.Name := '[Copy] ' + Src.Name;
end;

自訂記錄類別的複雜行為

在 Delphi 中，自訂記錄類別 (TCustomRecord) 的行為可能會比預期更複雜。以下是對其行為的分析。

建構子和初始化

當建立一個 TCustomRecord 例項時，會呼叫其建構子 (Create 方法)。在這個方法中，會設定記錄的 Value 和 Name 屬性，並將這些資訊新增到列表方塊中。

constructor TCustomRecord.Create(
  AValue: integer; const AName: string);
begin
  frmDataTypes.ListBox1.Items.Add(Format(
    '...creating "%s":%d (was "%s":%d)',
    [AName, AValue, Name, Value]));
  Value := AValue;
  Name := AName;
end;

初始化運運算元

TCustomRecord 類別也定義了一個初始化運運算元 (Initialize 方法)。這個方法會設定記錄的 Name 屬性，並將這些資訊新增到列表方塊中。

class operator TCustomRecord.Initialize(
  out Dest: TCustomRecord);
begin
  Dest.Name := 'Record ' + IntToStr(GNextID);
  Inc(GNextID);
  frmDataTypes.ListBox1.Items.Add(Format(
    '...initializing "%s":%d', [Dest.Name, Dest.Value]));
end;

指派運運算元

當將一個 TCustomRecord 例項指派給另一個例項時，會呼叫指派運運算元 (Assign 方法)。在這個方法中，會設定目的記錄的 Value 和 Name 屬性，並將這些資訊新增到列表方塊中。

class operator TCustomRecord.Assign(
  var Dest: TCustomRecord;
  const [ref] Src: TCustomRecord);
begin
  Dest.Value := Src.Value;
  Dest.Name := '[Copy] ' + Src.Name;
  frmDataTypes.ListBox1.Items.Add(Format(
    '...copying "%s":%d => "%s":%d',
    [Src.Name, Src.Value, Dest.Name, Dest.Value]));
end;

最終化運運算元

當 TCustomRecord 例項被最終化時，會呼叫最終化運運算元 (Finalize 方法)。在這個方法中，會將這些資訊新增到列表方塊中。

class operator TCustomRecord.Finalize(
  var Dest: TCustomRecord);
begin
  frmDataTypes.ListBox1.Items.Add(Format(
    '...finalizing "%s":%d', [Dest.Name, Dest.Value]));
end;

按鈕點選事件

當按鈕被點選時，會執行以下程式碼：

procedure TfrmDataTypes.btnCustomManagedRecordsClick(
  Sender: TObject);
var
  a, b, c: TCustomRecord;
begin
  Listbox1.Items.Add('Create a');
  a := TCustomRecord.Create(42, 'record A');
  ListBox1.Items.Add(Format('a = "%s":%d', [a.Name, a.Value]));
  b.Create(17, 'record B');
  ListBox1.Items.Add(Format('b = "%s":%d', [b.Name, b.Value]));
  Listbox1.Items.Add('Assign c := ' + a.Name);
  c := a;
  ListBox1.Items.Add(Format('c = "%s":%d', [c.Name, c.Value]));
  Listbox1.Items.Add('Exit');
end;

這個程式碼會建立三個 TCustomRecord 例項：a、b 和 c。然後，它會將 a 的值指派給 c。

輸出結果

如果你執行這個程式碼，你會看到以下輸出：

Create a
...creating "record A":42 (was "":0)
a = "record A":42
...creating "record B":17 (was "":0)
b = "record B":17
Assign c := record A
...copying "record A":42 => "[Copy] record A":42
c = "[Copy] record A":42
Exit
...finalizing "record A":42
...finalizing "record B":17
...finalizing "[Copy] record A":42

這個輸出顯示了 TCustomRecord 例項的建立、指派和最終化過程。

瞭解自訂記錄的運作原理

在 Delphi 中，記錄（record）是一種用於儲存資料的資料結構。當您使用自訂記錄（custom record）時，Delphi 會在幕後執行一些操作，以確保記錄的正確初始化和終結。

記錄的初始化和終結

當您宣告一個記錄變數時，Delphi 會自動初始化記錄的所有欄位。然而，如果您使用自訂記錄，則需要手動初始化記錄的欄位。

type
  TCustomRecord = record
    Name: string;
    Value: Integer;
  end;

var
  rec: TCustomRecord;
begin
  // 初始化記錄
  rec.Name := 'Default Name';
  rec.Value := 0;
end;

當您將一個記錄指派給另一個記錄時，Delphi 會自動複製記錄的所有欄位。

var
  rec1, rec2: TCustomRecord;
begin
  // 複製記錄
  rec2 := rec1;
end;

然而，如果您使用自訂記錄，則需要手動複製記錄的欄位。

var
  rec1, rec2: TCustomRecord;
begin
  // 複製記錄
  rec2.Name := rec1.Name;
  rec2.Value := rec1.Value;
end;

動態陣列和記錄

當您使用動態陣列（dynamic array）儲存記錄時，Delphi 會自動初始化陣列的所有元素。

type
  TCustomRecord = record
    Name: string;
    Value: Integer;
  end;

var
  arr: TArray<TCustomRecord>;
begin
  // 初始化陣列
  SetLength(arr, 3);
end;

然而，如果您使用自訂記錄，則需要手動初始化陣列的所有元素。

var
  arr: TArray<TCustomRecord>;
begin
  // 初始化陣列
  SetLength(arr, 3);
  arr[0].Name := 'Default Name';
  arr[0].Value := 0;
  arr[1].Name := 'Default Name';
  arr[1].Value := 0;
  arr[2].Name := 'Default Name';
  arr[2].Value := 0;
end;

類別和記錄

類別（class）是一種用於儲存資料和方法的資料結構。當您使用類別時，Delphi 會自動初始化類別的所有欄位。

type
  TCustomClass = class
    Name: string;
    Value: Integer;
    constructor Create;
    destructor Destroy;
  end;

constructor TCustomClass.Create;
begin
  // 初始化類別
  Name := 'Default Name';
  Value := 0;
end;

destructor TCustomClass.Destroy;
begin
  // 終結類別
end;

然而，如果您使用自訂類別，則需要手動初始化類別的欄位。

var
  obj: TCustomClass;
begin
  // 初始化類別
  obj := TCustomClass.Create;
  obj.Name := 'Default Name';
  obj.Value := 0;
end;
內容解密：

在這個例子中，我們可以看到 Delphi 如何自動初始化和終結記錄和類別的欄位。然而，如果我們使用自訂記錄和類別，則需要手動初始化和終結記錄和類別的欄位。這需要我們瞭解 Delphi 的記錄和類別的運作原理，並手動初始化和終結記錄和類別的欄位。

圖表翻譯：

  graph LR
    A[記錄] --> B[初始化]
    B --> C[終結]
    C --> D[複製]
    D --> E[動態陣列]
    E --> F[類別]
    F --> G[初始化]
    G --> H[終結]
    H --> I[複製]
    I --> J[動態陣列]
    J --> K[記錄]
    K --> L[類別]
    L --> M[初始化]
    M --> N[終結]
    N --> O[複製]
    O --> P[動態陣列]
    P --> Q[記錄]
    Q --> R[類別]
    R --> S[初始化]
    S --> T[終結]
    T --> U[複製]
    U --> V[動態陣列]
    V --> W[記錄]
    W --> X[類別]
    X --> Y[初始化]
    Y --> Z[終結]
    Z --> A

這個圖表展示了 Delphi 中記錄和類別的運作原理，包括初始化、終結、複製和動態陣列。

介紹 Delphi 的記憶體管理和最佳化技術

Delphi 是一種強大的程式設計語言，具有豐富的功能和工具。然而，記憶體管理和最佳化是任何程式設計師都需要關注的重要課題。在本文中，我們將探討 Delphi 的記憶體管理和最佳化技術，包括物件的建立和銷毀、介面的使用、方法呼叫最佳化等。

從效能最佳化視角來看，Delphi 雖然提供強大的開發能力，但在記憶體管理和最佳化方面仍存在一定限制。本文深入探討了 Delphi 的字串、陣列、記錄等資料型別的底層實作機制，並分析了這些機制對效能的影響。例如，字串的「複製於寫入」機制雖然確保了資料安全，但在頻繁修改字串的場景下可能導致效能瓶頸。同樣，記錄型別的複製操作在包含管理型別時，效率也相對較低。Delphi 提供的 CPU 視窗可以幫助開發者深入瞭解程式碼的執行狀況，進而找出效能瓶頸。然而，Delphi 編譯器的自動最佳化能力有限，開發者需要自行採取最佳化策略，例如減少計運算元表示式、避免不必要的記憶體組態等。對於追求極致效能的應用，需要深入理解 Delphi 的記憶體管理機制和底層實作細節，才能撰寫出高效的程式碼。未來，Delphi 或許可考慮強化編譯器的自動最佳化能力，並提供更便捷的效能分析工具，以降低開發者最佳化程式碼的難度。玄貓認為，深入理解 Delphi 的底層機制並掌握相應的最佳化技巧，對於 Delphi 開發者提升程式效能至關重要。

玄貓

玄貓

技術愛好者，專注於分享程式開發、雲端技術與 AI 應用的心得體會。