Delphi中record 的运算符重载

-----------------------------------

Delphi中目前好像只能在Record中定义运算法重载的方法，C++的运算符重载定义在类中，有区别，以后有啥研究再记录下来，方便学习交流

 

---------------------------------------

 

资料来源：delphi 中record 的类操作符重载简介 - findumars - 博客园  https://www.cnblogs.com/findumars/p/10201381.html

Operator Overloading (Delphi) - RAD Studio  http://docwiki.embarcadero.com/RADStudio/Tokyo/en/Operator_Overloading_(Delphi)

 

 

TXalionRec=record
ival:integer;
dval:Tdatetime;
constructor create(s:string);
{destructor Destroy;}

//class operator Assign(var Dest:TXalionRec;const Src:TXalionRec); // 赋值

class operator NotEqual(ALeft,ARight:TXalionRec):boolean; // 不等于
class operator Equal(ALeft,ARight:TXalionRec):boolean; //等于
class operator GreaterThan(ALeft,ARight:TXalionRec):boolean; // 大于
class operator GreaterThanOrEqual(ALeft,ARight:TXalionRec):boolean; //大于等于
class operator LessThan(ALeft,ARight:TXalionRec):boolean; // 小于
class operator LessThanOrEqual(ALeft,ARight:TXalionRec):boolean; //小于等于
class operator Inc(AValue:TXalionRec):TXalionRec; // 递增
class operator Dec(AValue:TXalionRec):TXalionRec; // 递减

class operator Add(AValue1:TXalionRec; AValue2:integer):TXalionRec; // 加整数
class operator Add(AValue1:TXalionRec; AValue2:TDateTime):TXalionRec; //加时间
class operator Add(AValue1:TXalionRec; AValue2:TXalionRec):TXalionRec; // 直接加

class operator Implicit(AValue:TDateTime):TXalionRec; //显式等于日期
class operator Implicit(AValue:integer):TXalionRec; //显式等于整数

class operator Implicit(AValue:TXalionRec):TDateTime; //显式赋值日期
class operator Implicit(AValue:TXalionRec):integer; //显式赋值整数
end;

 

{class operator TXalionRec.Assign(var Dest:TXalionRec;const Src:TXalionRec);
begin
dest.ival:=src.ival;
dest.dval:=src.dval;
end; }

class operator TXalionRec.Add(AValue1: TXalionRec;
AValue2: TDateTime): TXalionRec;
begin
result:= AValue1;
result.dval:=result.dval+avalue2;
end;

class operator TXalionRec.Add(AValue1: TXalionRec;
AValue2: integer): TXalionRec;
begin
result:= AValue1;
result.ival:=result.ival+avalue2;
end;

class operator TXalionRec.Add(AValue1:TXalionRec; AValue2:TXalionRec):TXalionRec;
begin
result.ival :=avalue1.ival+avalue2.ival;
result.dval:= avalue1.dval+avalue2.dval;
end;

constructor TXalionRec.create(s:string);
begin
ival:=0;
dval:=now;
end;

class operator TXalionRec.Dec(AValue: TXalionRec): TXalionRec;
begin
result:=Avalue;
dec(result.ival);
end;

{destructor TXalionRec.Destroy;
begin
exit;
end; }

class operator TXalionRec.Equal(ALeft, ARight: TXalionRec): boolean;
begin
result:=False;
if Aleft.ival=Aright.ival then
begin
result:=True;
end;

end;

class operator TXalionRec.GreaterThan(ALeft, ARight: TXalionRec): boolean;
begin
result:=False;
if Aleft.ival>Aright.ival then
result:=True;
end;

class operator TXalionRec.GreaterThanOrEqual(ALeft,
ARight: TXalionRec): boolean;
begin
result:=False;
if Aleft.ival>=Aright.ival then
result:=True;
end;

class operator TXalionRec.Implicit(AValue: integer): TXalionRec;
begin
result.ival:=Avalue;
end;

class operator TXalionRec.Implicit(AValue: TDateTime): TXalionRec;
begin
result.dval:=Avalue;
end;

class operator TXalionRec.Implicit(AValue: TXalionRec): integer;
begin
result:=Avalue.ival;
end;

class operator TXalionRec.Implicit(AValue: TXalionRec): TDateTime;
begin
result:=Avalue.dval;
end;

class operator TXalionRec.Inc(AValue: TXalionRec): TXalionRec;
begin
result:=Avalue;
inc( result.ival);
end;

