我的Delphi7里程碑(认识Delphi7的基本类型)

 

Delphi7_day01
       Delphi7用的是Windows开发语言,所以采用的是windows的工作机制。
其核心主要是三个:
1)窗口:操作系统连续地监视每一个窗口的活动或事件的信号
2)事件:可以是用户事件,也可以是系统事件
3)消息:每发生一次事件,将引发一条消息发送至操作系统。
对象是具有一定的属性,方法,事件的实体。可以把属性看作是对象的性质,把方法看作是对象的动作,把事件看作是对象的响应。
 
Delphi工程是由两部分组成的:
第一部分是pascal的代码他的保存是.pas
第二部分是工程部分他的保存方式是.dpr
 
一个代码单元的结构:
unit FirstUnit;                      {1单元头部分,指明了单元文件名为FirstUnit.pas}
interface                                   {2接口定义部分}
uses                                          {使用单元部分}
 Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
 Dialogs, StdCtrls;
type                                    {类型声明部分}
 TForm1 = class(TForm)
    Button1: TButton;
    Label1: TLabel;
    Edit1: TEdit;
    procedure Button1Click(Sender: TObject);
 private
    { Private declarations }
 public
    { Public declarations }
 end;
var                                     {变量声明部分}
 Form1: TForm1;
implementation                  {3实现部分}
{$R *.dfm}                         {编译器指令,用于查找资源}
initialization                       {4初始化部分}
finalization       {5结束部分}
end.
一般地,单元文件由单元头部分(unit),接口定义部分(interface),实现部分(implementation),初始化部分(initialization),结束部分(finalization)五部分组成.
1.   单元头部分(unit):指出了单元的文件名,单元名必须与文件名同名
2.   接口定义部分(interface):声明类型,常量,变量,函数和过程的地方.由uses,类型声明(type),变量声明(var)接口部分只能声明不要把实现放入.对于可见域的说明会在后面说到!
3.   ,实现部分(implementation):包含在接口部分声明的函数和过程代码.
4.   初始化部分(initialization):只在程序开始时运行一次,相当于C++的构造函数
5.   结束部分(finalization):这是在对象结束时运行的,相当于C++的析构函数,是一个和构造
   反向析构的过程.
 
程序调试:
       Delphi7提供了一个功能强大的集成调试器(Integrated Debugger)
 
异常处理:
       产生异常表示程序运行中发生错误,并创建异常对象(包含该错误的信息及发生的时间和位置)来响应错误.异常对象的基类是Exception,它是在单元SysUtils中定义的.
1.   结构化异常处理
基本结构是try..except..end;
       try
       测试代码语句;
       except
              on 异常1 do 异常1的响应语句
              on 异常 2 do 异常2的响应语句
              …….
       end;
可能包含错误的代码放在关键字try的后面,对异常的处理放在except的后面
2.
       try…finally
不管try是否有异常finally都会运行
 
 
Delphi_day02
常量、变量与数据类型
一、数据类型:
1.数值类型:用来存储各种数值形式的数据,分为两类:整型和实型
整数类型        字节数                                        实数类型                     字节数
Integer                         4                                               Single                                  4
Shortint                        1                                               Real                                    8
Smallint                        2                                               Double                                8
Longint                        4                                               Currency                             8
Int64                            8                                               Extended                             10
Byte                             1                                               Read48                                6
Word                           2                                               Comp                                  8
Longword                    4                                              
Cardinal                        4                                              
 
2.             字符和字符串类型
字符类型用来存储各种字符形式的数据,分为两大类:字符型和字符串型
字符型                   字节数                                          字符串类型                  最大长度
Char                                   1                                               String                                  4-2G
AnsiChar                      1                                               ShortString                          2-256
WideChar                     2                                               AnsiString                           4-2G
                                                                                    WideString                           4-2G
3.             逻辑类型
逻辑型又称为布尔型,是用来存储逻辑值的数据类型
逻辑类型               字节数
Boolean                        1                   0(false) 1(true)
ByteBool                       1                   0(false) !0(true)
WideString                    2                   0(false) !0(true)
LongBool               4                   0(false) !0(true)
 
