【delphi11】delphi基础探索【二、 Delphi 的基本语法：变量声明、数据类型、控制语句】

一、变量声明

在 Delphi 中，变量声明是一个重要的概念。变量可以在程序的不同部分声明，例如在全局范围、局部范围或在类的定义中。以下是 Delphi 中各种变量声明方式的详细介绍：

1. 全局变量声明

全局变量在程序的单元（Unit）中声明，位于 interface 部分或 implementation 部分的 var 关键字之后。全局变量在整个单元中都可见。

unit UnitName;

interface

var
  globalVar1: Integer;
  globalVar2: String;

implementation

var
  globalVar3: Boolean;

end.

2. 局部变量声明

局部变量在程序的特定部分（如过程或函数）内声明。它们只在声明它们的代码块内可见。

procedure MyProcedure;
var
  localVar1: Integer;
  localVar2: String;
begin
  // 这里可以使用 localVar1 和 localVar2
end;

3. 类型变量声明

在定义类时，可以在类的定义中声明变量。这些变量作为类的属性存在。

type
  TMyClass = class
    private
      classVar1: Integer;
    public
      classVar2: String;
  end;

4. 记录（Record）变量声明

在 Delphi 中，可以使用记录（Record）类型来声明复合变量。

type
  TPerson = record
    Name: String;
    Age: Integer;
  end;

var
  personVar: TPerson;

5. 数组变量声明

数组是存储一系列同类型数据的变量。

var
  arrayVar: array[1..10] of Integer;

6. 动态数组变量声明

动态数组的大小可以在运行时改变。

var
  dynamicArrayVar: array of Integer;

7. 枚举类型变量声明

枚举类型允许声明一组命名的常量。

type
  TDays = (Mon, Tue, Wed, Thu, Fri, Sat, Sun);

var
  today: TDays;

8. 指针变量声明

指针变量用于存储内存地址。

var
  ptrVar: ^Integer;

9. 集合类型变量声明

集合类型用于存储不重复的元素集合。

type
  TNumbers = set of 1..10;

var
  numberSet: TNumbers;

10. 文件类型变量声明

文件类型用于文件操作。

var
  fileVar: File;

11. Variant 类型变量声明

Variant 类型是一种特殊的类型，可以存储不同类型的数据

var
  variantVar: Variant;

总结

变量类型：

整型 (Integer, ShortInt, LongInt, Byte 等)

Integer：常用的整数类型，占用 4 个字节。
ShortInt：较小的整数，占用 1 个字节。
LongInt：较大的整数，占用 4 个字节。
Byte：无符号的小整数，占用 1 个字节。

浮点型 (Real, Double, Extended 等)

Real：单精度浮点数。
Double：双精度浮点数。
Extended：扩展精度的浮点数。

字符串类型 (String, Char)

String：字符串类型，用于存储文本。
Char：字符类型，存储单个字符。

布尔型 (Boolean)

Boolean：布尔类型，表示真 (True) 或假 (False)。

其他类型 如 Variant, Array 等。

二、控制语句

If 语句

if 条件表达式 then
begin
  // 条件为真时执行的代码
end
else
begin
  // 条件为假时执行的代码
end;

Case 语句

case 变量 of
  值1: 执行语句1;
  值2: 执行语句2;
  ...
  else 执行默认语句;
end;

For 循环

for 变量 := 初始值 to 结束值 do
begin
  // 循环体
end;

While 循环

while 条件表达式 do
begin
  // 循环体
end;

Repeat-Until 循环

repeat
  // 循环体
until 条件表达式;

总结

控制结构分为if类型和循环体结构，其中if判断控制有 if else 、 case等。而循环结构大致有五种下面为实例代码：

program LoopExample;

{$APPTYPE CONSOLE}

uses
  SysUtils, Generics.Collections;

var
  numbers: array[1..5] of Integer = (2, 4, 6, 8, 10);
  total, i, threshold: Integer;
  number: Integer;
  reversedNumbers: TList<Integer>;

