2024年7月28日 星期日

在 Delphi 中,指针(Pointer)是一种非常强大的工具

 在 Delphi 中,指针(Pointer)是一种非常强大的工具,可以直接操作内存地址。这些指针主要用于需要高效或特定内存操作的场景。以下是一些常见的指针使用示例,包括基本用法、动态内存分配以及数组和记录的操作。


### 基本指针用法


```delphi

procedure BasicPointerExample;

var

  Ptr: ^Integer;

  Value: Integer;

begin

  Value := 42;

  Ptr := @Value; // 获取变量 Value 的地址

  ShowMessage(IntToStr(Ptr^)); // 显示 Ptr 指向的值,即 42

end;

```


### 动态内存分配


```delphi

procedure DynamicMemoryAllocationExample;

var

  Ptr: ^Integer;

begin

  // 动态分配内存

  New(Ptr);

  Ptr^ := 42; // 设置 Ptr 指向的内存的值

  ShowMessage(IntToStr(Ptr^)); // 显示 Ptr 指向的值,即 42

  Dispose(Ptr); // 释放内存

end;

```


### 操作数组


```delphi

procedure ArrayPointerExample;

var

  Arr: array[1..5] of Integer;

  Ptr: ^Integer;

  I: Integer;

begin

  // 初始化数组

  for I := 1 to 5 do

    Arr[I] := I * 10;


  // 获取数组的指针

  Ptr := @Arr[1];


  // 通过指针访问数组

  for I := 0 to 4 do

    ShowMessage(IntToStr((Ptr + I)^)); // 显示 10, 20, 30, 40, 50

end;

```


### 操作记录


```delphi

type

  TMyRecord = record

    Age: Integer;

    Name: string;

  end;

  PMyRecord = ^TMyRecord;


procedure RecordPointerExample;

var

  Rec: TMyRecord;

  Ptr: PMyRecord;

begin

  Rec.Age := 30;

  Rec.Name := 'John Doe';


  Ptr := @Rec; // 获取记录的指针


  ShowMessage(IntToStr(Ptr^.Age)); // 显示 30

  ShowMessage(Ptr^.Name); // 显示 John Doe

end;

```


### 使用 `GetMem` 和 `FreeMem` 分配和释放内存


```delphi

procedure GetMemFreeMemExample;

var

  Ptr: Pointer;

  Value: Integer;

begin

  // 分配内存

  GetMem(Ptr, SizeOf(Integer));

  Integer(Ptr^) := 42; // 设置 Ptr 指向的内存的值

  Value := Integer(Ptr^);

  ShowMessage(IntToStr(Value)); // 显示 42

  // 释放内存

  FreeMem(Ptr);

end;

```


### 字符串操作


```delphi

procedure StringPointerExample;

var

  Str: string;

  Ptr: PChar;

begin

  Str := 'Hello, Delphi!';

  Ptr := PChar(Str); // 获取字符串的指针


  while Ptr^ <> #0 do

  begin

    ShowMessage(Ptr^); // 显示每个字符

    Inc(Ptr); // 移动到下一个字符

  end;

end;

```


以上示例展示了如何在 Delphi 中使用指针来操作不同类型的数据。使用指针时需特别注意内存管理,以避免内存泄漏或访问无效内存。

Delphi 中,有一些低级别的内存操作指令可以直接操作内存

 在 Delphi 中,有一些低级别的内存操作指令可以直接操作内存。这些指令通常用于需要高性能或特定内存操作的场景。除了 `Move` 之外,常用的低级别内存操作指令还有:


1. **FillChar**

2. **ZeroMemory**

3. **CopyMemory**

4. **FreeMemory**

5. **GetMemory**

6. **ReallocMemory**


### 详细介绍


1. **FillChar**

   用于将内存块填充为指定的字符。


   ```delphi

   procedure FillChar(var X; Count: Integer; Value: Char);

   ```


   示例:


   ```delphi

   var

     Buffer: array[0..9] of Char;

   begin

     FillChar(Buffer, SizeOf(Buffer), 'A');

   end;

   ```