4.             强制类型转换:
ObjectPascal是一种强类型的语言,既不同数据类型的数据之间不直接进行赋值操作,而且一种数据类型的数据也不能直接参与其他类型的运算
类型转换函数                                                 作用
IntToStr(Value:Integer)                              将整型和长整型数据分别转换为字符串
IntToStr(Value:Int64)                                 string
floatToStr(Value:Extended)                         将实型(Real)数据转换为字符串型string
StrToFloat(const S:string)                          将字符串型数据转换为实型Real
strToInt(const S:string)                             将字符串型数据分别转换为整型和长整型
StrToInt64(const S:string)
以上的转换都是从一个字节或长度比较大的类型作为参数来进行转换的这里是为了强制类型转换服务的。
注意:同一类型较长的类型转制为较短的类型时,系统会进行自动截取,可能会影响数据的精度,对于不同类型数据转换为强类型,如果必须强类型数据转换为弱类型数据就要用到截断函数Trunc(一个参数)Round(一个参数)
二、常量与变量:
1.在程序中有两种数据类型:一种在程序运行过程中的值保持不变,称为常量,一种是程序运行过程中的值可以改变,称为变量。
标识符:
       是由字母或下划线打头的其他字符可以是数字和字母
       不区分大小写。
常量包含:常数常量和符号常量
符号常量:
       Const
              <常量名1>: [<类型名>]=<常量值1>
              ………
              类型名可以不用写,注意在这里常量赋值和普通赋值时不一样用的是”=”号而不是”:=”
2.变量
变量的类型决定相应的内存空间的大小和格式,变量的取值即相应的内存空间所存储的数据值,变量必须先进行声明,然后才能使用。
Var
       <变量名1>:<类型名1>
       …………
注意:变量的定义必须在事件过程专门的常量、变量定义区,即第一个begin之前,同一行进行相同类型的声明时中间用逗号分隔,变量有一个确定的值以后才能参加各种运算,还要注意有效的泛围。
 
三、作用域范围:
标识符的作用域范围从小到大包括3个等级,过程级、单元级和程序级
过程的内部变量即begin之前的变量只作用于过程。
写在implementation的变量只作用于此单元
interface的变量可以作用于所有工项下的单元,前提把其他要引用的加入到uses子句中,再用<单元名>.<标识符>来引用。
重定义标识符,即在更大的作用域中用过的标识符在其内部如过程级中重新有一个同名标识符,这个标识符会把更大的作用域中的标识符暂时隐藏起来。
 
四、高级数据类型:
       1.枚举类型的定义和声明及应用函数:
              先对枚举类型进行定义:
              Type
                     <枚举类型名>=(<标识符1>,<标识符2>,<标识符3>,<标识符4>,……);
       说明: type是系统的保留字,表示定义高级数据类型的开始,<枚举类型名>是用户自己定义的枚举类型的名称,<标识符>列举出该类型中的所有数据元素,称为枚举常量,枚举常量用逗号隔开。不允许重复定义,出不允许同时出现在不同的枚举类型定义中。
              声明:
              var
                     <标识符名>:<枚举类型名>;
              函数应用:
                     枚举内的标识符都是有顺序的从0到始,所以在得到枚举的值有一套函数:
如下:
       枚举函数                     功能                            调用格式
       Ord                       求枚举序数                         ord(枚举常量或枚举变量)
       Pred                      求前驱值                            。。。
       Succ                            求后继值                            。。。
       Low                      求第一个枚举常量              Low(枚举类型名)
       Hight                     求未一个枚举常量              ….
 
2.子界类型的定义和声明及注意
子界类型是有确定的数据类型、且取值范围固定的数据集合。子界类型必须是某种顺序类型的子集,所以称其相应的顺序类型为基类型。
定义
       Type
       <子界类型名>=<常量1>…<常量2>;
       说明:<子界类型名>是用户定义的子界类型的名称,<常量1>表示子界类型的下界,即最小值,<常量2>表示子界类型的上界,即最大值,子界上界必须小于下界的,还必须是同一类型的。
例子:
Lowercase=’a’..’z’;
 
Month=(Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec);
Sping=Feb..May;
声明
       Var s1,s2:spring;
注意:
       在调试阶段子界所赋的值会进行检查,在运行阶段子界的值不一定会进行检查。