begin
  // For 循环
  WriteLn('For 循环输出:');
  for i := 1 to Length(numbers) do
    WriteLn('numbers[', i, '] = ', numbers[i]);

  // While 循环
  threshold := 5;
  i := 1;
  WriteLn('While 循环，找到第一个大于 ', threshold, ' 的数字:');
  while (i <= Length(numbers)) and (numbers[i] <= threshold) do
    Inc(i);
  if i <= Length(numbers) then
    WriteLn('找到的数字: ', numbers[i]);

  // Repeat-Until 循环
  i := 1;
  total := 0;
  repeat
    total := total + numbers[i];
    Inc(i);
  until i > Length(numbers);
  WriteLn('Repeat-Until 循环，数组总和: ', total);

  // For-In 循环
  WriteLn('For-In 循环，翻倍数组元素:');
  for number in numbers do
    WriteLn(number * 2);

  // Foreach 循环（类似于 For-In）
  reversedNumbers := TList<Integer>.Create;
  try
    for number in numbers do
      reversedNumbers.Insert(0, number);
    WriteLn('Foreach 循环，逆序输出数组元素:');
    for number in reversedNumbers do
      WriteLn(number);
  finally
    reversedNumbers.Free;
  end;

  ReadLn;  // 等待用户按键
end.

if和case的程序实例：

program MenuSystem;

{$APPTYPE CONSOLE}

uses
  SysUtils;

var
  choice: Integer;

begin
  repeat
    // 显示菜单
    WriteLn('菜单系统');
    WriteLn('1. 打印消息');
    WriteLn('2. 检查数字');
    WriteLn('3. 退出');
    Write('请输入您的选择 (1-3): ');
    ReadLn(choice);

    // 主菜单逻辑
    case choice of
      1: 
        begin
          WriteLn('您选择了打印消息。');
          // 可以添加更多的 if 逻辑
        end;
      2: 
        begin
          Write('请输入一个数字: ');
          ReadLn(choice);
          // 嵌套 if 语句
          if choice < 0 then
            WriteLn('这是一个负数。')
          else if choice = 0 then
            WriteLn('数字是零。')
          else
            WriteLn('这是一个正数。');

          // 在 if 中使用 case
          if choice >= 0 then
          begin
            case choice of
              0: WriteLn('零是一个特殊的数字。');
              1..10: WriteLn('这个数字位于 1 到 10 之间。');
              else WriteLn('这个数字大于 10。');
            end;
          end;
        end;
      3: WriteLn('退出程序。');
    else
      WriteLn('无效选择，请输入 1 到 3 之间的数字。');
    end;
  until choice = 3;

  WriteLn('程序结束。');
  ReadLn;
end.

三、数据类型

标准类型

整数类型
- ShortInt: 8 位有符号整数。大小：1 字节（32 位和 64 位）。
- Byte: 8 位无符号整数。大小：1 字节（32 位和 64 位）。
- SmallInt: 16 位有符号整数。大小：2 字节（32 位和 64 位）。
- Word: 16 位无符号整数。大小：2 字节（32 位和 64 位）。
- Integer: 32 位有符号整数。大小：4 字节（32 位和 64 位）。
- Cardinal: 32 位无符号整数。大小：4 字节（32 位和 64 位）。
- LongInt: 与 Integer 相同。大小：4 字节（32 位和 64 位）。
- LongWord: 与 Cardinal 相同。大小：4 字节（32 位和 64 位）。
- Int64: 64 位有符号整数。大小：8 字节（32 位和 64 位）。
- UInt64: 64 位无符号整数。大小：8 字节（32 位和 64 位）。
浮点类型
- Real: 与 Single 或 Double 相同，根据平台和编译器设置而定。
- Single: 单精度浮点数。大小：4 字节（32 位和 64 位）。
- Double: 双精度浮点数。大小：8 字节（32 位和 64 位）。
- Extended: 扩展精度浮点数。大小：10 字节（32 位），16 字节（64 位）。
- Comp: 64 位浮点数。大小：8 字节（32 位和 64 位）。
- Currency: 固定小数点，用于财务计算。大小：8 字节（32 位和 64 位）。
字符类型
- Char: 16 位字符。大小：2 字节（32 位和 64 位）。
- WideChar: 与 Char 相同。
- AnsiChar: 8 位字符。大小：1 字节（32 位和 64 位）。
字符串类型
- String: Unicode 字符串。大小：32 位系统中为 4 字节（指针大小），64 位系统中为 8 字节。
- AnsiString: 非 Unicode 字符串。大小：与 String 相同。
- WideString: 宽字符串，使用 COM。大小：与 String 相同。
- ShortString: 长度有限的字符串。最大长度 255 字节。
布尔类型
- Boolean: 布尔值。大小：1 字节（32 位和 64 位）。
- ByteBool: 与 Byte 相同。
- WordBool: 与 Word 相同。
- LongBool: 与 LongInt 相同。
变体类型
- Variant: 任何类型的数据。大小：16 字节（32 位），24 字节（64 位）。
- OleVariant: 类似于 Variant，用于 OLE 自动化。大小与 Variant 相同。
指针类型
- Pointer: 通用指针类型。大小：32 位系统中为 4 字节，64 位系统中为 8 字节。
其他类型
- TDateTime: 日期和时间类型。大小：8 字节（32 位和 64 位）。