class operator TXalionRec.LessThan(ALeft, ARight: TXalionRec): boolean;
begin
result:=False;
if Aleft.ival<Aright.ival then
result:=True;
end;

class operator TXalionRec.LessThanOrEqual(ALeft, ARight: TXalionRec): boolean;
begin
result:=False;
if Aleft.ival<=Aright.ival then
result:=True;
end;

class operator TXalionRec.NotEqual(ALeft, ARight: TXalionRec): boolean;
begin
result:=False;
if Aleft.ival<>Aright.ival then
result:=True;
end;

 

procedure TForm1.Button3Click(Sender: TObject);
var
myrec,rec2:TXalionRec;
d:Tdatetime;
begin
myrec:=3; //等于整数
memo1.Lines.Add('myrec ival='+ IntToStr(myrec.ival));
memo1.Lines.Add('myrec dval='+ formatdatetime('yyyy-mm-dd',myrec.dval));
memo1.Lines.Add('>>>>>>>>>>>>>>>>>>end<<<<<<<<<<<<<<<<');

inc(myrec); //递增
memo1.Lines.Add('myrec ival='+ IntToStr(myrec.ival)); //myrec.ival.ToString
memo1.Lines.Add('myrec dval='+ formatdatetime('yyyy-mm-dd',myrec.dval));
memo1.Lines.Add('>>>>>>>>>>>>>>>>>>end<<<<<<<<<<<<<<<<');

d:=2;
myrec:=myrec+ d; //加时间 2天
memo1.Lines.Add('myrec ival='+ IntToStr(myrec.ival));
memo1.Lines.Add('myrec dval='+ formatdatetime('yyyy-mm-dd',myrec.dval));
memo1.Lines.Add('>>>>>>>>>>>>>>>>>>end<<<<<<<<<<<<<<<<');

myrec:=myrec+5; //加整数

memo1.Lines.Add('myrec ival='+ IntToStr(myrec.ival));
memo1.Lines.Add('myrec dval='+ formatdatetime('yyyy-mm-dd',myrec.dval));
memo1.Lines.Add('>>>>>>>>>>>>>>>>>>end<<<<<<<<<<<<<<<<');

rec2:=6;

myrec:=myrec+rec2;

memo1.Lines.Add('myrec ival='+ IntToStr(myrec.ival));
memo1.Lines.Add('myrec dval='+ formatdatetime('yyyy-mm-dd',myrec.dval));
memo1.Lines.Add('>>>>>>>>>>>>>>>>>>end<<<<<<<<<<<<<<<<');

end;

 

-------------------------------------------资料还是保存下----------------开始--------------

About Operator Overloading

Delphi allows certain functions, or "operators", to be overloaded within record declarations. The name of the operator function maps to a symbolic representation in source code. For example, the Add operator maps to the + symbol.

The compiler generates a call to the appropriate overload, matching the context (that is, the return type, and type of parameters used in the call), to the signature of the operator function.

The following table shows the Delphi operators that can be overloaded:

Operator	Category	Declaration Signature	Symbol Mapping
Implicit	Conversion	Implicit(a : type) : resultType;	implicit typecast
Explicit	Conversion	Explicit(a: type) : resultType;	explicit typecast
Negative	Unary	Negative(a: type) : resultType;	-
Positive	Unary	Positive(a: type): resultType;	+
Inc	Unary	Inc(a: type) : resultType;	Inc
Dec	Unary	Dec(a: type): resultType	Dec
LogicalNot	Unary	LogicalNot(a: type): resultType;	not
Trunc	Unary	Trunc(a: type): resultType;	Trunc
Round	Unary	Round(a: type): resultType;	Round
In	Set	In(a: type; b: type) : Boolean;	in
Equal	Comparison	Equal(a: type; b: type) : Boolean;	=
NotEqual	Comparison	NotEqual(a: type; b: type): Boolean;	<>
GreaterThan	Comparison	GreaterThan(a: type; b: type) Boolean;	>
GreaterThanOrEqual	Comparison	GreaterThanOrEqual(a: type; b: type): Boolean;	>=
LessThan	Comparison	LessThan(a: type; b: type): Boolean;	<
LessThanOrEqual	Comparison	LessThanOrEqual(a: type; b: type): Boolean;	<=
Add	Binary	Add(a: type; b: type): resultType;	+
Subtract	Binary	Subtract(a: type; b: type) : resultType;	-
Multiply	Binary	Multiply(a: type; b: type) : resultType;	*
Divide	Binary	Divide(a: type; b: type) : resultType;	/
IntDivide	Binary	IntDivide(a: type; b: type): resultType;	div
Modulus	Binary	Modulus(a: type; b: type): resultType;	mod
LeftShift	Binary	LeftShift(a: type; b: type): resultType;	shl
RightShift	Binary	RightShift(a: type; b: type): resultType;	shr
LogicalAnd	Binary	LogicalAnd(a: type; b: type): resultType;	and
LogicalOr	Binary	LogicalOr(a: type; b: type): resultType;	or
LogicalXor	Binary	LogicalXor(a: type; b: type): resultType;	xor
BitwiseAnd	Binary	BitwiseAnd(a: type; b: type): resultType;	and
BitwiseOr	Binary	BitwiseOr(a: type; b: type): resultType;	or
BitwiseXor	Binary	BitwiseXor(a: type; b: type): resultType;	xor

