从 codegear 抄来的 Delphi2006、Delphi2007 语言新特性(0分)

URL: http://dn.codegear.com/article/34324

1）Inlining：
Routines can now be marked with the inline directive. This tells the compiler that, instead of actually calling the routine, it should emit code that includes the routine at the call site.

2）Operator Overloading：
Delphi allows certain functions, or operators, to be overloaded within record declarations

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

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

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

3）Class Helpers
A class helper is a type that - when associated with another class - introduces additional method names and properties which may be used in the context of the associated class (or its descendants). Class helpers are a way to extend a class without using inheritance. A class helper simply introduces a wider scope for the compiler to use when resolving identifiers. When you declare a class helper, you state the helper name, and the name of the class you are going to extend with the helper. You can use the class helper any place where you can legally use the extended class. The compiler's resolution scope then becomes the original class, plus the class helper. Class helpers provide a way to extend a class, but they should not be viewed as a design tool to be used when developing new code. They should be used solely for their intended purpose, which is language and platform RTL binding.

type
TMyClass = class

procedure MyProc;
function MyFunc: Integer;
end;

...

procedure TMyClass.MyProc;
var
X: Integer;
begin
X := MyFunc;
end;

function TMyClass.MyFunc: Integer;
begin
...
end;

...

type
TMyClassHelper = class helper for TMyClass
procedure HelloWorld;
function MyFunc: Integer;
end;

...

procedure TMyClassHelper.HelloWorld;
begin
WriteLn(Self.ClassName)
// Self refers to TMyClass type, not TMyClassHelper

end;

function TMyClassHelper.MyFunc: Integer;
begin
...
end;
...

var
X: TMyClass;
begin
X := TMyClass.Create;
X.MyProc
// Calls TMyClass.MyProc
X.HelloWorld
// Calls TMyClassHelper.HelloWorld
X.MyFunc
// Calls TMyClassHelper.MyFunc

end;

4）strict private
The private keyword actually creates a " friendship" relationship between classes in the same unit. The strict private declaration creates a true private field, not viewable by any other class, not even classes in the same unit.

5）strict protected
Similar to the strict private declaration, strict protectedcreates a true protected member, visible only to the declaring class and its descendents.

6）Records with Methods
In addition to fields, records now may have properties and methods (including constructors), class properties, class methods, class fields, and nested types.

type
TMyRecord = record
type
TInnerColorType = Integer;
var
Red: Integer;
class var
Blue: Integer;
procedure printRed();
constructor Create(val: Integer);
property RedProperty: TInnerColorType read Red write Red;
class property BlueProp: TInnerColorType read Blue write Blue;
end;

constructor TMyRecord.Create(val: Integer);
begin
Red := val;
end;

procedure TMyRecord.printRed;
begin
writeln('Red: ', Red);
end;

7）class abstract
Classes, and not just methods, can be declared as abstract.

type
TAbstractClass = class abstract
procedure SomeProcedure;
end;

8）class sealed
Classes marked as sealed cannot be inherited from.

type
TAbstractClass = class sealed
procedure SomeProcedure;
end;

9）class const
Classes can now have class constants -- a constant value associated with the class itself and not an instance of the class.

type
TClassWithConstant = class
public
const SomeConst = 'This is a class constant';
end;


procedure TForm1.FormCreate(Sender: TObject);
begin
ShowMessage(TClassWithConstant.SomeConst);
end;

10）class type
A class can now contain a type declaration that is usable only within that class.

type
TClassWithClassType = class
private
type
TRecordWithinAClass = record
SomeField: string;
end;
public

class var
RecordWithinAClass: TRecordWithinAClass;
end;
...
procedure TForm1.FormCreate(Sender: TObject);
begin
TClassWithClassType.RecordWithinAClass.SomeField := 'This is a field of a class type declaration';
ShowMessage(TClassWithClassType.RecordWithinAClass.SomeField);
end;

11）class var
A class can also have a class variable, applicable only to the class and not an instance of the class. See "class type" for an example.

12）class property
A class can have a class property, which is a property that applies only to the class reference and not to an instance of a class. The accessors for the class property must be either class methods or class variables. See the example in "static class methods" below.

13）nested classes
Type declarations can be nested within class declarations. They present a way to keep conceptually related types together, and to avoid name collisions.

type
TOuterClass = class
strict private
MyField: Integer;
public
type
TInnerClass = class
public
MyInnerField: Integer;
procedure InnerProc;
end;
procedure OuterProc;
end;

procedure TOuterClass.TInnerClass.InnerProc;
begin
...
end;