其他常用类型

集合类型
- Set of [EnumType]: 枚举类型的集合。大小取决于枚举类型中元素的数量，最多可以有 256 个布尔值（最大 32 字节）。
枚举类型
- EnumType: 用户定义的枚举。大小通常为 1 字节，但可能更大，取决于枚举值的数量。
记录（Record）类型
- Record: 用户定义的复合类型，大小取决于包含的字段。
动态数组
- Array of [Type]: 动态数组。数组指针的大小在 32 位系统中为 4 字节，在 64 位系统中为 8 字节，数组元素的总大小取决于元素类型和数量。
静态数组
- Array [Range] of [Type]: 静态数组，大小取决于元素类型和数量。
文件类型
- File, TextFile, BinaryFile: 文件操作类型。大小不固定，取决于文件内容和文件系统。
接口类型
- Interface: COM 接口。指针大小在 32 位系统中为 4 字节，在 64 位系统中为 8 字节。
类类型
- Class: 用户定义的类。类实例的大小取决于其字段和方法。
方法指针类型
- Procedure/Function of object: 方法指针。大小通常在 32 位系统中为 8 字节，在 64 位系统中为 16 字节。
变体数组
- Variant array: 动态变体类型的数组。大小取决于数组元素的数量和类型。
GUID 类型
- TGUID: 全局唯一标识符。大小固定为 16 字节。

总结：查看每种类型占用大小

program DataTypeSizes;

{$APPTYPE CONSOLE}

uses
  SysUtils;

type
  TMyEnum = (meOne, meTwo, meThree);
  TMySet = set of TMyEnum;
  TMyRecord = record
    IntValue: Integer;
    StrValue: String;
  end;
  TMyArray = array[1..10] of Integer;
  TMyDynArray = array of Integer;

var
  ShortIntVar: ShortInt;
  ByteVar: Byte;
  SmallIntVar: SmallInt;
  WordVar: Word;
  IntegerVar: Integer;
  CardinalVar: Cardinal;
  LongIntVar: LongInt;
  LongWordVar: LongWord;
  Int64Var: Int64;
  UInt64Var: UInt64;
  SingleVar: Single;
  DoubleVar: Double;
  ExtendedVar: Extended;
  CompVar: Comp;
  CurrencyVar: Currency;
  CharVar: Char;
  WideCharVar: WideChar;
  AnsiCharVar: AnsiChar;
  StringVar: String;
  AnsiStringVar: AnsiString;
  WideStringVar: WideString;
  ShortStringVar: ShortString;
  BooleanVar: Boolean;
  ByteBoolVar: ByteBool;
  WordBoolVar: WordBool;
  LongBoolVar: LongBool;
  VariantVar: Variant;
  OleVariantVar: OleVariant;
  PointerVar: Pointer;
  DateTimeVar: TDateTime;
  MyEnumVar: TMyEnum;
  MySetVar: TMySet;
  MyRecordVar: TMyRecord;
  MyArrayVar: TMyArray;
  MyDynArrayVar: TMyDynArray;
  FileVar: File;
  TextFileVar: TextFile;
  BinaryFileVar: File of Byte;
  InterfaceVar: IInterface;
  ClassVar: TObject;
  MethodPointerVar: TMethod;
  VariantArrayVar: array of Variant;
  GUIDVar: TGUID;