3.集合类型:
这里的集合就是一个数学上集合的定义他有几个特征如下:
1)互异性,集合中的元素是可以相互区分的,完全相同的元素视为同一个元素。
2)无序性,集合中的元素没有顺序,可以随机排列。
3)有限性,一般意义下的集合元素个数可以是元限的,但是在这里规定集合的元素个数不能超过256个
集合的定义
       Type
       <集合类型名>=set of<基类型>;
其中,<集合类型名>是用户集合类型的名称,<基类型>表示集合中各元素的数据类型。在这里教室:集合类型的<基类型>必须是顺序类型中的字符型、逻辑型、枚举型和子界型,而不能是整形和其他数据类型。同时元素不能超过256个。
       例如:
       Type
       Uppercase=’A’..’Z’;
       Uchars=set of uppercase;
Month=(Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec);
Vacation=set of Month;
集合变量的声明
Var
       SumVac,WinVac:vacation
也可以不经过定义就用子界
Var
       N1,n2:set of 1..100;
集合变量的取值:
集合变量不同于其他变量,它不是一个单独的元素,而是一系列元素的一个集合。集合变量的取值称为集合值,基一般表现形式如下:
[<元素1>,<元素2>,<元素3>,<元素4>。。。。];
集合类型的运算:
其实就是数学上的交、并、差运算
 
运算名称        表示方式                     运算结果                       是否满足交换律
并运算            S1+S2            两个集合中所有不重复元素集合             
交运算            S1*S2            两个集合所共有的元素集合                    
差运算            S1-S2            所有属于S1不属于S2的集合                
相等运算        S1=S2            元素全相等true                                      
不等运算        S1<>S2          元素全不相等true                                   
包含运算        S1>=S2          S2的元素全在S1中true                     
被包含运算     S1<=S2                                                                        
属于运算        X in S1          元素X在S1集合中true                        
 
4.数组类型:
数组(Array)是数目固定、类型相同的若干个元素的有序集合,提供的数据分为静态数组和动态数组。
a)         静态数组
静态数组在程序初始化时必须分配内存单元,明确其固定的大小和元素的数据类型
定义:
Type
<数组类型名>=array[<下标集合1>,<下标集合2>] of <基类型>
<下标集合1>表示数组第一维的大小,<下标集合2>表示数组第二维的大小。。。。。。
例如:
Type
       MyArr1=array[1..5] of real;                            //一维数组
       MyArr2=array[1..3,0..2] of integer;          //二维数组
声明:
Var
Arr1:MyArr1;
也可以
Arr2:array[1..3,0..2] of integer;
注意:因为一个数组变量对应多个数组元素,所以数组变量不能直接参加运算,也不能直接赋值,只有单个数组元素才可以参加运算,运算的类型取决于数组类型的基类型。
b)        动态数组:
动态数组在定义和声明时仅指定数组的类型,而不指定数组的大小。
定义:
Type
<数组类型名>=array of array of ..array of<基数型>
例如:
       Type
       MyArr4=array of integer;{一维动态数组}
       MyArr5=array of array of real;{二维动态数组}
       Arr4:MyArr4;
       Arr5:array of array of char;
在使用动态数组变量之前,要先调用标准过程SetLength来确定数组的大小,例如:
SetLength(arr4,3);                {指定arr4有3个元素}
SelLength(arr5,2,3);             {指定arr5的每一维大小为2,第二维大小为3}
此外允许创建一种特殊的多维动态数组,除第一维外,其他维的大小不固定
Var
Arr6:array of array of integer;
Begin
       SetLength(arr6,2);
       SetLength(arr6[0],2);
       SetLength(arr6[1],3);
End;
 
5.记录类型
记录在这里好比C++的结构体!
记录类型(Record)可以将数据类型不同的数据集中在一起,并作为一个整体进行操作。
记录类型的定义:
       Type:
       <记录类型名>=Record
              <域名表1>:<类型1>;
              <域名表2>:<类型2>;
              ….
       End;