14）final methods
A virtual method that you override can now be marked final, preventing derived classes from overriding that method.

TAbstractClass = classabstract
public
procedure Bar
virtual;
end;

TSealedClass = classsealed(TAbstractClass)
public
procedure Bar
override;
end;

TFinalMethodClass = class(TAbstractClass)
public
procedure Bar
override
final;
end;

15）sealed methods
Classes marked as sealed cannot be descended from. See the example in 'final methods'.

16）static class methods
Classes can have static class methods -- i.e. methods that can be called from a class type. Class static methods can be accessed without an object reference. Unlike ordinary class methods, class static methods have no Self parameter at all. They also cannot access any instance members. (They still have access to class fields, class properties, and class methods.) Also unlike class methods, class static methods cannot be declared virtual.

type
TMyClass = class
strict private
class var
FX: Integer;
strict protected

// Note: accessors for class properties must be declared class static.

class function GetX: Integer
static;
class procedure SetX(val: Integer)
static;
public
class property X: Integer read GetX write SetX;
class procedure StatProc(s: String)
static;
end;

TMyClass.X := 17;
TMyClass.StatProc('Hello');

17）for-in loop
Delphi 2007 for Win32 supports for-element-in-collection style iteration over containers. The following container iteration patterns are recognized by the compiler:

for Element in ArrayExpr do Stmt;
for Element in StringExpr do Stmt;
for Element in SetExpr do Stmt;
for Element in CollectionExpr do Stmt;

=== 结束 ===

>>Operator Overloading

我记得这个只能在.NET项目中用，Win32好像还是不支持。

操作符重载，在上面例子中写的是：
TMyClass = class
class operator Add(a, b: TMyClass): TMyClass
// Addition of two operands of type TMyClass
class operator Subtract(a, b: TMyClass): TMyclass
// Subtraction of type TMyClass
class operator Implicit(a: Integer): TMyClass
// Implicit conversion of an Integer to type TMyClass
class operator Implicit(a: TMyClass): Integer
// Implicit conversion of TMyClass to Integer
class operator Explicit(a: Double): TMyClass
// Explicit conversion of a Double to TMyClass
end;

看到第六点“Records with Methods”后，把它改成这样呢？
TMyClass = record
class operator Add(a, b: TMyClass): TMyClass
// Addition of two operands of type TMyClass
class operator Subtract(a, b: TMyClass): TMyclass
// Subtraction of type TMyClass
class operator Implicit(a: Integer): TMyClass
// Implicit conversion of an Integer to type TMyClass
class operator Implicit(a: TMyClass): Integer
// Implicit conversion of TMyClass to Integer
class operator Explicit(a: Double): TMyClass
// Explicit conversion of a Double to TMyClass
end;

Win32 就支持了。具体实例大概可以这样看：

声明：
type
TMyRect = record
Left, Top, Right, Bottom:integer;
class operator Add(a, b: TMyRect): TMyRect;
class operator Subtract(a, b: TMyRect): TMyRect;
class operator Implicit(a: Integer): TMyRect;
class operator Explicit(a: TMyRect): Integer;
end;

实现：
class operator TMyRect.Add(a, b: TMyRect): TMyRect;
begin
Result.Left := a.Left + b.Left;
Result.Top := a.Top + b.Top;
Result.Right := a.Right + b.Right;
Result.Bottom := a.Bottom + b.Bottom;
end;

class operator TMyRect.Explicit(a: TMyRect): Integer;
begin
Result:=a.Left + a.Top + a.Right + a.Bottom;
end;

class operator TMyRect.Implicit(a: Integer): TMyRect;
begin
Result.Left := a;
Result.Top := a;
Result.Right := a;
Result.Bottom := a;
end;

class operator TMyRect.Subtract(a, b: TMyRect): TMyRect;
begin
Result.Left := a.Left - b.Left;
Result.Top := a.Top - b.Top;
Result.Right := a.Right - b.Right;
Result.Bottom := a.Bottom - b.Bottom;
end;

调用：
procedure TForm1.FormClick(Sender: TObject);
var
R1,R2:TMyRect;
begin
R2:= R1 + R2;
end;

好东西呀。

2007下我没试过，我记得2006的时候我试了的，操作符重载在Win32项目中只支持record，而不能在class下应用。回头我试试2007的class可否用操作符重载了。

刚刚试了，呵呵，class只有.NET支持操作符重载。帮助原文：
Delphi for .NET and Delphi for Win32 allow certain functions, or "operators" to be overloaded within record declarations. Delphi for .NET also allows overloading within class declarations.

[]