begin
  // 初始化动态数组
  SetLength(MyDynArrayVar, 10);
  SetLength(VariantArrayVar, 10);

  // 打印各类型的大小
  WriteLn('ShortInt: ', SizeOf(ShortIntVar), ' bytes');
  WriteLn('Byte: ', SizeOf(ByteVar), ' bytes');
  WriteLn('SmallInt: ', SizeOf(SmallIntVar), ' bytes');
  WriteLn('Word: ', SizeOf(WordVar), ' bytes');
  WriteLn('Integer: ', SizeOf(IntegerVar), ' bytes');
  WriteLn('Cardinal: ', SizeOf(CardinalVar), ' bytes');
  WriteLn('LongInt: ', SizeOf(LongIntVar), ' bytes');
  WriteLn('LongWord: ', SizeOf(LongWordVar), ' bytes');
  WriteLn('Int64: ', SizeOf(Int64Var), ' bytes');
  WriteLn('UInt64: ', SizeOf(UInt64Var), ' bytes');
  WriteLn('Single: ', SizeOf(SingleVar), ' bytes');
  WriteLn('Double: ', SizeOf(DoubleVar), ' bytes');
  WriteLn('Extended: ', SizeOf(ExtendedVar), ' bytes');
  WriteLn('Comp: ', SizeOf(CompVar), ' bytes');
  WriteLn('Currency: ', SizeOf(CurrencyVar), ' bytes');
  WriteLn('Char: ', SizeOf(CharVar), ' bytes');
  WriteLn('WideChar: ', SizeOf(WideCharVar), ' bytes');
  WriteLn('AnsiChar: ', SizeOf(AnsiCharVar), ' bytes');
  WriteLn('String: ', SizeOf(StringVar), ' bytes');
  WriteLn('AnsiString: ', SizeOf(AnsiStringVar), ' bytes');
  WriteLn('WideString: ', SizeOf(WideStringVar), ' bytes');
  WriteLn('ShortString: ', SizeOf(ShortStringVar), ' bytes');
  WriteLn('Boolean: ', SizeOf(BooleanVar), ' bytes');
  WriteLn('ByteBool: ', SizeOf(ByteBoolVar), ' bytes');
  WriteLn('WordBool: ', SizeOf(WordBoolVar), ' bytes');
  WriteLn('LongBool: ', SizeOf(LongBoolVar), ' bytes');
  WriteLn('Variant: ', SizeOf(VariantVar), ' bytes');
  WriteLn('OleVariant: ', SizeOf(OleVariantVar), ' bytes');
  WriteLn('Pointer: ', SizeOf(PointerVar), ' bytes');
  WriteLn('TDateTime: ', SizeOf(DateTimeVar), ' bytes');
  WriteLn('TMyEnum: ', SizeOf(MyEnumVar), ' bytes');
  WriteLn('TMySet: ', SizeOf(MySetVar), ' bytes');
  WriteLn('TMyRecord: ', SizeOf(MyRecordVar), ' bytes');
  WriteLn('TMyArray: ', SizeOf(MyArrayVar), ' bytes');
  WriteLn('TMyDynArray: ', SizeOf(MyDynArrayVar), ' bytes');
  WriteLn('File: ', SizeOf(FileVar), ' bytes');
  WriteLn('TextFile: ', SizeOf(TextFileVar), ' bytes');
  WriteLn('BinaryFile: ', SizeOf(BinaryFileVar), ' bytes');
  WriteLn('Interface: ', SizeOf(InterfaceVar), ' bytes');
  WriteLn('Class: ', SizeOf(ClassVar), ' bytes');
  WriteLn('MethodPointer: ', SizeOf(MethodPointerVar), ' bytes');
  WriteLn('VariantArray: ', SizeOf(VariantArrayVar), ' bytes');
  WriteLn('TGUID: ', SizeOf(GUIDVar), ' bytes');

  ReadLn;
end.