2. **ZeroMemory**

   用于将内存块填充为零。这个函数通常作为 FillChar 的变种使用。


   ```delphi

   procedure ZeroMemory(Destination: Pointer; Length: SIZE_T); stdcall;

   ```


   示例:


   ```delphi

   var

     Buffer: array[0..9] of Byte;

   begin

     ZeroMemory(@Buffer, SizeOf(Buffer));

   end;

   ```


3. **CopyMemory**

   用于从一个内存块复制到另一个内存块。这通常作为 Move 的变种使用。


   ```delphi

   procedure CopyMemory(Destination: Pointer; Source: Pointer; Length: SIZE_T); stdcall;

   ```


   示例:


   ```delphi

   var

     Source, Destination: array[0..9] of Byte;

   begin

     CopyMemory(@Destination, @Source, SizeOf(Source));

   end;

   ```


4. **FreeMemory**

   用于释放内存块。


   ```delphi

   procedure FreeMemory(P: Pointer);

   ```


   示例:


   ```delphi

   var

     Ptr: Pointer;

   begin

     Ptr := GetMemory(100);

     // 使用 Ptr

     FreeMemory(Ptr);

   end;

   ```


5. **GetMemory**

   用于分配内存块。


   ```delphi

   function GetMemory(Size: Integer): Pointer;

   ```


   示例:


   ```delphi

   var

     Ptr: Pointer;

   begin

     Ptr := GetMemory(100);

     // 使用 Ptr

     FreeMemory(Ptr);

   end;

   ```


6. **ReallocMemory**

   用于重新分配内存块。


   ```delphi

   function ReallocMemory(P: Pointer; Size: Integer): Pointer;

   ```


   示例:


   ```delphi

   var

     Ptr: Pointer;

   begin

     Ptr := GetMemory(100);

     Ptr := ReallocMemory(Ptr, 200);

     // 使用 Ptr

     FreeMemory(Ptr);

   end;

   ```


这些低级别内存操作指令提供了对内存的直接控制,但使用时需要特别小心,以避免内存泄漏或内存访问错误。

2024年7月12日 星期五

// 使用 System.Move 进行快速数组复制 array

 program ArrayCopyExample;


{$APPTYPE CONSOLE}


uses

  SysUtils;


procedure CopyArray(const Source: array of Integer; var Dest: array of Integer);

begin

  if Length(Dest) <> Length(Source) then

    raise Exception.Create('Destination array must be the same length as the source array.');


  // 使用 System.Move 进行快速数组复制

  System.Move(Source[0], Dest[0], Length(Source) * SizeOf(Integer));

end;


var

  SourceArray, DestArray: array of Integer;

  i: Integer;

begin

  // 初始化源数组

  SetLength(SourceArray, 5);

  for i := 0 to Length(SourceArray) - 1 do

    SourceArray[i] := i + 1;


  // 初始化目标数组

  SetLength(DestArray, Length(SourceArray));


  // 复制数组

  CopyArray(SourceArray, DestArray);


  // 输出结果

  for i := 0 to Length(DestArray) - 1 do

    WriteLn('DestArray[', i, '] = ', DestArray[i]);


  ReadLn;

end.

2024年7月3日 星期三

GR32 Related example demo

 GR32 is 

graphics32/graphics32: Graphics32 is a graphics library for Delphi and Lazarus. Optimized for 32-bit pixel formats, it provides fast operations with pixels and graphic primitives. In most cases Graphics32 considerably outperforms the standard TBitmap/TCanvas methods. (github.com)

About

Graphics32 is a graphics library for Delphi and Lazarus. Optimized for 32-bit pixel formats, it provides fast operations with pixels and graphic primitives. In most cases Graphics32 considerably outperforms the standard TBitmap/TCanvas methods.

Example code contents:


resize, stretch,..position...
































































CAN FD