其中,<记录类型名>是用户定义的记录类型的名称,<域名表>中可以是多个合法的发域名标识符,域名又称为字段名,<类型>可以是任意的数据类型。同一个记录类型中不能有同名的字段,而因为作用域不同,记录内的字段名与记录外的标识符可以相同。
例如:
       Type
       Student=Record
       Id:integer;
       Name:string[8];
       Sex:char;
       End;
声明:
       Var
       <记录变量名>:<记录类型名>
记录域的访问:
       <记录变量名>.<字段名>
使用With语句
       With <记录变量名>Do<语句>
<语句>可以是简单语句,也可以是复合语句。在语句中,对字段的访问不需要加记录变量名进行限定
With stu2 do
Begin
       Id:=2;
       Name:=’SB’
       Sex:=’F’;
End;
 
 
6.指针类型:
指针是一种特殊的数据类型,指针类型(Pointer)的变量称为指针变量。指针变量具有一般变量的三个基本要素,即变量名、变量类型、变量值,它与一般变量的不同之外在于:指针变量是用来存放其他变量的内存地址的一种变量。
指针变量的声明:
       Type
              <指针类型名>=^<基类型>
       基类型也可是高级数据类型如记录型
声明:
       Type
              PtrInt=^Integer
       Var
       P1,p2:PtrInt;
       也可以
       P4,p5:^Integer;
指针变量的赋值:
       与普通的变量一样,声明了指针变量之后,编译器将给指针变量分配内存单元,但内存单元中的值尚未确定,需要通过赋值操作来实现。格式如下:
       <指针变量名>:=@<标识符>
       @是一元操作符,用于获取操作数的内存地址,@后面的操作数可以是变量、过程、函数等.
       Var
              N:integer;
              P:^integer;
              P:=@N;//为指针变量赋值
              P^:=3;//“p^”来表示p所指向的内存单元
无类型指针变量:
       声明格式如下:
       <指针变量名>:Pointer;
       Type
              pInt=^integer;
       Var
              P1:pInt;
              M:integer;
              N:real;
              pAny:Pointer;
              begin
                     pAny:=@M;
                     pAny:=@N;
                     p1:=Pint(pAny);//将无类型指针PAny转换为整型指针类型p1
                     p1^:Random(n);//这时才可以用p^进行操作
              end;
       对于无类型指针p,不能使用”p^”的形式来引用它指向的变量。如果要引用无类型指针指向的变量,必须将其转换成确定的类型。
             
指针变量的动态使用:
a)      指针变量的动态使用:
i)                    New 过程和Dispose过程
如果不使用@运算符为指针变量赋值,则指针变量称为动态指针变量,动态变量在访问之前必须首先分配内存单元。在此提供了标准过程New,用来为动态变量分配内存单元,并把该单元的地址赋给指针变量,所分配单元的大小由指针所指的类型决定,调用New过程的格式如下:
New(<指针变量名>);
当程序不再需要使用动态变量时,就调用标准过程Dispose删除New创建的动态变量,并释放所分配的内存单元。调用Dispose过程如下:
Dispose(<指针变量名>);
例如:
       Var
       P:^integer;
       Begin
              New(p);
              P^=10;
              Dispose(p);
End;
ii)                  GetMem过程和FreeMem过程
标准过程GetMem用于为动态变量分配一块指定大小的内存区域,并把该区域的初始地址赋给指针变量。
GetMem(<指针变量名>,<区域大小>);
如果程序不再需要使用动态变量时,就调用标准过程FreeMem删除GetMem创建的动态变量,并释放所分配的内存单元。调用FreeMem过程的格式如下:
       FreeMem(<指针变量名>);
New与GetMem的区别在于New是把自己的地址赋给自己,而GetMem是分配一块指定大小的内存区域,把这个区域的初始地址给他,这个地址就很有可能不是自己了!
 
字符指针类型:
       为了与Windows和C的字符串兼容,Object Pascal 提供了一种Pchar字符指针类型。pChar指针是一个指向以NULL字符结尾的字符串指针。
Var
       P:pChar;
Begin
       p:=’Delphi7’;
End;
 
 
在这里我把Delphi7的入门内容草草总结了,方便以后自己重新总结也方便大家的学习,这是我学Delphi的第二天!
发布了47 篇原创文章 · 获赞 5 · 访问量 10万+
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 大白 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览