No operators other than those listed in the table may be defined on a class or record.

Overloaded operator methods cannot be referred to by name in source code. To access a specific operator method of a specific class or record, refer to: Code Example:OpOverloads_(Delphi). Operator identifiers are included for classes and records in the language in the class or record's list of methods starting with the word "operator" (example: System.AnsiStringBase Methods). You can implement any of the above operators in your own classes and records.

The compiler will use an operator for a class or record provided that:

• For binary operators, one of the input parameters must be the class type.
• For unary operators, either the input parameter or the return value must be the class type.
• For a logical operator and a bitwise operator using the same symbol, the logical operator is used only when the operands are booleans. Since the type of the class of this class operator is not a boolean, a logical operator will only be used when the other operand is a boolean.

No assumptions are made regarding the distributive or commutative properties of the operation. For binary operators, the first parameter is always the left operand, and the second parameter is always the right operand. Associativity is assumed to be left-to-right in the absence of explicit parentheses.

Resolution of operator methods is done over the union of accessible operators of the types used in the operation (note this includes inherited operators). For an operation involving two different types A and B, if type A has an implicit conversion to B, and B has an implicit conversion to A, an ambiguity will occur. Implicit conversions should be provided only where absolutely necessary, and reflexivity should be avoided. It is best to let type B implicitly convert itself to type A, and let type A have no knowledge of type B (or vice versa).

As a general rule, operators should not modify their operands. Instead, return a new value, constructed by performing the operation on the parameters.

Overloaded operators are used most often in records (that is, value types).

Note: Class and record helpers do not support operator overloading.

Declaring Operator Overloads

Operator overloads are declared within classes or records, with the following syntax:

type
   typeName = record
       class operator conversionOp(a: type): resultType;
       class operator unaryOp(a: type): resultType;
       class operator comparisonOp(a: type; b: type): Boolean;
       class operator binaryOp(a: type; b: type): resultType;
   end;

Implementation of overloaded operators must also include the class operator syntax:

class operator typeName.conversionOp(a: type): resultType;
class operator typeName.unaryOp(a: type): resultType;
class operator typeName.comparisonOp(a: type; b: type): Boolean;
class operator typeName.binaryOp(a: type; b: type): resultType;

The following are some examples of overloaded operators:

type
   TMyRecord = record
     class operator Add(a, b: TMyRecord): TMyRecord;      // Addition of two operands of type TMyRecord
     class operator Subtract(a, b: TMyRecord): TMyRecord; // Subtraction of type TMyRecord
     class operator Implicit(a: Integer): TMyRecord;      // Implicit conversion of an Integer to type TMyRecord
     class operator Implicit(a: TMyRecord): Integer;      // Implicit conversion of TMyRecordto Integer
     class operator Explicit(a: Double): TMyRecord;       // Explicit conversion of a Double to TMyRecord
   end;

// Example implementation of Add
class operator TMyRecord.Add(a, b: TMyRecord): TMyRecord;
begin
   // ...
end;

var
x, y: TMyRecord;
begin
   x := 12;      // Implicit conversion from an Integer
   y := x + x;   // Calls TMyRecord.Add(a, b: TMyRecord): TMyRecord
   b := b + 100; // Calls TMyRecord.Add(b, TMyRecord.Implicit(100))
end;

-------------------------------------------资料还是保存下------------------结束-----------