Объектное ориентирование

Override/Vitual/Dynamic - методы

2013-08-19T15:51:52+07:00

Если метод в классе предка объявлен как виртуальный (virtual) или динамический (dynamic), вам необходимо перекрыть его во всех классах-наследниках. Если вы объявляете унаследованный метод виртуальным или динамическим, вы начинаете строить его новое виртуальное/динамическое дерево наследования. Допустим, у нас есть следующая иерархия: A (родитель) - B - C - D. Если вы объявляете метод как виртуальный (или динамический) в A, перекрываете в B, создаете виртуальным в C и перекрываете в D, вот что получается:

фактический класс, используемый класс, использующий

класс для доступа к методу метод

-----------+---------------------+--------------------

D D D

D C D

D B B

D A B

C C C

C B B

C A B

B B B

B A B

Вывод: работа виртуального/динамического наследования прекращается в момент создания одноименного виртуального/динамического метода наследниками класса.

Mark

Взято из Советов по Delphi отВалентина Озерова

Сборник Kuliba

Динамические и виртуальные методы

2013-08-19T15:50:56+07:00

Согласно онлайновой документации, динамические и виртуальные методы семантически идентичны, единственно различие заключается в их реализации, нижеследующий код генерирует указанную ошибку компиляции:

Code:

type t = class

function a: integer; {статический}

function b: integer; virtual;

function c: integer; dynamic;

property i: integer read a; { ok }

property j: integer read b; { ok }

property k: integer read c;{ ОШИБКА: type mismatch (не совпадение типа) }

end;

Взято из Советов по Delphi от Валентина Озерова

Сборник Kuliba

Как вызвать метод предка?

2013-08-19T15:45:46+07:00

1) Есть Class1, с методом Mtd.

2) Есть Class2 унаследованный от Class1, метод Mtd перезаписан

3) В программе используется переменная типа Class2

Можно ли из программы вызвать Mtd от Class1, Другими словами, можно ли вызвать перезаписанный метод класса-предка?

Способ 1(только для не виртуальных методов)

Code:

{©Drkb v.3(2007): www.drkb.ru}

var

a:class2;

begin

a:=class2.Create;

class1(a).mtd;

....

end;

Автор:Fantasist

Взято с Vingrad.ruhttps://forum.vingrad

Способ со статическим приведением годится только для

не виртуальных методов, имеющих одно имя.

Вызов же виртуальных методов от статического типа не зависит.

В твоём простейшем случае достаточно написать inherited Mtd;

(ты его можешь вызвать из любого метода TClass2, не только из Mtd).

Трудности возникнут, когда нужно вызвать метод "дедушки" или "прадедушки" и т.д.

Один из способов, описанных в литературе, - временная замена

VMT объекта на "дедушку" и обратно. Но если у дедушки такого метода не было - будет облом.

Я предпочитаю такой способ:

Code:

type

{©Drkb v.3(2007): www.drkb.ru}

TProc = procedureofobject;

procedure TClassN.SomeMethod;

var

Proc: TProc;

begin

TMethod(Proc).Code := @TClass1.Mtd; // Статический адрес

TMethod(Proc).Data := Self;

Proc();

end;

Автор ответа:Le Taon

Взято с Vingrad.ruhttps://forum.vingrad

Как преобразовать указатель на метод в указатель на функцию?

2013-08-19T14:07:36+07:00

Code:

// Converting method pointers into function pointers

// Often you need a function pointer for a callback function. But what, if you want to specify a method as

// an callback? Converting a method pointer to a function pointer is not a trivial task; both types are

// incompatible with each other. Although you have the possibility to convert like this "@TClass.SomeMethod",

// this is more a hack than a solution, because it restricts the use of this method to some kind of a class

// function, where you cannot access instance variables. If you fail to do so, you'll get a wonderful gpf.

// But there is a better solution: run time code generation! Just allocate an executable memory block, and

// write 4 machine code instructions into it: 2 instructions loads the two pointers of the method pointer

// (code & data) into the registers, one calls the method via the code pointer, and the last is just a return

// Now you can use this pointer to the allocated memory as a plain function pointer, but in fact you are

// calling a method for a specific instance of a Class.

type TMyMethod = procedureofobject;

function MakeProcInstance(M: TMethod): Pointer;

begin

// allocate memory

GetMem(Result, 15);

asm

// MOV ECX,

MOV BYTE PTR [EAX], $B9

MOV ECX, M.Data

MOV DWORD PTR [EAX+$1], ECX

// POP EDX

MOV BYTE PTR [EAX+$5], $5A

// PUSH ECX

MOV BYTE PTR [EAX+$6], $51

// PUSH EDX

MOV BYTE PTR [EAX+$7], $52

// MOV ECX,

MOV BYTE PTR [EAX+$8], $B9

MOV ECX, M.Code

MOV DWORD PTR [EAX+$9], ECX

// JMP ECX

MOV BYTE PTR [EAX+$D], $FF

MOV BYTE PTR [EAX+$E], $E1

end;

procedure FreeProcInstance(ProcInstance: Pointer);

begin

// free memory

FreeMem(ProcInstance, 15);

end;

Взято с сайтаhttps://www.swissdelphicenter.ch/en/tipsindex

Как редактировать таблицы виртуальных и динамических методов?

2013-08-19T15:47:47+07:00

Code:

unit EditorVMTandDMTTables;

interface

// функция служит для выяснения существования VMT у класса

// возвращает True, если класс имеет VMT и False - если нет

function IsVMTExist(Cls: TClass): Boolean;

// процедура служит для замены адреса метода в VMT класса со смещением

// Offset(должно быть кратно 4) новым адресом, хранящимся в NewMet

// примечание: перед вызовом этой процедуры проверяйте существование

// VMT у класса функцией IsVMTExist

procedure VirtMethodReplace(Cls: TClass; Offset: LongWord; NewMet: Pointer); overload;

// процедура служит для замены адреса метода, хранящегося в OldMet,

// в VMT класса новым адресом, хранящимся в NewMet

// примечание: перед вызовом этой процедуры проверяйте существование

// VMT у класса функцией IsVMTExist

procedure VirtMethodReplace(Cls: TClass; OldMet, NewMet: Pointer); overload;

// функция служит для замены адреса динамического метода класса с индексом,

// хранящимся в Index, новым адресом, хранящимся в NewMet

// возвращает True, если метод с данным индексом найден и False - если нет

function DynMethodReplace(Cls: TClass; Index: Word; NewMet: Pointer): Boolean; overload;

// функция служит для замены адреса динамического метода класса, хранящегося

// в OldMet, новым адресом, хранящимся в NewMet

// возвращает True, если метод с данным адресом найден и False - если нет

function DynMethodReplace(Cls: TClass; OldMet, NewMet: Pointer): Boolean; overload;

implementation

// функция служит для получения указателя на байт, следующий за адресом

// последнего метода в VMT класса

// возвращает nil в случае, если у класса нет VMT

// функция является "внутренней" в модуле

// (используется другими подпрограммами и не объявлена в секции interface)

// , поэтому используйте её только если

// Вы полностью уверены в своих действиях(она изменяет "рабочие" регистры

// ECX и EDX)

function GetVMTEnd(Cls: TClass): Pointer;

asm

// Вход: Cls --> EAX

// Выход: Result --> EAX

PUSH EBX

MOV ECX, 8

MOV EBX, -1

MOV EDX, vmtSelfPtr

@@cycle:

ADD EDX, 4

CMP [EAX + EDX], EAX

JE @@vmt_not_found

JB @@continue

CMP [EAX + EDX], EBX

JAE @@continue

MOV EBX, [EAX + EDX]

@@continue:

DEC ECX

JNZ @@cycle

MOV EAX, EBX

JMP @@exit

@@vmt_not_found:

XOR EAX, EAX

@@exit:

POP EBX

end;

function IsVMTExist(Cls: TClass): Boolean;

asm

// Вход: Cls --> EAX

// Выход: Result --> AL

CALL GetVMTEnd

TEST EAX, EAX

JZ @@vmt_not_found

MOV AL, 1

@@vmt_not_found:

end;

procedure VirtMethodReplace(Cls: TClass; Offset: LongWord; NewMet: Pointer); overload;

asm

// Вход: Cls --> EAX, Offset --> EDX, NewMet --> ECX

MOV [EAX + EDX], ECX

end;

procedure VirtMethodReplace(Cls: TClass; OldMet, NewMet: Pointer); overload;

asm

// Вход: Cls --> EAX, OldMet --> EDX, NewMet --> ECX

PUSH EDI

MOV EDI, EAX

PUSH ECX

PUSH EDX

PUSH EAX

CALL GetVMTEnd

POP EDX

SUB EAX, EDX

SHR EAX, 2

POP EDX

POP ECX

PUSH ECX

MOV ECX, EAX

MOV EAX, EDX

POP EDX

REPNE SCASD

JNE @@OldMet_not_found

MOV [EDI - 4], EDX

@@OldMet_not_found:

POP EDI

end;

function DynMethodReplace(Cls: TClass; Index: Word; NewMet: Pointer): Boolean; overload;

asm

// Вход: Cls --> EAX, Index --> DX, NewMet --> ECX

// Выход: Result --> AL

PUSH EDI

PUSH ESI

MOV ESI, ECX

XOR EAX, EDX

XOR EDX, EAX

XOR EAX, EDX

JMP @@start

@@cycle:

MOV EDX, [EDX]

@@start:

MOV EDI, [EDX].vmtDynamicTable

TEST EDI, EDI

JZ @@get_parent_dmt

MOVZX ECX, WORD PTR [EDI]

PUSH ECX

ADD EDI, 2

REPNE SCASW

JE @@Index_found

POP ECX

@@get_parent_dmt:

MOV EDX, [EDX].vmtParent

TEST EDX, EDX

JNZ @@cycle

JMP @@Index_not_found

@@Index_found:

POP EAX

SHL EAX, 1

SUB EAX, ECX

MOV [EDI + EAX * 2 - 4], ESI

MOV AL, 1

JMP @@exit

@@Index_not_found:

XOR AL, AL

@@exit:

POP ESI

POP EDI

end;

function DynMethodReplace(Cls: TClass; OldMet, NewMet: Pointer): Boolean; overload;

asm

// Вход: Cls --> EAX, OldMet --> EDX, NewMet --> ECX

// Выход: Result --> AL

PUSH EDI

PUSH ESI

MOV ESI, ECX

XOR EAX, EDX

XOR EDX, EAX

XOR EAX, EDX

JMP @@start

@@cycle:

MOV EDX, [EDX]

@@start:

MOV EDI, [EDX].vmtDynamicTable

TEST EDI, EDI

JZ @@get_parent_dmt

MOVZX ECX, WORD PTR [EDI]

LEA EDI, EDI + 2 * ECX + 2

REPNE SCASD

JE @@OldMet_found

@@get_parent_dmt:

MOV EDX, [EDX].vmtParent

TEST EDX, EDX

JNZ @@cycle

JMP @@OldMet_not_found

@@OldMet_found:

MOV [EDI - 4], ESI

MOV AL, 1

JMP @@exit

@@OldMet_not_found:

XOR AL, AL

@@exit:

POP ESI

POP EDI

end;

end.

Автор ___ALex___ Форум:https://forum.pascal.dax

Как явно вызвать виртуальный метод дедушки?

2013-08-19T15:39:50+07:00

Проблема в следующем. Допустим, есть иерархия классов, у которых перекрывается один и тот же виртуальный (или динамический - не важно) метод и в одной из реализаций этого метода вы хотите вызвать виртуальный метод предка своего предка. Новая объектная модель Delphi допускает только вызов методов предка (с помощью ключевого слова inherited) либо вызов методов класса с префиксом - типом класса (например, TLevel1.ClassName).

Эта проблема стандартными средствами не решается. Но сделать требуемый вызов можно. Причем способом, показанным ниже, можно вызвать любой метод для любого класса, однако, в этом случае вся ответственность за правильность работы с методами и полями ложится на программиста. Ниже в методе VirtualFunction класса TLevel3 вызывается метод класса TLevel1, а в функции Level1Always всегда вызывается метод класса TLevel1 для любого его наследника.

Code:

TLevel1 = class(TComponent)

public

function VirtualFunction: string; virtual;

end;

TLevel2 = class(TLevel1)

public

function VirtualFunction: string; override;

end;

TLevel3 = class(TLevel2)

public

function VirtualFunction: string; override;

end;

function Level1Always(MyLevel: TLevel1): string;

implementation

type

PClass = ^TClass;

function TLevel1.VirtualFunction: string;

begin

Result := 'Level1';

end;

function TLevel2.VirtualFunction: string;

begin

Result := inherited VirtualFunction+' Level2';

end;

function TLevel3.VirtualFunction: string;

var

ClassOld: TClass;

begin

ClassOld := PClass(Self)^;

PClass(Self)^ := TLevel1;

Result := VirtualFunction + ' Level3';

PClass(Self)^ := ClassOld;

end;

function Level1Always(MyObject: TObject): string;

var

ClassOld: TClass;

begin

ClassOld := PClass(MyObject)^;

PClass(MyObject)^ := TLevel1;

Result := (MyObject as TLevel1).VirtualFunction;

PClass(MyObject)^ := ClassOld;

end;

Как же это работает? Стандартные так называемые объектные типы (object types - class of ...) на самом деле представляют из себя указатель на VMT (Virtual Method Table) - таблицу виртуальных методов, который (указатель) лежит по смещению 0 в экземпляре класса. Воспользовавшись этим, мы сначала сохраняем 'старый тип класса' - указатель на VMT, присваиваем ему указатель на VMT нужного класса, делаем вызов и восстанавливаем все как было. Причем нигде не требуется, чтобы один из этих классов был бы порожден от другого, т.е. функция Level1Always вызовет требуемый метод вообще для любого экземпляра любого класса.

Если в функции Level1Always сделать попробовать вызов

Code:

Result := MyObject.VirtualFunction;

то будет ошибка на стадии компиляции, так как у класса TObject нет метода VirtualFunction. Другой вызов

Code:

Result := (MyObject as TLevel3).VirtualFunction;

будет пропущен компилятором, но вызовет Run-time ошибку, даже если передается экземпляр класса TLevel3 или один из его потомком, так как информация о типе объекта меняется. Динамически распределяемые (dynamic) методы можно вызывать точно таким же образом, т.к. информация о них тоже хранится в VMT. Статические методы объектов вызываются гораздо более простым способом, например

Code:

var

MyLevel3: TLevel3;

...

(MyLevel3 as TLevel1).SomeMethode;

вызовет метод класса TLevel1 даже если у MyLevel3 есть свой такой же метод.

Взято из FAQ Epsylon Technologies

Перекрытие виртуальных методов

2013-08-19T15:50:07+07:00

Кто-нибудь знает, в чем разница между перекрытием (OVERRIDING) виртуального метода и заменой (REPLACING) его? Я немного запутался.

Допустим у вас есть класс:

Code:

TMyObject = class (TObject)

и его наследник:

Code:

TOverrideObject = class (TMyObject)

К примеру, TMyObject имеет метод Wiggle:

Code:

procedure Wiggle; virtual;

а TOverrideObject перекрывает Wiggle:

Code:

procedure Wiggle; override;

и, естественно, вы реализовали оба метода.

Теперь вы создаете TList, содержащий целую кучу MyObjects и OverrideObjects в свойстве TList.Items[n]. Свойство Items является указателем, поэтому для вызова метода Wiggle вам достаточно вызвать необходимый элемент списка. Например так:

Code:

if TObject(Items[1]) is TMyObject then

TMyObject(Items[1]).Wiggle

else

if TObject(Items[1]) is TOverrideObject then

TOverrideObject(Items[1]).Wiggle;

но возможности полиморфизма и директива override позволяют вам сделать так:

Code:

TMyObject(Items[1]).Wiggle;

Ваше приложение посмотрит на экземпляр специфического объекта, ссылка на который содержится в Items[1] и скажет: "Да, это - TMyObject, но, точнее говоря, это TOverrideObject; но поскольку метод Wiggle является виртуальным методом и TOverrideObject переопределил метод Wiggle, я собираюсь выполнить метод TOverrideObject.Wiggle, а не метод TMyObject.Wiggle."

Теперь представьте себе, что при декларации метода вы пропустили директиву override, попробуйте это выполнить теперь:

Code:

TMyObject(Items[1]).Wiggle;

Приложение и в этом случае должно "видеть" данный метод, даже если Items[1] - TOverrideObject; но у него отсутствует перекрытая версия метода Wiggle, поэтому приложение выполнит TMyObject.Wiggle, а не TOverrideObject.Wiggle (поведение, которое вы можете как хотеть, так и избегать).

Так, перекрытый метод функционально может отличаться от декларированного метода, содержащего директиву virtual (или dynamic) в базовом классе, и объявленный с директивой override в классе-наследнике. Для замены метода необходимо объявить его в классе-наследнике без директивы override. Перекрытые методы могут выполняться даже тогда, когда специфический экземпляр класса-предка является точной копией базового класса. "Замененные" методы могут выполняться только тогда, когда специфический экземпляр является "слепком" только этого класса.

Взято из Советов по Delphi отВалентина Озерова

Сборник Kuliba

Вызов процедуры, имя которой содержится в переменной

2013-08-19T19:04:34+07:00

Как я могу вызвать процедуру, чье имя хранится в таблице, списке, и т.п.? Другими словами, я хочу сохранить имя процедуры в переменной и для ее вызова обращаться к значению этой переменной. Какие предложения?

Code:

unit ProcDict;

interface

type MyProc = procedure(s: string);

procedure RegisterProc(procName: string; proc: MyProc);

procedure ExecuteProc(procName: string; arg: string);

implementation

uses Classes;

var ProcDict: TStringList;

procedure RegisterProc(procName: string; proc: MyProc);

begin

ProcDict.AddObject(procName, TObject(@proc));

end;

procedure ExecuteProc(procName: string; arg: string);

var

index: Integer;

begin

index := ProcDict.IndexOf(ProcName);

ifindex >= 0then

MyProc(ProcDict.objects[index])(arg);

// Можно вставить обработку исключительной ситуации - сообщение об ошибке

end;

initialization

ProcDict := TStringList.Create;

ProcDict.Sorted := true;

finalization

ProcDict.Free;

end.

вы могли бы создать StringList как показано ниже:

Code:

StringList.Create; StringList.AddObject('Proc1',@Proc1);

StringList.AddObject('Proc2',@Proc2);

и затем реализовать это в вашей программе:

Code:

var

myFunc: procedure;

begin

if Stringlist.indexof(S) = -1then

MessageDlg('Не понял процедуру ' + S, mtError, [mbOk], 0)

else

begin

@myFunc := Stringlist.Objects[Stringlist.indexof(S)];

myFunc;

end;

RAM

Взято из Советов по Delphi от Валентина Озерова

Сборник Kuliba

Выполнение процедуры по адресу

2013-08-19T19:05:36+07:00

Code:

var F: procedure(x, y: double);

@F := GetProcAddress(hDLL, 'SOMEPROC');

F(3, 4);

Ключом здесь является использование оператора @, располагаемого с левой части процедурной переменной. Он говорит компилятору: "Не волнуйтесь здесь о совместимости типов, просто присвойте полученный в правой части выражения адрес переменной в левой части выражения (и процедурные переменные являются переменными-указателями).

- Peter Below

Взято из Советов по Delphi от Валентина Озерова

Сборник Kuliba

Информация о TClass

2013-08-19T19:06:38+07:00

TObject - "корневой" объект.

TClass определен как Class of TObject. Переменная Class НЕ является указателем на экземпляр объекта. Это указатель на *ТИП* объекта Class.

Code:

var

Obj1: TWinControl;

Class1: classof TWinControl;

Class1 := TWinControl - правильное присваивание. Мы не распределяем память, у нас нет экземпляра TWinControl, мы не можем вызвать Class1.OnClick.

Class1 - это *тип* TWinControl с тем же контекстом использования, что и "TWinControl".

Поскольку мы можем использовать TWinControl.Create, то также мы можем использовать и Class1.Create, при этом создавая новый экземпляр TWinControl.

С тех пор как TEdit - наследник TWinControl, Class1 := TEdit правильное присваивание и Class1.Create создает экземпляр TEdit.

Если у меня имеется переменная Obj2: TWinControl, и даже если я присвоил экземпляр TListbox Obj2, я не могу ссылаться на Obj2.Items, поскольку Obj2 определен как TWinControl, а TWinControl не имеет свойства Items.

Те же характеристики верны и для Class1. Class1 определен как Class of TWinControl, поэтому они имеют общий конструктор, определенный в классе TWinControl.

Это не пугает меня при создании дополнительных типов:

Code:

TMyObj1 = class(TEdit)

constructor CreateMagic; virtual;

end;

TMyObj2 = class(TMyObj1)

constructor CreateMagic; override;

end;

TMyClass = classof TMyObj;

var

MyObj1: TMyObj1;

MyObj2: TMyObj2;

function MakeAnother(AClass: TMyClass): TMyObj1;

begin

Result := AClass.CreateMagic;

end;

begin

MyObj2 := TMyObj2.CreateMagic;

MyObj1 := MakeAnother(MyObj2.ClassType);

end.

Взято из Советов по Delphi от Валентина Озерова

Сборник Kuliba

Как внести изменения в код VCL?

2013-08-19T17:09:01+07:00

Примечание: внесение изменений в VCL не поддерживается Borland или Borland Developer Support.

-Но если Вы решили сделать это...

Изменения в код VCL никогда не должны вносится в секцию "interface" модуля - только в секцию "implimentation". Наиболее безопасный способ внести изменения в VCL - создать новый каталог названный "исправленный VCL". Скопируйте файл VCL который Вы хотите изменить в этот каталог. Внесите изменения (лучше прокомментировать их) в этот файл. Затем добавьте путь к Вашему каталогу "исправленный VCL" в самое начало "library path". Перезапустите Delphi/C++ Builder и перекомпилируйте Ваш проект. "library path" можно изменить в меню:

Delphi 1 : Options | Environment | Library

Delphi 2 : Tools | Options | Library

Delphi 3 : Tools | Environment Options | Library

Delphi 4 : Tools | Environment Options | Library

C++ Builder : Options | Environment | Library

Как забыть о необходимости разрушать объекты?

2013-08-19T19:08:27+07:00

Code:

type

ISelfDestroy = interface;

//forget about GUID, if you are not using COM

TSelfDestroy = class(TInterfacedObject, ISelfDestroy)

private

FObject: TObject;

public

constructor Create(AObject: TObject);

destructor Destroy; override;

end;

implementation

constructor TSelfDestroy.Create(AObject: TObject);

begin

FObject := AObject;

end;

destructor TSelfDestroy.Destroy;

begin

FreeAndNil(FObject);

inherited;

end;

// So when you use, just do like this...

procedure TForm1.Button1Click(Sender: TObject);

var

MyObject: TMyObject;

SelfDestroy: TSelfDestroy;

begin

MyObject := TMyObject.Create;

SelfDestroy := TSelfDestroy.Create(MyObject);

// The MyObject will free automatically as soon as TSelfDestroy

// goes out of scope.

// Carry on your code here...

end;

Взято с сайтаhttps://www.swissdelphicenter.ch/en/tipsindex

Как можно работать с объектами не заботясь об их разрушении?

2013-08-19T17:01:39+07:00

Вначале сделаем интерфейс для нашего объекта:

Code:

type

IAutoClean = interface

['{61D9CBA6-B1CE-4297-9319-66CC86CE6922}']

end;

TAutoClean = class(TInterfacedObject, IAutoClean)

private

FObj: TObject;

public

constructor Create(AObj: TObject);

destructor Destroy; override;

end;

implementation

constructor TAutoClean.Create(AObj: TObject);

begin

FObj := AObj;

end;

destructor TAutoClean.Destroy;

begin

FreeAndNil(FObj);

inherited;

end;

А теперь будем использовать его вместо объекта:

Code:

procedure TForm1.Button1Click(Sender: TObject);

var

a: IAutoClean;

//must declare as local variable, so when this procedure finished, it's out of scope

o: TOpenDialog; //any component

begin

o := TOpenDialog.Create(self);

a := TAutoClean.Create(o);

if o.Execute then

ShowMessage(o.FileName);

end;

Взято с Delphi Knowledge Base: https://www.baltsoft

Как создать компонент во время выполнения приложения?

2013-08-19T17:06:34+07:00

При создании визуальных контролов в runtime, важным моментом является назначение родительских свойств и использование метода SetBounds, чтобы этот контрол стал видимы.

Code:

type

TForm1 = class(TForm)

protected

MyLabel: TLabel;

procedure LabelClick(Sender: TObject);

procedure CreateControl;

end;

procedure TForm1.LabelClick(Sender: TObject);

begin

(Sender asLabel).Caption := ...

end;

procedure TForm1.CreateControl;

var

ALeft, ATop, AWidth, AHeight: Integer;

begin

ALeft := 10;

ATop := 10;

AWidth := 50;

AHeight := 13;

MyLabel := TLabel.Create(Self);

MyLabel.Parent := Self;

MyLabel.Name:='LabelName';

MyLabel.SetBounds(ALeft, ATop, AWidth, AHeight);

MyLabel.OnClick := LabelClick;

end;

Взято из https://forum.sources

Как создать копию произвольного компонента?

2013-08-19T17:09:40+07:00

Code:

{

Здесь пpоцедypа CreateClone, котоpая кpеатит компонентy ОЧЕHЬ ПОХОЖУЮ на

входнyю. С такими же значениями свойств. Пpисваивается все, кpоме методов.

}

function CreateClone(Src: TComponent): TComponent;

var

F: TStream;

begin

F := nil;

try

F := TMemoryStream.Create;

F.WriteComponent(Src);

RegisterClass(TComponentClass(Src.ClassType));

F.Position := 0;

Result := F.ReadComponent(nil);

finally

F.Free;

end;

Клонирование объектов

2013-08-19T19:11:28+07:00

Создатькопиюобъектав Delphi оченьпросто. Конвертируемобъектвтекст, азатем - обратно. Приэтомбудутпродублированывсесвойства, кромессылокнаобработчикисобытий. Дляпреобразованиякомпонентавфайлиобратнонампонадобятсяфункциипотоков WriteComponent(TComponent) и ReadComponent(TComponent). Приэтомвпотокзаписываетсядвоичныйресурс. Последнийспомощьюфункции ObjectBinaryToText можнопреобразоватьвтекст.
Создадимнаихосновефункциипреобразования:

Code:

function ComponentToString(Component: TComponent): string;

var

ms: TMemoryStream;

ss: TStringStream;

begin

ss := TStringStream.Create(' ');

ms := TMemoryStream.Create;

try

ms.WriteComponent(Component);

ms.position := 0;

ObjectBinaryToText(ms, ss);

ss.position := 0;

Result := ss.DataString;

finally

ms.Free;

ss.free;

end;

procedure StringToComponent(Component: TComponent; Value: string);

var

StrStream:TStringStream;

ms: TMemoryStream;

begin

StrStream := TStringStream.Create(Value);

try

ms := TMemoryStream.Create;

try

ObjectTextToBinary(StrStream, ms);

ms.position := 0;

ms.ReadComponent(Component);

finally

ms.Free;

end;

finally

StrStream.Free;

end;

Спомощьюпарыэтихфункциймыможемпреобразоватьлюбойкомпонентвтекст, азатемпроинициализироватьдругойкомпоненттогожеклассаэтимиданными.
Нижеприведенресурсформысоднойкнопкойитекстобработчиканажатиянаэтукнопку.

Code:

object Form1: TForm1

Left = 262

Top = 129

Width = 525

Height = 153

Caption = 'Form1'

Color = clBtnFace

Font.Charset = DEFAULT_CHARSET

Font.Color = clWindowText

Font.Height = -11

Font.Name = 'MS Sans Serif'

Font.Style = []

OldCreateOrder = False

Scaled = False

PixelsPerInch = 96

TextHeight = 13

object Button1: TButton

Left = 16

Top = 32

Width = 57

Height = 49

Caption = 'Caption'

TabOrder = 0

OnClick = Button1Click

end

procedure TForm1.Button1Click(Sender: TObject);

var

Button: TButton;

OldName: string;

begin

Button := TButton.Create(self);

//...сохраняем имя компонента

OldName := (Sender as TButton).Name;

//...стираем имя компонента, чтобы избежать конфликта имен.

//...После этого Button1 станет = nil.

(Sender as TButton).Name := '';

//...преобразуем в текст и обратно

StringToComponent( Button, ComponentToString(Sender as TButton) );

//...дадим компоненту уникальное(?) имя

Button.Name := 'Button' + IntToStr(random(1000));

//...вернем исходному компоненту имя.

//...После этого Button1 станет снова указывать на объект.

(Sender as TButton).Name := OldName;

//...размещаем новую кнопку справа от исходной

Button.parent := self;

Button1.Tag := Button1.Tag + 1;

Button.Left := Button.Left + Button.Width * Button1.Tag + 1;

end;

Приведенныйметоднедублируетуказателинаобработчикисобытий. Однако, еслитакимобразомдублироватьформы, товседочерниекомпонентыивсеобработчикисохранятся.

составлениестатьи: АндрейЧудин, ЦПРТДБиблио-Глобус

Взято из https://delphi.chertenok

Работа метода Assign

2013-08-19T19:07:31+07:00

В общем случае, утверждение "Destination := Source" не идентично утверждению "Destination.Assign(Source)".

Утверждение "Destination := Source" принуждает Destination ссылаться на тот же объект, что и Source, а "Destination.Assign(Source)" копирует содержание объектных ссылок Source в объектные ссылки Destination.

Если Destination является свойством некоторого объекта (тем не менее, и свойство не является ссылкой на другой объект, как, например, свойство формы ActiveControl, или свойство DataSource элементов управления для работы с базами данных), тогда утверждение "Destination := Source" идентично утверждению "Destination.Assign(Source)". Это объясняет, почему LB.Items := MemStr работает, когда MemStr := LB.Items нет.

Взято из Советов по Delphi от Валентина Озерова

Сборник Kuliba

Сгруппировать свойства наподобие Font

2013-08-19T19:10:14+07:00

...чтобы сгруппировать свойства наподобие Font, вам необходимо создать наследника (подкласс) TPersistent. Например:

Code:

TBoolList = class(TPersistent)

private

FValue1: Boolean;

FValue2: Boolean

published

property Value1: Boolean read FValue1 write FValue1;

property Value2: Boolean read FValue2 write FValue2;

end;

Затем, в вашем новом компоненте, для этого подкласса необходимо создать ivar. Чтобы все работало правильно, вам необходимо перекрыть конструктор.

Code:

TMyPanel = class(TCustomPanel)

private

FBoolList: TBoolList;

public

constructor Create( AOwner: TComponent ); override;

published

property BoolList: TBoolList read FBoolList write FBoolLisr;

end;

Затем добавьте следующий код в ваш конструктор:

Code:

constructor TMyPanel.Create( AOwner: TComponent );

begin

inherited Create( AOwner );

FBoolList := TBoolList.Create;

end;

Взято с https://delphiworld.narod

Сохранение и загрузка данных в объекты на примере коллекций.

2013-08-19T19:12:45+07:00

ЕсливВашейпрограммеиспользуютсяклассыдляописанияобъектовнекоторойпредметнойобласти, тоданные, ихинициализирующие, можнохранитьивбазеданных. Номожновыбратьгораздоболеепродуктивныйподход, которыйдоступенв Delphi/C++ Builder. Средаразработки Delphi/C++ Builder хранитресурсывсехформвдвоичныхилитекстовыхфайлахиэтавозможностьдоступнаидляразрабатываемыхсеепомощьюпрограмм. Вданномслучае, дляоценкиудобствтакогоподходалучшевсегорассмотретьконкретныйпример.

Необходимореализоватьхранениеинформациионекоейслужберассылкииееподписчиках. Будемхранитьданныеопочтовомсервереисписокподписчиков. Каждаязаписьоподписчикехранитеголичныеданныеиадрес, атакжесписоктем(иликаталогов), накоторыеонподписан. КакбольшиепоклонникиГрадиБуча (Grady Booch), атакжебудучизаинтересованывудобнойорганизациикода, мыорганизуеминформациюоподписчикахввидеобъектов. В Delphi дляданнойзадачиидеальноподходиткласс TCollection, реализующийвсюнеобходимуюфункциональностьдляработысоспискамитипизированныхобъектов. Дляэтогомынаследуемсяот TCollection, называяновыйкласс TMailList - списокрассылки, атакжесоздаемнаследникаот TCollectionItem - TMailClient - адресатрассылки. Последнийбудетсодержатьвсенеобходимыеданныеоподписчике, атакжереализовыватьнеобходимыефункциидляработысним.

Самуколлекциюсподписчикаминамнужнобудетпоместитьвнекийбазовыйкласс, которыймыибудемсохранятьизагружать. Нарольтаковогоподходиткласс TMailer - почтовыйклиент.
Начнемс TMailClient.

Code:

type

TMailClient = class(TCollectionItem)

private

FName: string;

FAddress: string;

FEnabled: boolean;

FFolders: TStringList;

public

Files: TStringList; // список файлов к рассылке. заполняется в run-time. Сохранению не подлежит

constructor Create(Collection: TCollection); override;

destructor Destroy; override;

procedure PickFiles;

published

propertyName: stringread FName write FName; // имя адресата

property Address: stringread FAddress write FAddress; // почтовый адрес

property Enabled: boolean read FEnabled write FEnabled default true;

property Folders: TStringList read FFolders write FFolders; // список папок (тем) подписки

end;

Класссодержитсведенияоимениклиента, егоадресе, егостатусе(Enabled), атакжесписоккаталогов, накоторыеонподписан. Процедура PickFiles составляетсписокфайловкотправкеисохраняетеговсвойстве Files
Класс TMailList, хранящийобъектыкласса TMailClient, приведенниже.

Code:

TMailList = class(TCollection)

public

function GetMailClient(Index: Integer): TMailClient;

procedure SetMailClient(Index: Integer; Value: TMailClient);

public

function Add: TMailClient;

property Items[Index: Integer]: TMailClient read GetMailClient write SetMailClient; default;

end;

Теперьпоместимкласс TMailList вкласс TMailer. Внегоможнобудетпотомвключитьданныеопараметрахдоступакпочтовомусерверудляотправкипочты. Онмогбыиотправлятьпочту, новданномпримереэтонеиспользовано, дабынеперегружатькод.

Тоестьвнашемпримереонвыполняеттолькорольносителяданныхоподписчикахиихподписке. Класс TComponent, откоторогооннаследуетсяможносохранитьвфайл, втовремякак TCollection самостоятельнонесохранится. Толькоеслионаагрегированав TComponent. Именноэтоунасиреализовано.

Code:

TMailer = class(TComponent)

private

FMailList: TMailList;

public

constructor Create(AOwner: TComponent); override;

destructor Destroy; override;

published

property MailList: TMailList read FMailList write FMailList; // коллекция - список рассылки.

// здесь можно поместить, к примеру, данные о соединении с почтовым сервером

end;

Повторюсь. Вданномслучаемынаследуемсяоткласса TComponent, длятого, чтобыбылавозможностизаписиданныхобъектавфайл. Свойство MailList содержитужеобъекткласса TMailList.
Реализациявсехприведенныхклассовприведенаниже.

Code:

constructor TMailClient.Create(Collection: TCollection);

begin

inherited;

Folders := TStringList.Create;

Files := TStringList.Create;

FEnabled := true;

end;

destructor TMailClient.Destroy;

begin

Folders.Free;

Files.Free;

inherited;

end;

// здесь во всех каталогах Folders ищем файлы для рассылки и помещаем их в Files.

procedure TMailClient.PickFiles;

var i: integer;

begin

for i:=0to Folders.Count-1do CreateFileList(Files, Folders[i]);

end;

// Стандартный код при наследовании от класса коллекции: переопределяем тип

function TMailList.GetMailClient(Index: Integer): TMailClient;

begin

Result := TMailClient(inherited Items[Index]);

end;

// Стандартный код при наследовании от класса коллекции

procedure TMailList.SetMailClient(Index: Integer; Value: TMailClient);

begin

Items[Index].Assign(Value);

end;

// Стандартный код при наследовании от класса коллекции: переопределяем тип

function TMailList.Add: TMailClient;

begin

Result := TMailClient(inherited Add);

end;

// создаем коллекцию адресатов рассылки TMailList

constructor TMailer.Create(AOwner: TComponent);

begin

inherited Create(AOwner);

MailList := TMailList.Create(TMailClient);

end;

destructor TMailer.Destroy;

begin

MailList.Free;

inherited;

end;

//---------------------

Функция CreateFileList создаетпокаким-либоправиламсписокфайловнаосновепереданногоейспискакаталогов, обходяихрекурсивно. Кпримеру, онаможетбытьреализованатак.

Code:

procedure CreateFileList(sl: TStringList; const FilePath: string);

var

sr: TSearchRec;

procedure ProcessFile;

begin

if (sr.Name = '.')or(sr.Name = '..') then exit;

if sr.Attr <> faDirectory then

sl.Add(FilePath + '\' + sr.Name);

if sr.Attr = faDirectory then

begin

CreateFileList(sl, FilePath + '\' + sr.Name);

end;

begin

ifnot DirectoryExists(FilePath) then exit;

if FindFirst(FilePath + '\' + '*.*', faAnyFile , sr) = 0then ProcessFile;

while FindNext(sr) = 0do ProcessFile;

FindClose(sr);

end;

Витогемырасполагаемклассом TMailer, содержащимвсюнеобходимуюнаминформацию. Теперьперейдемксозданиюобъекта, ихсохранениюизагрузке.

Code:

var

Mailer: TMailer; // это наш объект для хранения данных о почтовой рассылки

// Процедура загрузки данных в объект. Может быть процедурой OnCreate() главной формы.

procedure TfMain.FormCreate(Sender: TObject);

var

sDataFile, sTmp: string;

i, j: integer;

begin

Mailer := TMailer.Create(self);

// будем считать, что данные были сохранены в файл users.dat в каталоге программы

sDataFile := ExtractFilePath(ParamStr(0)) + 'users.dat';

//...загрузка данных из файла

if FileExists(sDataFile) then

LoadComponentFromTextFile(Mailer, sDataFile);

{ здесь данные из файла загружены }

//...перебор подписчиков

for i:=0to Mailer.MailList.Count-1do

begin

sTmp := Mailer.MailList[i].Name; //...обращение к имени

sTmp := Mailer.MailList[i].Address; //...обращение к адресу

//... sTmp - фиктивная переменная. Поменяйте ее на свои.

Mailer.MailList[i].PickFiles; //... поиск файлов для отправки очередному подписчику.

//...перебор найденных файлов к отправке

for j:=0to Mailer.MailList[i].Files.Count-1do

begin

sTmp := Mailer.MailList[i].Files[j];

end;

Послезагрузкиданныхмыможемработатьсданнымивнашейколлекцииподписчиков. Добавлятьиудалятьих ( Mailer.MailList.Add; Mailer.MailList.Delete(Index); ). Призавершенииработыпрограммынеобходимосохранитьуженовыеданныевтотжефайл.

Code:

// Процедура сохранения данных из объекта в файл. Может быть процедурой OnDestroy() главной формы.

procedure TfMain.OnDestroy;

begin

//...сохранение данных в файл users.dat

SaveComponentToTextFile(Mailer, ExtractFilePath(ParamStr(0)) + 'users.dat');

end;

ХранениеданныхвфайлепозволяетоказатьсяотиспользованияБД, еслиобъемданныхнеслишкомвеликинетнеобходимостивсовместномдоступекданным.
Самоеглавное - мыорганизуемвседанныеввиденабораудобныхдляработыклассовинетратимвремянаихсохранениеиинициализациюизБД.
Приведенныйпримерлишьиллюстрируетэтотподход. Дляегореализациимогутподойтии 2 таблицывБД. Однакоприведенныйподходудобенприусловии, чтоданныеимеютсложнуюиерархию. Кпримеру, вложенныеколлекцииразныхтиповгораздосложнееразложитьвбазеданных, дляихизвлеченияпотребуется SQL. Решайтесами, судяпосвоейконкретнойзадаче.

Далееприведенкодфункцийдлясохранения/чтениякомпонента.

Code:

//...процедура загружает(инициализирует) компонент из текстового файла с ресурсом

procedure LoadComponentFromTextFile(Component: TComponent; const FileName: string);

var

ms: TMemoryStream;

fs: TFileStream;

begin

fs := TFileStream.Create(FileName, fmOpenRead);

ms := TMemoryStream.Create;

try

ObjectTextToBinary(fs, ms);

ms.position := 0;

ms.ReadComponent(Component);

finally

ms.Free;

fs.free;

end;

//...процедура сохраняет компонент в текстовый файл

procedure SaveComponentToTextFile(Component: TComponent; const FileName: string);

var

ms: TMemoryStream;

fs: TFileStream;

begin

fs := TFileStream.Create(FileName, fmCreate or fmOpenWrite);

ms := TMemoryStream.Create;

try

ms.WriteComponent(Component);

ms.position := 0;

ObjectBinaryToText(ms, fs);

finally

ms.Free;

fs.free;

end;

составлениестатьи: АндрейЧудин, ЦПРТДБиблио-Глобус.

Взято из https://delphi.chertenok

Список handle всех окон моего приложения

2013-08-19T19:09:20+07:00

Code:

function EnumProc(wnd: HWND; var count: DWORD): Bool; stdcall;

begin

Inc(count);

result := True;

EnumChildWindows(wnd, @EnumProc, integer(@count));

end;

procedure TForm1.Button1Click(Sender: TObject);

var

count: DWORD;

begin

count := 0;

EnumThreadWindows(GetCurrentThreadID, @EnumProc, Integer(@count));

Caption := Format('%d window handles in use', [count]);

end;

Взято с сайтаhttps://www.swissdelphicenter.ch/en/tipsindex

Шаблоны в Object Pascal

2013-08-19T17:08:00+07:00

Шаблоны в Object Pascal

( перевод одноименной статьи с сайта community.borland.com )

Наверное каждый Delphi программист хоть раз общался с программистом C++ и объяснял насколько

Delphi мощнее и удобнее. Но в некоторый момент, программист C++ заявляет примерно следующее

"OK, но Delphi использует Pascal, а значит не поддерживает множественное наследование и шаблоны,

поэтому он не так хорош как C++."

Насчет множественного наследования можно легко заявить, что Delphi имеет интерфейсы, которые

прекрасно справляются со своей задачей, но вот насчет шаблонов Вам придётся согласится, так как

Object Pascal не поддерживает их.

Давайте посмотрим на эту проблему по-внимательней

Шаблоны позволяют делать универсальные контейнеры такие как списки, стеки, очереди, и т.д.

Если Вы хотите осуществить что-то подобное в Delphi, то у Вас есть два пути:

Использовать контейнер TList, который содержит указатели. В этом случае Вам придётся всё

время делать явное приведение типов.

Сделать подкласс контейнера TCollection или TObjectList, и убрать все методы, зависящие от типов

каждый раз, когда Вы захотите использовать новый тип данных.

Третий вариант, это сделать модуль с универсальным классом контейнера, и каждый раз, когда нужно

использовать новый тип данных, нам прийдётся в редакторе искать и вносить исправления. Было бы

здорово, если всю эту работу за Вас делал компилятор.... вот этим мы сейчас и займёмся!

Например, возьмём классы TCollection и TCollectionItem. Когда Вы объявляете нового потомка TCollectionItem

, то так же Вы наследуете новый класс от TOwnedCollection и переопределяете большинство методов, чтобы

их можно было вызывать с новыми типами.

Давайте посмотрим, как создать универсальную коллекцию шаблонов класса:

Шаг 1: Создайте новый текстовый файл (не юнитовский) с именем TemplateCollectionInterface.pas:

Code:

_COLLECTION_ = class (TOwnedCollection)

protected

function GetItem (const aIndex : Integer) : _COLLECTION_ITEM_;

procedure SetItem (const aIndex : Integer;

const aValue : _COLLECTION_ITEM_);

public

constructor Create (const aOwner : TComponent);

function Add : _COLLECTION_ITEM_;

function FindItemID (const aID : Integer) : _COLLECTION_ITEM_;

function Insert (const aIndex : Integer) : _COLLECTION_ITEM_;

property Items [const aIndex : Integer] : _COLLECTION_ITEM_ read GetItem write SetItem;

end;

Обратите внимание, что нет никаких uses или interface clauses, только универсальное объявление

типа, в котором _COLLECTION_ это имя универсальной коллекции класса, а _COLLECTION_ITEM_

это имя методов, содержащихся в нашем шаблоне.

Шаг 2: Создайте второй текстовый файл и сохраните его как TemplateCollectionImplementation.pas:

Code:

constructor _COLLECTION_.Create (const aOwner : TComponent);

begin

inherited Create (aOwner, _COLLECTION_ITEM_);

end;

function _COLLECTION_.Add : _COLLECTION_ITEM_;

begin

Result := _COLLECTION_ITEM_ (inherited Add);

end;

function _COLLECTION_.FindItemID (const aID : Integer) : _COLLECTION_ITEM_;

begin

Result := _COLLECTION_ITEM_ (inherited FindItemID (aID));

end;

function _COLLECTION_.GetItem (const aIndex : Integer) : _COLLECTION_ITEM_;

begin

Result := _COLLECTION_ITEM_ (inherited GetItem (aIndex));

end;

function _COLLECTION_.Insert (const aIndex : Integer) : _COLLECTION_ITEM_;

begin

Result := _COLLECTION_ITEM_ (inherited Insert (aIndex));

end;

procedure _COLLECTION_.SetItem (const aIndex : Integer;

const aValue : _COLLECTION_ITEM_);

begin

inherited SetItem (aIndex, aValue);

end;

Снова нет никаких uses или interface clauses , а только код универсального типа.

Шаг 3: Создайте новый unit-файл с именем MyCollectionUnit.pas:

Code:

unit MyCollectionUnit;

interface

uses Classes;

type TMyCollectionItem = class (TCollectionItem)

private

FMyStringData : String;

FMyIntegerData : Integer;

public

procedure Assign (aSource : TPersistent); override;

published

property MyStringData : Stringread FMyStringData write FMyStringData;

property MyIntegerData : Integer read FMyIntegerData write FMyIntegerData;

end;

// !!! Указываем универсальному классу на реальный тип

_COLLECTION_ITEM_ = TMyCollectionItem;

// !!! директива добавления интерфейса универсального класса

{$INCLUDE TemplateCollectionInterface}

// !!! переименовываем универсальный класс

TMyCollection = _COLLECTION_;

implementation

uses SysUtils;

// !!! препроцессорная директива добавления универсального класса

{$INCLUDE TemplateCollectionImplementation}

procedure TMyCollectionItem.Assign (aSource : TPersistent);

begin

if aSource is TMyCollectionItem then

begin

FMyStringData := TMyCollectionItem(aSource).FMyStringData;

FMyIntegerData := TMyCollectionItem(aSource).FMyIntegerData;

end

elseinherited;

end;

end.

Вот и всё! Теперь компилятор будет делать всю работу за Вас! Если Вы измените интерфейс

универсального класса, то изменения автоматически распространятся на все модули, которые

он использует.

Второй пример

Давайте создадим универсальный класс для динамических массивов.

Шаг 1: Создайте текстовый файл с именем TemplateVectorInterface.pas:

Code:

_VECTOR_INTERFACE_ = nterface

function GetLength : Integer;

procedure SetLength (const aLength : Integer);

function GetItems (const aIndex : Integer) : _VECTOR_DATA_TYPE_;

procedure SetItems (const aIndex : Integer;

const aValue : _VECTOR_DATA_TYPE_);

function GetFirst : _VECTOR_DATA_TYPE_;

procedure SetFirst (const aValue : _VECTOR_DATA_TYPE_);

function GetLast : _VECTOR_DATA_TYPE_;

procedure SetLast (const aValue : _VECTOR_DATA_TYPE_);

function High : Integer;

function Low : Integer;

function Clear : _VECTOR_INTERFACE_;

function Extend (const aDelta : Word = 1) : _VECTOR_INTERFACE_;

function Contract (const aDelta : Word = 1) : _VECTOR_INTERFACE_;

property Length : Integer read GetLength write SetLength;

property Items [const aIndex : Integer] : _VECTOR_DATA_TYPE_ read GetItems write SetItems; default;

property First : _VECTOR_DATA_TYPE_ read GetFirst write SetFirst;

property Last : _VECTOR_DATA_TYPE_ read GetLast write SetLast;

end;

_VECTOR_CLASS_ = class (TInterfacedObject, _VECTOR_INTERFACE_)

private

FArray : arrayof _VECTOR_DATA_TYPE_;

protected

function GetLength : Integer;

procedure SetLength (const aLength : Integer);

function GetItems (const aIndex : Integer) : _VECTOR_DATA_TYPE_;

procedure SetItems (const aIndex : Integer;

const aValue : _VECTOR_DATA_TYPE_);

function GetFirst : _VECTOR_DATA_TYPE_;

procedure SetFirst (const aValue : _VECTOR_DATA_TYPE_);

function GetLast : _VECTOR_DATA_TYPE_;

procedure SetLast (const aValue : _VECTOR_DATA_TYPE_);

public

function High : Integer;

function Low : Integer;

function Clear : _VECTOR_INTERFACE_;

function Extend (const aDelta : Word = 1) : _VECTOR_INTERFACE_;

function Contract (const aDelta : Word = 1) : _VECTOR_INTERFACE_;

constructor Create (const aLength : Integer);

end;

Шаг 2: Создайте текстовый файл и сохраните его как TemplateVectorImplementation.pas:

Code:

constructor _VECTOR_CLASS_.Create (const aLength : Integer);

begin

inherited Create;

SetLength (aLength);

end;

function _VECTOR_CLASS_.GetLength : Integer;

begin

Result := System.Length (FArray);

end;

procedure _VECTOR_CLASS_.SetLength (const aLength : Integer);

begin

System.SetLength (FArray, aLength);

end;

function _VECTOR_CLASS_.GetItems (const aIndex : Integer) : _VECTOR_DATA_TYPE_;

begin

Result := FArray [aIndex];

end;

procedure _VECTOR_CLASS_.SetItems (const aIndex : Integer;

const aValue : _VECTOR_DATA_TYPE_);

begin

FArray [aIndex] := aValue;

end;

function _VECTOR_CLASS_.High : Integer;

begin

Result := System.High (FArray);

end;

function _VECTOR_CLASS_.Low : Integer;

begin

Result := System.Low (FArray);

end;

function _VECTOR_CLASS_.GetFirst : _VECTOR_DATA_TYPE_;

begin

Result := FArray [System.Low (FArray)];

end;

procedure _VECTOR_CLASS_.SetFirst (const aValue : _VECTOR_DATA_TYPE_);

begin

FArray [System.Low (FArray)] := aValue;

end;

function _VECTOR_CLASS_.GetLast : _VECTOR_DATA_TYPE_;

begin

Result := FArray [System.High (FArray)];

end;

procedure _VECTOR_CLASS_.SetLast (const aValue : _VECTOR_DATA_TYPE_);

begin

FArray [System.High (FArray)] := aValue;

end;

function _VECTOR_CLASS_.Clear : _VECTOR_INTERFACE_;

begin

FArray := Nil;

Result := Self;

end;

function _VECTOR_CLASS_.Extend (const aDelta : Word) : _VECTOR_INTERFACE_;

begin

System.SetLength (FArray, System.Length (FArray) + aDelta);

Result := Self;

end;

function _VECTOR_CLASS_.Contract (const aDelta : Word) : _VECTOR_INTERFACE_;

begin

System.SetLength (FArray, System.Length (FArray) - aDelta);

Result := Self;

end;

Шаг 3: Создайте unit файл с именем FloatVectorUnit.pas:

Code:

unit FloatVectorUnit;

interface

uses Classes; // !!! Модуль "Classes" содержит объявление класса TInterfacedObject

type _VECTOR_DATA_TYPE_ = Double; // !!! тип данных для класса массива Double

{$INCLUDE TemplateVectorInterface}

IFloatVector = _VECTOR_INTERFACE_; // !!! give the interface a meanigful name

TFloatVector = _VECTOR_CLASS_; // !!! give the class a meanigful name

function CreateFloatVector (const aLength : Integer = 0) : IFloatVector; // !!! дополнительная функция

implementation

{$INCLUDE TemplateVectorImplementation}

function CreateFloatVector (const aLength : Integer = 0) : IFloatVector;

begin

Result := TFloatVector.Create (aLength);

end;

end.

Естественно, можно дополнить универсальный класс дополнительными

функциями. Всё зависит от Вашей фантазии!

Использование шаблонов

Вот пример использования нового векторного интерфейса:

Code:

procedure TestFloatVector;

var aFloatVector : IFloatVector;

aIndex : Integer;

begin

aFloatVector := CreateFloatVector;

aFloatVector.Extend.Last := 1;

aFloatVector.Extend.Last := 2;

for aIndex := aFloatVector.Low to aFloatVector.High do

begin

WriteLn (FloatToStr (aFloatVector [aIndex]));

end;

end.

Единственное требование при создании шаблонов таким способом, это то, что

каждый новый тип должен быть объявлен в отдельном модуле, а так же Вы должны

иметь исходники для универсальных классов.

Взято из https://forum.sources

Как заставить код компонента работать только в дизайне?

2013-08-19T13:31:31+07:00

Code:

if csDesigning in ComponentState then

begin

... код, работающий только в дизайне ...

end;

Взято из Советов по Delphi от Валентина Озерова

Сборник Kuliba

вмодификации Vit

Как написать собственный класс?

2013-08-19T13:30:10+07:00

Вот пример написания класса. Этот класс вычисляет сумму квадратов введенных чисел. Этот класс написан мной только для примера, и я исходил из соображений наглядности, а не оптимальности. Большая часть реализации не только не оптимальна, но и бессмысленна, но показывает большую часть простейших приемов создания класса.

Code:

unit Unit2;

{©Drkb v.3(2007): www.drkb.ru,

®Vit (Vitaly Nevzorov) - nevzorov@yahoo.com}

interface

Uses classes, Sysutils;

{Нам нужен процедурный тип для создания собственного события. Собственно - это описание процедуры которая должна будет исполнятся при каких-нибудь обстоятельствах}

Type

TError = procedure(Sender:TObject; Error: string) ofobject;

{Описание нашего класса, мы его наследуем от TObject, потому ?то нам практи?ески не нужна

никакия функциональность предков}

Type TStatistic=Class(TObject)

private{здесь описываются только внутренние переменные и процедуры - "для служебного пользования"}

{Описание полей, т.е. переменных которые работают только внутри класса, "снаружи" они не

доступны.}

FList:TStringList;

FPrecision: byte;

{Тоже переменная - для определения события}

FonError: TError;

{функция - будет использоваться только внутри класса, "снаружи" напрямую не доступна}

function GetCount: integer;

public{Описанное здесь доступно для пользователя класса}

{Конструктор - метод создания класса, имеет смысл его описывать только если он делает

?то-то специфи?еское - например нам надо будет создать переменную FList. В противном слу?ае

его описание можно опустить - будет работать конструктор родительского класса}

Constructor Create;

{Деструктор - метод разрушения класса}

Destructor Destroy; override;

{Описание методов - собственно методы мало ?ем отли?аются от процедур}

Procedure AddValue(Value:String);

Procedure Clear;

Function Solve:real;

{Описание свойств. Обратите внимание само свойство не способно хранить никакую информацию, это

только указатель на внутренюю струкруру. Например для хранения свойства Precision используется

переменная FPrecision. А для ?тение свойства Count используется функция GetCount}

Property Precision:byte read FPrecision write FPrecision;

Property Count:integer read GetCount;

{Описание событий. ?то такое событие? - Это указатель на процедуру. Сам класс реализации этой процедуры

не знает. Классу известно только заголовок процедуры, вы в коде программы будете писать реализацию

процедуры, а класс только в нужный момент передаст ей управление, используя указатель onError}

Property onError:TError read FonError write FonError;

end;

implementation

{ TStatistic }

constructor TStatistic.Create;

begin

inherited; {Вна?але надо вызвать конструктор класса-родителя}

FList:=TStringList.create;{создаем структуры нашего класса}

end;

destructor TStatistic.Destroy;

begin

FList.Free;{Разрушаем структуры нашего класса}

inherited;{в последнюю о?ередь вызываем деструктор клсса-родителя}

end;

procedure TStatistic.AddValue(Value: String);

begin

FList.add(Value); {Примерно так мы реализуем метод}

end;

procedure TStatistic.Clear;

begin

FList.clear;

end;

function TStatistic.GetCount: integer;

begin

Result:=FList.count+1;

end;

function TStatistic.Solve: real;

var i:integer;

begin

result:=0;

for i:=0to FList.count-1do

begin

try

result:=result+(Sqr(strtofloat(FList[i])));

except

{интересная конструкция. "on e:exception do" - мы "отлавливаем" ошибку как переменную "e".

Эта переменная имеет о?ень полезное свойство e.message - оно содержит описание ошибки. Далее

следует вызов события. Вна?але мы проверяем использует ли пользователь событие:

"if Assigned(FOnError) then", если использует то вызываем его процедуру: FOnError, с параметрами:

self - зарезервированная переменная - указатель на экземпляр нашего класса, e.message - описание

ошибки}

on e:exception do

if Assigned(FOnError) then FOnError(Self, e.message);

end;

end.

Вот пример использования этого класса:

unit Unit1;

interface

uses Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,

StdCtrls;

type

TForm1 = class(TForm)

Button1: TButton;

procedure Button1Click(Sender: TObject);

private

procedure OnError(Sender:TObject; Error: string);

public

{ Public declarations }

end;

var

Form1: TForm1;

implementation

uses Unit2;

{$R *.DFM}

procedure TForm1.Button1Click(Sender: TObject);

var Statistic:TStatistic;

begin

Statistic:=TStatistic.create;

Statistic.onError:=onError;

Statistic.AddValue('123423');

showmessage(floattostr(Statistic.solve));

Statistic.Clear;

Statistic.AddValue('123423');

Statistic.AddValue('12ssss3');

showmessage(floattostr(Statistic.solve));

Statistic.Free;

end;

procedure TForm1.OnError(Sender: TObject; Error: string);

begin

showmessage('Error inside class:'+Sender.ClassName+#13#10+Error);

end;

end.

Автор:Vit

Взято с Vingradhttps://forum.vingrad

Пособие по написанию своих компонентов

2013-08-19T13:35:03+07:00

Пособиепонаписаниюсвоихкомпонентовна Delphi дляначинающих

Почемуяселписатьэтопособие

Во-первых, потому что когда я очень хотел написать свой первый компонент, я прочитал две книги, и у меня ничего интересного собственно не вышло. Потом я прочитал еще одну книгу (в ней хотя бы пример рабочий был), вроде разобрался. Но там был разобран такой простой компонент, что все более сложное мне приходилось делать самому, иногда методом тыка, иногда сидел разбирался и так далее. Результат - разобрался, чего и вам желаю и надеюсь помочь этим пособием.

Все мои готовые компоненты можно найти на сайте https://delphid.dax

Длячегонужныкомпоненты

Дельфи имеет открытую архитектуру - это значит, что каждый программист волен усовершенствовать эту среду разработки, как он захочет. К стандартным наборам компонентов, которые поставляются вместе с Дельфи можно создать еще массу своих интересных компонентов, которые заметно упростят вам жизнь (это я вам гарантирую). А еще можно зайти на какой-нибудь крутой сайт о Дельфи и там скачать кучу крутых компонентов, и на их основе сделать какую-нибудь крутую прогу. Так же компоненты освобождают вас от написания "тысячи тонн словесной руды". Пример: вы создали компонент - кнопку, при щелчке на которую данные из Memo сохранятся во временный файл. Теперь как только вам понадобится эта функция вы просто ставите этот компонент на форму и наслаждаетесь результатом. И не надо будет каждый раз прописывать это, для ваших новых программ - просто воспользуйтесь компонентом.

Шаг 1. Придумываниеидеи

Первым шагом нужно ответить себе на вопрос: "Для чего мне этот компонент и что он будет делать?". Затем необходимо в общих чертах продумать его свойства, события, на которые он будет реагировать и те функции и процедуры, которыми компонент должен обладать. Затем очень важно выбрать "предка" компонента, то есть наследником какого класса он будет являться. Тут есть два пути. Либо в качестве наследника взять уже готовый компонент (то есть модифицировать уже существующий класс), либо создать новый класс.

Для создания нового класса можно выделить 4 случая:

1. Создание Windows-элемента управления (TWinControl)

2. Создание графического элемента управления (TGraphicControl)

3. Создание нового класса или элемента управления (TCustomControl)

4. Создание невизуального компонента (не видимого) (TComponent)

Теперь попробую объяснить что же такое визуальные и невизуальные компоненты. Визуальные компоненты видны во время работы приложения, с ними напрямую может взаимодействовать пользователь, например кнопка Button - является визуальным компонентом.

Невизуальные компоненты видны только во время разработки приложения (Design-Time), а во время работы приложения (Run-Time) их не видно, но они могут выполнять какую-нибудь работу. Наиболее часто используемый невизуальный компонент - это Timer.

Итак, что бы приступить от слов к делу, попробуем сделать какой-нибудь супер простой компонент (только в целях ознакомления с техникой создания компонентов), а потом будем его усложнять.

Шаг 2. Созданиепустогомодулякомпонента

Рассматривать этот шаг я буду исходя из устройства Дельфи 3, в других версиях этот процесс не сильно отличается. Давайте попробуем создать кнопку, у которой будет доступна информация о количестве кликов по ней.

Чтобы приступить к непосредственному написанию компонента, вам необходимо сделать следующее:

·	Закройте проекты, которые вы разрабатывали (формы и модули)

·	В основном меню выберите Component -> New Component...

·	Перед вами откроется диалоговое окно с названием "New Component"

·	В поле Ancestor Type (тип предка) выберите класс компонента, который вы хотите модифицировать. В нашем случае вам надо выбрать класс TButton

·	В поле Class Name введите имя класса, который вы хотите получить. Имя обязательно должно начинаться с буквы "T". Мы напишем туда, например, TCountBtn

·	В поле Palette Page укажите имя закладки на которой этот компонент появиться после установки. Введем туда MyComponents (теперь у вас в Делфьи будет своя закладка с компонентами!).

·	Поле Unit File Name заполняется автоматически, в зависимости от выбранного имени компонента. Это путь куда будет сохранен ваш модуль.

·	В поле Search Path ничего изменять не нужно.

·	Теперь нажмите на кнопку Create Unit и получите следующее:

Code:

unit CountBtn;

interface

uses

Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,

StdCtrls;

type

TCountBtn = class(TButton)

private

{ Private declarations }

protected

{ Protected declarations }

public

{ Public declarations }

published

{ Published declarations }

end;

procedureRegister;

implementation

procedureRegister;

begin

RegisterComponents('MyComponents', [TCountBtn]);

end;

end.

Шаг 3. Начинаемразбиратьсявовсехдирективах

Что же здесь написано? да собственно пока ничего интересного. Здесь объявлен новый класс TCountBtn и процедура регистрации вашего компонента в палитре компонентов.

Директива Private Здесь вы будете писать все скрытые поля которые вам понадобятся для создания компонента. Так же в этой директиве описываются процедуры и функции, необходимые для работы своего компонента, эти процедуры и функции пользователю не доступны. Для нашего компонент мы напишем туда следующее (запись должна состоять из буквы "F" имени поля: тип этого поля):

Code:

FCount:integer;

Буква "F" должна присутсвовать обязательно. Здесь мы создали скрытое поле Count, в котором и будет храниться число кликов по кнопке.

Директива Protected. Обычно я здесь пишу различные обработчики событий мыши и клавиатуры. Мы напишем здесь следующую строку:

Code:

procedure Click; override;

Это указывает на то, что мы будем обрабатывать щелчок мыши по компоненту. Слово "override" указывает на то, что мы перекроем стандартное событие OnClick для компонента предка.

В директиве Public описываются те процедуры и функции компонента, которые будут доступны пользователю. (Например, в процессе написания кода вы пишите имя компонента, ставите точку и перед вами список доступных функций, объявленных в диретиве Public). Для нашего компонента, чтобы показать принцип использования этой директивы создадим функцию - ShowCount, которая покажет сообщение, уведомляя пользователя сколько раз он уже нажал на кнопку. Для этого в директиве Public напишем такой код:

Code:

procedure ShowCount;

Осталась последняя директива Published. В ней также используется объявления доступных пользователю, свойств и методов компонента. Для того, чтобы наш компонент появился на форме необходимо описать метод создания компонента (конструктор), можно прописать и деструктор, но это не обязательно. Следует обратить внимание на то, что если вы хотите, чтобы какие-то свойства вашего компонента появились в Инспекторе Объектов (Object Inspector) вам необходимо описать эти свойства в директиве Published. Это делается так: property Имя_свойства (но помните здесь букву "F" уже не нужно писать), затем ставиться двоеточие ":" тип свойства, read процедура для чтения значения, write функция для записи значения;. Но похоже это все сильно запутано. Посмотрите, что нужно написать для нашего компонента и все поймете:

Code:

constructor Create(aowner:Tcomponent);override; //Конструктор

property Count:integer read FCount write FCount; //Свойство Count

Итак все объявления сделаны и мы можем приступить к написанию непосредственно всех объявленных процедур.

Шаг 4. Пишемпроцедурыифункции.

Начнем с написания конструктора. Это делается примерно так:

Code:

constructor TCountBtn.Create(aowner:Tcomponent);

begin

inherited create(Aowner);

end;

Здесь в принципе понимать ничего не надо. Во всех своих компонентах я писал именно это (только класс компонента менял и все). Также сюда можно записывать любые действия, которые вы хотите сделать в самом начале работы компонента, то есть в момент установки компонента на форму. Например можно установить начальное значение нашего свойства Count. Но мы этого делать не будем.

Теперь мы напишем процедуру обработки щелчка мышкой по кнопке:

Code:

procedure Tcountbtn.Click;

begin

inherited click;

FCount:=FCount+1;

end;

"Inherited click" означает, что мы повторяем стандартные методы обработки щелчка мышью (зачем напрягаться и делать лишнюю работу:)).

У нас осталась последняя процедура ShowCount. Она может выглядеть примерно так:

Code:

procedure TCountBtn.ShowCount;

begin

Showmessage('По кнопке '+ caption+' вы сделали: '+inttostr(FCount)+' клик(а/ов)');

end;

Здесь выводится сообщение в котором показывается количество кликов по кнопке (к тому же выводится имя этой кнопки, ну это я добавил только с эстетической целью).

И если вы все поняли и сделали правильно, то у вас должно получится следующее:

Code:

unit CountBtn;

interface

uses

Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,

StdCtrls, ExtCtrls;

type

TCountBtn = class(TButton)

private

{ Private declarations }

FCount:integer;

protected

{ Protected declarations }

procedure Click;override;

public

{ Public declarations }

procedure ShowCount;

published

{ Published declarations }

property Count:integer read FCount write FCount;

constructor Create(aowner:Tcomponent);override;

end;

procedureRegister;

implementation

procedureRegister;

begin

RegisterComponents('Mihan Components', [TCountBtn]);

end;

constructor TCountBtn.Create(aowner:Tcomponent);

begin

inherited create(Aowner);

end;

procedure Tcountbtn.Click;

begin

inherited click;

FCount:=FCount+1;

end;

procedure TCountBtn.ShowCount;

begin

Showmessage('По кнопке '+ caption+' вы сделали: '+inttostr(FCount)+' клик(а/ов)');

end;

end.

Скорее сохраняйтесь, дабы не потерять случайным образом байты набранного кода:)).

Шаг 5. Устанавливаемкомпонент

Если вы сумели написать и понять, все то что здесь предложено, то установка компонента не должна вызвать у вас никаких проблем. Все здесь делается очень просто. В главном меню выберите пункт Component -> Install Component. перед вами открылось диалоговое окно Install Component. В нем вы увидите две закладки: Into exsisting Package и Into new Package. Вам предоставляется выбор установить ваш компонент в уже существующий пакет или в новый пакет соответственно. Мы выберем в уже существующий пакет.

В поле Unit File Name напишите имя вашего сохранненого модуля (естественно необходимо еще и указать путь к нему), а лучше воспользуйтесь кнопкой Browse и выберите ваш файл в открывшемся окне.

В Search Path ничего изменять не нужно, Делфьи сама за вас все туда добавит.

В поле Package File Name выберите имя пакета, в который будет установлен ваш компонент. Мы согласимся с предложенным по умолчанию пакетом.

Теперь нажимаем кнопочку Ok. И тут появиться предупреждение Package dclusr30.dpk will be rebuilt. Continue? Дельфи спрашивает: "Пакет такой-то будет изменен. Продолжить?". Конечно же надо ответить "Да". И если вы все сделали правильно, то появиться сообщение, что ваш компонент установлен. Что ж можно кричать Ура! Это ваш первый компонент.

Созданиесвойствсвоеготипа

Теперь мы попробуем создать свойство нестандартного типа. Рассмотрим это на примере метки - TLabel. У этого компонента есть такое свойство: Alignment. Оно может принимать следующие значения: taLeftJustify, taCenter, taRightJustify. Приступаем к созданию свойства. Ничего интересного мне придумать не удалось, но тем не менее я вам покажу это на примере того свойства, которое я придумал. Оно очень простое и поможет вам разобраться. Свойство будет называться ShowType (тип TShowTp), в нашем компоненте оно будет отвечать за отображение свойства Count. Если пользователь установит свойство ShowType в Normal, то кнопка будет работать, как и работала. А если пользователь присвоит этому свойтсву значение CountToCaption, то количество кликов, будет отображаться на самой кнопке.

Для начале нам необходимо объявить новый тип. Описание типа нужно добавить после слова Type. Вот так это выглядело вначале:

Code:

type

TCountBtn = class(TButton)

Воттакэтодолжновыглядеть:

Code:

type

TShowTp = (Normal, CountToCaption);

TCountBtn = class(TButton)

Здесь мы объявили новый тип TShowTp, который может принимать только два значения. Все значения, которые вы хотите добавить перечисляются через запятую. Теперь нам понадобиться создать поле этого типа. Это мы уже умеем и делать и поэтому не должно вызвать никаких сложностей. В директиву Private напишите:

Code:

FShowType:TShowTp;

Мы создали поле ShowType, типа TShowTp.

Конечно же необходимо добавить это свойство в инспектор объектов:

property ShowType: TshowTp read FshowType write FShowType;

Ну и наконец, чтобы наш компонент реагировал на изменение этого свойства пользователем надо слегка изменить обработчик события OnClick. После небольшой модификации он может иметь примерно такой вид:

Code:

procedure Tcountbtn.Click;

begin

inherited click;

FCount:=Fcount+1;

if ShowType = Normal then

Caption:=Caption;

if ShowType = CountToCaption then

Caption:='Count= '+inttostr(count);

end;

Объясню что произошло. Вначале мы увеличиваем счетчик на единицу. Затем проверяем какое значение имеет свойство ShowType. Если Normal, то ничего не делаем, а если CountToCaption, то в надпись на кнопке выводим количество кликов. Не так уж и сложно как это могло показаться с первого раза.

Имплантируемтаймервкомпонент

Очень часто бывает, что вам необходимо вставить в компонент, какой-нибудь другой компонент, например, таймер. Как обычно будем рассматривать этот процесс на конкретном примере. Сделаем так, что через каждые 10 секунд значение счетчика кликов будет удваиваться. Для этого мы встроим таймер в нашу кнопку. Нам понадобиться сделать несколько несложных шагов.

После раздела uses, где описаны добавленные в программу модули, объявите переменную типа TTimer. Назовем ее Timer. Приведу небольшой участок кода:

Code:

unit CountBtn;

interface

uses

Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,

StdCtrls, ExtCtrls;

var Timer: TTimer;

type

Дальше в директиву Protected необходимо добавить обработчик события OnTimer для нашего таймера. Это делается так:

procedure OnTimer(Sender: TObject);

Поскольку наш таймер это не переменная, а компонент, его тоже надо создать, для этого в конструктор нашей кнопки напишем:

Code:

constructor TCountBtn.Create(aowner:Tcomponent);

begin

inherited create(Aowner);

Timer:=TTimer.Create(self);

Timer.Enabled:=true;

Timer.OnTimer:=OnTimer;

Timer.Interval:=10000;

end;

Здесь создается экземпляр нашего таймера и его свойству Iterval (измеряется в миллисекундах) присваивается значение 10000 (то есть 10 секунд если по простому).

Собственно осталось написать саму процедуру OnTimer. Я сделал это так:

Code:

procedure TCountBtn.OnTimer(Sender: TObject);

begin

FCount:=FCount*2;

end;

Вот примерно то, что у вас должно получиться в конце:

unit CountBtn;

interface

uses

Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,

StdCtrls, ExtCtrls;

var Timer: TTimer;

type

TShowTp = (Normal, CountToCaption);

TCountBtn = class(TButton)

private

{ Private declarations }

FCount:integer;

FShowType:TShowTp;

protected

{ Protected declarations }

procedure OnTimer(Sender: TObject);

procedure Click;override;

public

{ Public declarations }

procedure ShowCount;

published

{ Published declarations }

property Count:integer read FCount write FCount;

constructor Create(aowner:Tcomponent);override;

property ShowType: TshowTp read FshowType write FShowType;

end;

procedureRegister;

implementation

procedureRegister;

begin

RegisterComponents('Mihan Components', [TCountBtn]);

end;

constructor TCountBtn.Create(aowner:Tcomponent);

begin

inherited create(Aowner);

Timer:=TTimer.Create(self);

Timer.Enabled:=false;

Timer.OnTimer:=OnTimer;

Timer.Interval:=1000;

end;

procedure Tcountbtn.Click;

begin

inherited click;

FCount:=Fcount+1;

Timer.Enabled:=true;

if ShowType = Normal then

Caption:=Caption;

if ShowType = CountToCaption then

Caption:='Count= '+inttostr(count);

end;

procedure TCountBtn.ShowCount;

begin

Showmessage('По кнопке '+ caption+' вы сделали: '+inttostr(FCount)+' клик(а/ов)');

end;

procedure TCountBtn.OnTimer(Sender: TObject);

begin

FCount:=FCount*2;

end;

end.

Если у вас что-то не сработало, то в начале проверьте все ли у вас написано правильно. Затем проверьте может у вас не хватает какого-нибудь модуля в разделе Uses.

Переустановкакомпонента

Очень часто бывает необходимо переустановить ваш компонент. Если вы попробуете сделать это путем выбора Component->Install Component, то Дельфи вас честно предупредит о том, что пакет уже содержит модуль с таким именем. Перед вами открывается окно с содержимым пакета. В нем вы должны найти имя вашего компонента и удалить его (либо нажать кнопочку Remove). Теперь в пакете уже нет вашего компонента. Затем проделайте стандартную процедуру по установке компонента.

Редактированиезначения, котороеввелпользователь, изменяякакое-нибудьсвойство.

Простой пример. Допустим у нас есть компонент (основанный на Tedit), у него есть два свойства: FirstNumber и SecondNumber. И у него есть процедура Division, в которой первое число делится на второе и результат присаивается свойству текст нашего компонента. Вот код этого компонента:

Code:

unit DivEdit;

interface

uses

Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,

StdCtrls;

type

TDivEdit = class(Tedit)

private

{ Private declarations }

FFirstNumber:integer;

FSecondNumber:integer;

FResult:Single; //в компонентах нельзя использовать Real!!!

protected

{ Protected declarations }

public

{ Public declarations }

procedure Division;

published

{ Published declarations }

constructor create(aowner:Tcomponent);override;

property FirstNumber:integer read FFirstNumber write FFirstNumber;

property SecondNumber:integer read FSecondNumber write FSecondNumber;

property Result:Single read Fresult write FResult;

end;

procedureRegister;

implementation

Constructor TDivEdit.create(aowner:Tcomponent);

begin

inherited create(aowner);

FFirtsNumber:=1;

FSecondNumber:=1;

end;

procedure TDivEdit.Division;

begin

FResult:=FFirstNumber/FSecondNumber;

text:=floattostr(FResult);

end;

procedureRegister;

begin

RegisterComponents('Mihan Components', [TDivEdit]);

end;

end.

Хочется обратить ваше внимание на то, что в компонентах нельзя использовать переменные и поля типа Real, вместо него нужно брать переменные типов Single, Double, Extended.

Здесь все просто. Но вот если пользователю вздумается поделить на ноль (ну вдруг он математики не знает), то компонент выдаст ошибку DivisionByZero, а кому они нужны. Обойти эту проблему можно так: в код компонента добавить процедуру, которая проанализирует данные введенные пользователь и если все будет в порядке, то она присвоит значения соответствующим свойтсвам. В директиве Private объявите такую процедуру:

Code:

procedure SetSecondNumber(value:integer);

Обычно такие процедуры начинаются с приставки Set, затем идет имя свойства, и в конце тип переменной. Теперь в директиве Published надо сделать небольшие изменения:

Code:

property SecondNumber:integer read FSecondNumber write SetSecondNumber;

А теперь напишем саму процедуру:

Code:

procedure TDivEdit.SetSecondNumber(value:Integer);

begin

if value<>FSecondNumber then//надо проверить совпадают ли исходное и вводимое значения

FSecondNumber:=value; //если нет, то изменить значение

if FSecondNumber=0then

FSecondNumber:=1;

end;

Теперь сколько бы пользователь не вводил нулей значение SecondNumber будет единицей. Такие процедуры проверки рекомендуется использовать везде, где только допустимо появление исключительной ситуации.

Использованиедругогокомпонентаввашем

Попробуем создать такой компонент. Это будет обычная метка (Label), у которой будет две процедуры: ChangeBackColor и ChangeFontColor, которые соответственно будут менять цвет фона метки и цвет текста. Для этого нам понадобиться ColorDialog, который будет создаваться вместе с компонентом, а потом с помощью процедур он будет активироваться. Назовем компонент ColorLabel. Вначале добавим в uses два модуля: Dialogs, StdCtrls (в них находятся описания классаов диалога и метки). Теперь нам надо объявить переменную типа TColorDialog. Объявление идет сразу после секции Uses.

Примерно это выглядит так:

Code:

uses

Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,StdCtrls;

var ColorDialog:TColorDialog;

type

...

Теперь в конструкторе (Create), нам надо создать этот компонент:

Code:

constructor TColorLabel.create(aowner:Tcomponent);

begin

Inherited Create(aowner);

ColorDialog:=TColorDialog.Create(self);

end;

Теперь надо объявить процедуры ChangeBackColor, ChangeFontColor. Чтобы они были доступны пользователю их надо поместить в директиву Public:

Code:

public

{ Public declarations }

procedure ChangeBackColor;

procedure ChangeFontColor;

published

Осталось написать сами процедуры. Все очень просто: открываете диалог методом Execute, а затем присваиваете полученное значение цвета метке. У меня эти процедуры имеют такой вид:

Code:

procedure TColorLabel.ChangeBackColor;

begin

if ColorDialog.Execute then

color:=ColorDialog.color;

end;

procedure TColorLabel.ChangeFontColor;

begin

if ColorDialog.Execute then

font.color:=ColorDialog.color;

end;

Если у вас вдруг что-то не получилось, то взгляните на мой код целиком:

unit ColorLabel;

interface

uses

Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,StdCtrls;

var ColorDialog:TColorDialog;

type

TColorLabel = class(Tlabel)

private

{ Private declarations }

protected

{ Protected declarations }

public

{ Public declarations }

procedure ChangeBackColor;

procedure ChangeFontColor;

published

{ Published declarations }

constructor create(aowner:tcomponent);override;

end;

procedureRegister;

implementation

constructor TColorLabel.create(aowner:Tcomponent);

begin

Inherited Create(aowner);

ColorDialog:=TColorDialog.Create(self);

end;

procedure TColorLabel.ChangeBackColor;

begin

if ColorDialog.Execute then

color:=ColorDialog.color;

end;

procedure TColorLabel.ChangeFontColor;

begin

if ColorDialog.Execute then

font.color:=ColorDialog.color;

end;

procedureRegister;

begin

RegisterComponents('Mihan Components', [TColorLabel]);

end;

end.

Доступксвойствамдругогокомпонента

Сейчас нам предстоит более сложная задача. Мы будем создавать компонент, вместе с которым будет создаваться какой-нибудь визуальный компонент. Например создадим кнопку, которая будет сопровождаться поясняющей надписью сверху. За основу возмем тип TButton. Нам надо будет создать еще и Label. Здесь существует одна проблемка: при перемещении компонента по форме, метка должна двигаться вместе с кнопкой, поэтому нам придется обрабатывать сообщение WmMove. Итак, объявляем переменную Label (в данном примере она объявлена в директиве Private, что тоже допустимо):

Code:

uses

SysUtils, WinTypes, WinProcs, Messages, Classes, Graphics, Controls,

Forms, Dialogs, StdCtrls,buttons;

type

TLabelButton = class(TButton)

private

FLabel : TLabel ;

Теперь я приведу весь код этого компонента и походу буду вставлять необходимые пояснения:

Code:

unit LabelBtn;

interface

uses

SysUtils, WinTypes, WinProcs, Messages, Classes, Graphics, Controls,

Forms, Dialogs, StdCtrls,buttons;

type

TLabelButton = class(TButton)

private

FLabel : TLabel ; {создаем поле типа Tlabel}

procedure WMMove( var Msg : TWMMove ) ; message WM_MOVE ;{процедура для обработки сообщения Wm_move, чтобы метка перемещалась вместе с кнопкой}

protected

procedure SetParent( Value : TWinControl ) ; override ;{необходимо воспользоваться и этой процедурой, так как нужно убедиться, имеют ли кнопка и метка общего предка}

function GetLabelCaption : string ; virtual ; {Вот пример доступа из компонента к свойствам другого. Эти две процедуры для изменения текста метки}

procedure SetLabelCaption( const Value : string ) ; virtual ;

public

constructor Create( AOwner : TComponent ) ; override ;

destructor Destroy ; override ;

published

property LabelCaption : stringread GetLabelCaption write

SetLabelCaption ;

end;

procedureRegister;

implementation

constructor TLabelButton.Create( AOwner : TComponent ) ;

begin

inherited Create( AOwner ) ;

{ создаем TLabel }

FLabel := TLabel.Create( NIL ) ;

FLabel.Caption := 'Описание:' ;

end ;

procedure TLabelButton.SetParent( Value : TWinControl ) ;

begin

{надо убедиться, что у них предок один, чтоб проблем потом не было}

if ( Owner = NIL ) ornot ( csDestroying in Owner.ComponentState ) then

FLabel.Parent := Value ;

inherited SetParent( Value ) ;

end ;

destructor TLabelButton.Destroy ;

begin

if ( FLabel <> NIL ) and ( FLabel.Parent = NIL ) then

FLabel.Free ;{Уничтожаем метку, т.к. она нам больше не нужна}

inherited Destroy ;

end ;

function TLabelButton.GetLabelCaption : string ;

begin

Result := FLabel.Caption ;

end ;

procedure TLabelButton.SetLabelCaption( const Value : string ) ;

begin

FLabel.Caption := Value ;

end ;

procedure TLabelButton.WMMove( var Msg : TWMMove ) ;

begin

inherited ;

if FLabel <> NILthenwith Flabel do

SetBounds( Msg.XPos, Msg.YPos - Height, Width,Height ) ; {изменяем левое и верхнее положение метки исходя из полученных координат}

end;

procedureRegister;

begin

RegisterComponents('Mihan Components', [TLabelButton]);

end;

initialization

RegisterClass( TLabel ) ; {Это делается для обеспечения поточности, но об этом не думайте, этим редко придется пользоваться}

end.{Вы можете пользоваться этим компонентом сколько угодно, но распространять его можно только указывая авторство}

Можно сделать доступ к любым свойствам метки, например, к шрифту, цвету и так далее, используя необходимые процедуры.

Использованиевкачествепредкакласс TWinControl

Предыдущий пример был очень сложным, к тому же пришлось обрабатывать системные сообщения. Есть другое решение этой проблемы, более простое для понимания и для реализации: использовать в качестве контейнера класс TWinControl и в этот контейнер помещать другие компоненты. Теперь попробуем совместить Edit и Label. Давайте вместе создадим такой компонент. В качестве предка нужно выбрать класс TWinControl, а в качестве типа вашего компонента выберите TlabelEdit. Будем разбирать код по кусочкам.

Code:

unit LabelEdit;

interface

uses

SysUtils, WinTypes, WinProcs, Messages, Classes, Graphics, Controls,

Forms, Dialogs, stdctrls;

type

TLabelEdit = class(TWinControl)

private

{ Private declarations }

FEdit: TEdit;

FLabel: TLabel;

//Здесь объявляются поля для метки и для Edita.

function GetLabelCaption: string;

procedure SetLabelCaption(LabelCaption: string);

function GetEditText: string;

procedure SetEditText(EditText: string);

//Здесь объявлены функции для работы со свойствами Caption у метки и Text у Edita.

protected

{ Protected declarations }

public

{ Public declarations }constructor Create(AOwner: TComponent); override; published

property LabelCaption: stringread GetLabelCaption write SetLabelCaption;

property EditText: stringread GetEditText write SetEditText;

{ Published declarations }

end;

procedureRegister;

implementation

constructor TLabelEdit.Create(AOwner: TComponent);

begin

inherited Create(AOwner);

FEdit := TEdit.Create(self);{создаем поле редактирования Edit}

FLabel := TLabel.Create(self);{создаем Label}

with FLabel dobegin

Width := FEdit.Width;

visible := true;

Parent := self;

Caption := 'Описание:';

end;

with FEdit dobegin

Top := FLabel.Height+2;

Parent := self;

Visible := true;

end;

Top := 0;

Left := 0;

Width := FEdit.Width;

Height := FEdit.Height+FLabel.Height;{определяются размеры и положение компонентов}

Visible := true;

end;

function TLabelEdit.GetLabelCaption: string;

begin

Result := FLabel.Caption;

end;

procedure TLabelEdit.SetLabelCaption(LabelCaption: string);

begin

FLabel.Caption := LabelCaption;

end;

function TLabelEdit.GetEditText: string;

begin

Result := FEdit.Text;

end;

procedure TLabelEdit.SetEditText(EditText: string);

begin

FEdit.Text := EditText;

end;

procedureRegister;

begin

RegisterComponents('Mihan Components', [TLabelEdit]);

end;

end.

Попробуйте установить этот компонент. Когда вы будете размещать его на форме, то будет виден "контейнер", на котором располагаются Edit и Label. Использование в качестве предка компонента класса TWinControl, очень удобно если вы хотите объединить несколько визуальных компонентов.

Обработкасобытий OnMouseDown, OnMouseMove и OnMouseUp

Часто возникает необходимость обработки событий нажатия и отпускания кнопки в вашем компоненте. Сейчас мы это и рассмотрим. Только ради примера сделаем компонент, который будет считать количество нажатий и отпусканий кнопки в его области, допустим это будет панель (Tpanel). Для этого в директиве Private надо объявить следующие процедуры и поля:

Code:

FClickCount:integer;

FUpCount:integer;

procedure MouseDown(Button:TMouseButton; Shift: TShiftState; X,Y: Integer); override;

procedure MouseMove(Shift: TShiftState; X, Y: Integer); override;

procedure MouseUp(Button:TMouseButton; Shift:TShiftState; X, Y: Integer); override;

А в директиве Published надо написать:

Code:

constructor create(aowner:tcomponent);override;

property ClickCount:integer read FclickCount write FClickCount;

property UpCount:integer read FUpCount write FUpCount;

property OnMouseDown;

property OnMouseMove;

property OnMouseUp;

Ну и теперь осталось описать нужные процедуры:

Code:

procedure TMpanel.MouseDown(Button:TMouseButton; Shift: TShiftState; X,Y: Integer);

begin

FClickCount:=FClickCount+1;

end;

procedure TMpanel.MouseMove(Shift: TShiftState; X, Y: Integer);

begin

caption:=inttostr(x)+' '+inttostr(y);{для демонстрации работы этой процедуры. Надпись на панели будет отражать координаты курсора мыши над этой панелью}

end;

procedure TMpanel.MouseUp(Button:TMouseButton; Shift:TShiftState; X, Y: Integer);

begin

FUpCount:=FUpCount+1;

end;

Таким образом весь код компонента был таким:

Code:

unit Mpanel;

interface

uses

Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,

ExtCtrls;

type

TMpanel = class(TPanel)

private

{ Private declarations }

FClickCount:integer;

FUpCount:integer;

procedure MouseDown(Button:TMouseButton; Shift: TShiftState; X,Y: Integer); override;

procedure MouseMove(Shift: TShiftState; X, Y: Integer); override;

procedure MouseUp(Button:TMouseButton; Shift:TShiftState; X, Y: Integer); override;

protected

{ Protected declarations }

public

{ Public declarations }

published

{ Published declarations }

constructor create(aowner:tcomponent);override;

property ClickCount:integer read FclickCount write FClickCount;

property UpCount:integer read FUpCount write FUpCount;

property OnMouseDown;

property OnMouseMove;

property OnMouseUp;

end;

procedureRegister;

implementation

constructor TMpanel.create(aowner:Tcomponent);

begin

inherited create(aowner);

end;

procedure TMpanel.MouseDown(Button:TMouseButton; Shift: TShiftState; X,Y: Integer);

begin

FClickCount:=FClickCount+1;

end;

procedure TMpanel.MouseMove(Shift: TShiftState; X, Y: Integer);

begin

caption:=inttostr(x)+' '+inttostr(y);

end;

procedure TMpanel.MouseUp(Button:TMouseButton; Shift:TShiftState; X, Y: Integer);

begin

FUpCount:=FUpCount+1;

end;

procedureRegister;

begin

RegisterComponents('Mihan Components', [TMpanel]);

end;

end.

Созданиеииспользованиесвоейиконкидлякомпонента

Когда вы создали свой компонент и установили его, та на палитре компонентов, его иконка будет такой же как и у компонента, который вы выбрали в качестве предка. Конечно же вам хотелось бы видеть свой компонент со своей иконкой. Для этого необходимо создать файл ресурсов компонента. Сейчас я расскажу вам как это делается.

Откройте Image Editor (Tools->Image Editor) и выберите File->New->Component Resourse File. Перед вами появится небольшое окно с надписью Untitled.dcr в нем будет только одно слово: Contents. Нажмите на него правой кнопкой и в появившемся меню выберите New->Bitmap. Откроется диалоговое окно для настройки параметров изображения. Они должны быть такими: Размер 32x32, цветовой режим VGA (16 colors). Теперь нажмите ok. Теперь надо нажать правой кнопкой на появившейся надписи Bitmap1 и выбрать пункт Rename. Название картинки должно совпадать с названием класса компонента, для которого вы делаете эту иконку (например, TMPanel). Нажмите два раза на Bitmap1 и перед вами появится окно для рисования. Нарисуйте, что вам надо и перейдите на окно с надписью Untitled.dcr и в меню File выберите Save. Имя файла ресурса компонента должно совпадать с именем модуля компонента (без расширения конечно же, например, Mpanel). Файл ресурса готов. Теперь установите ваш компонент заново и в палитре компонентов ваш компонент будет уже с новой иконкой.

Источник: https://delphid.dax

Создание компонент в Delphi

2013-08-19T13:33:48+07:00

Перед созданием своего компонента нужно выбрать для него предка. Кто же может быть предком для вашего компонента? Как правило, используются в виде предков TComponent, TControl, TWinControl, TGraphicControl, TCustomXXXXXX, а также все компоненты палитры компонентов. Возьмем для примера компонент TOpenDialog, который находится на странице Dialogs палитры компонентов. Он хорошо справляется со своей задачей, но у него есть одно маленькое неудобство. Каждый раз, когда его используешь необходимо каждый раз изменять значение свойства Options. И причем это, как правило, одни и те же действия.

Code:

OpenDialog1.Options := OpenDialog1.Options + [ofFileMustExist, ofPathMustExist];

чтобы файл, который мы пытаемся открыть с помощью этого диалогового окна, действительно существовал на диске.
Задание для себя мы уже выбрали, осталось за малым - создать компонент. Заготовку для компонента создаем, выбирая из меню команду Component/New Component... и в диалоговом окне выбираем
Ancestor type: TOpenDialog
Class Name: TOurOpenDialog
Palette Page: Our Test
Нажали Ok и у нас появился шаблон нашего будущего компонента.

Переопределяем конструктор у этого компонента, т.е. в секции public вставляем строку:

Code:

constructor Create(AOwner: TComponent); override;

нажатие на этой строке Ctrl + Shift + C создает шаблон для этого метода, внутри которого мы вставляем такие строки:

Code:

inherited Create(AOwner); {Вызываем унаследованный конструктор}

Options := Options + [ofFileMustExist, ofPathMustExist]; {Выполняем необходимые нам действия}

Обратите внимание: Комбинации клавиш Ctrl + Shift + стрелки вверх/вниз позволяют перемещаться между объявлением метода и его реализацией.

Установка созданного компонента Component/Install Component...
Install Into New Package
Package file name: C:\Program Files\Borland\Delphi4\Lib\OurTest.dpk
Package description: Our tested package

Вам не нравится, что у нашего компонента иконка такая же как у стандартного? Тогда создадим для него свою собственную. Для этого нам необходимо вызвать Tools/Image Editor. Создаем новый *.dcr файл.
Вставляем в него рисунок Resource/New/Bitmap. Устанавливаем размер картинки 24x24 точек. А дальше - ваше творчество... Обратите внимание: цвет точек, совпадающий с цветом точки в левом нижнем углу рисунка, будет считаться ПРОЗРАЧНЫМ! После того как вы создали свой рисунок, переименуйте его из Bitmap1 в TOurOpenDialog и сохраните файл с именем OurOpenDialog.dcr. Удалите компонент из пакета и установите его снова (только в этом случае добавится и ссылка на *.dcr файл). Compile, Install и удачи!

Code:

{======================================================}

unit OurOpenDialog;

interface

uses

Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs;

type

TOurOpenDialog = class(TOpenDialog)

private

{ Private declarations }

protected

{ Protected declarations }

public

{ Public declarations }

constructor Create(AOwner: TComponent); override;

published

{ Published declarations }

end;

procedure register;

implementation

procedure register;

begin

RegisterComponents('Samples', [TOurOpenDialog]);

end;

{ TOurOpenDialog }

constructor TOurOpenDialog.Create(AOwner: TComponent);

begin

inherited Create(AOwner); {Вызываем

унаследованный конструктор}

Options := Options + [ofFileMustExist, ofPathMustExist];

{Выполняем необходимые нам действия}

end;

end.

Объявление компонента состоит из секций, таких как private, protected, public и published. Что они означают?
Это директивы видимости. Все что объявлено в секции private, доступно только внутри модуля в котором объявлен класс (приватные объявления). Здесь как правило объявляются переменные, в которых хранятся значения свойств, а также методы (процедуры или функции) доступа к ним. Все что объявлено в секции protected, доступно как и в секции private, а также наследникам данного класса (интерфейс разработчика). Здесь можно объявить методы доступа к значениям свойств (если вы хотите позволить изменять эти методы потомкам вашего компенента),
а также свойства, методы и события (методы реакции на события) в компонентах типа TCustomXXX.
Все что объявлено в секции public, доступно любому пользователю компонента (интерфейс этапа выполнения).
Здесь объявляются, как правило методы. В секции published можно объявлять только свойства и события (они объявляются в виде свойств). Они доступны во время проектирования приложения (интерфейс этапа проектирования).

Свойства

Свойства типа масив - обычные массива Object Pascal, но в отличии от последних могут индексироваться не только числовыми значениями но и строковыми. К сожалению этот тип свойства требует пользовательского редактора свойств (в инспекторе объектов редактор свойства имеет кнопку с тремя точками [...]), по-этому в указанном ниже примере свойство ArrayProp объявлено в секции public.

Code:

type

TOurComponent = class(TComponent)

private

{ Private declarations }

FArrayProp: array[0..9] of integer;

function GetArrayProp(aIndex: integer): integer;

procedure SetArrayProp(aIndex: integer; const

Value: integer);

protected

{ Protected declarations }

public

{ Public declarations }

property ArrayProp[aIndex: integer]: integer read

GetArrayProp

write SetArrayProp;

published

{ Published declarations }

end;

Спецификаторысвойств

Спецификаторdefaultуказываетсохранятьзначениесвойствавфайлеформыилинет. Еслизначениесвойствасовпадаетсозначениемdefault - значениевфайлеформынесохраняется, еслизначениянеравны - сохраняется. Этоможнопроверить, положивкомпонентнаформуивыбратьправойкнопкоймышипунктменю "View as Text". Defaultнеустанавливаетпервоначальноезначениесвойствакуказанному. Этонеобходимосделатьвконструкторекомпонента.

Code:

unit OurComponent;

interface

uses Windows, SysUtils, Classes, Graphics, Forms, Controls;

type

TOurComponent = class(TComponent)

private

{ Private declarations }

FMyInteger: Integer;

protected

{ Protected declarations }

public

{ Public declarations }

constructor Create(AOwner: TComponent); override;

published

{ Published declarations }

property MyInteger: Integer read FMyInteger

write FMyInteger default10;

end;

implementation

constructor TOurComponent.Create(AOwner: TComponent);

begin

inherited Create(AOwner);

FInteger := 10;

end;

end.

Спецификатор nodefault отменяет заданное по умолчанию значение свойства. Этот спецификатор, как правило, используется для отмены заданого по умолчанию значения унаследованного свойства.

Например:

Code:

property AutoSize nodefault;

Спецификатор stored указывает когда сохранять в файле формы значение свойства. После stored может стоять true (всегда сохранять), false (никогда не сохранять) или название функции, которая возвращает логический результат.

Code:

property OneProp: integer read FOneProp

write

SetOneProp

stored False;

property TwoProp: integer read FTwoProp

write

SetTwoProp

stored True;

property ThreeProp: integer read FThreeProp

write SetThreeProp

stored Fuct;

Автор: АлександрВасилевский
Источник: https://alvas.hypermart

Self

2013-08-19T16:51:50+07:00

Self - это явное задание экземпляра класса в его методе.

Например для твоей формы это указание на саму форму:

Code:

procedure TForm1.Button1Click(Sender: TObject);

begin

showmessage(self.classname+#13#10+self.name);

end;

Если например это MDI форма то это будет указатель именно на тот экземпляр для которого выполняется этот код. На практике Self обычно применяется при написании своих классов, когда ты пишешь класс или компонент, то у тебя нет переменной с экземпляром этого компонента, следовательно чтобы обратится к экземпляру (который появится только в коде конечного пользователя, который будет использовать компонент) класса нужна переменная - вот она и берётся за self.

Автор:Vit

Взято с Vingrad.ruhttps://forum.vingrad

Чтобы понять, что такое self надо понять что такое метод класса. Метод класса - это просто функция(процедура) который имеет дополнительный неявный параметр - указатель на экземпляр класса. То есть:

Code:

TMy=class

x:integer;

procedure Proc(val:integer);

end;

procedure TMy.Proc(val:integer);

begin

x:=val;

end;

После компиляции это будет практически то же самое, что:

Code:

procedure Proc(self:TMy;val:integer);

begin

self.x:=val;

end;

То есть на самом деле в методе Proc обращаясь к x мы на самом деле обращаемся к self.x, просто переменная self опускается. В откомпилированном коде нет такого понятия как классы - есть только код и память. Все методы классов превращаются в обыкновенные функции, в которым качестве первого параметра передается указатель на область памяти где лежит созданный пользователем экземпляр класса, который они и используют для чтения или записи(а так же для вызова) того, что мы называем членами класса.

Code:

var

m1,m2:TMy;

begin

.....

m1.Proc(4); // -> Proc(m1,4)

m2.Proc(4); // -> Proc(m2,4)

end;

Автор:Fantasist

Взято с Vingradruhttps://forum.vingrad

В чем отличие между Create(Self) и Create(Application)?

2013-08-19T16:52:46+07:00

Self может быть использовано только в методе класса, и ссылается на текущий экземпляр класса. Таким образом "Self" в методе класса TForm1 ссылается на текущий экземпляр TForm1. При создании компонента Вы передаете его владельца (owner) в конструктор. При уничтожении формы или компонента автоматически уничтожаются и все компоненты владельцем которого она является. Таким образом если при создании формы передать в качестве владельца Application эта форма будет автоматически уничтожена при уничтожении Application. Если же при создании формы передать в качестве владельца другую форму, вновь созданная форма будет автоматически уничтоженна при уничтожении формы-владельца.

Работа с Sender

2013-08-19T16:59:11+07:00

Code:

unit TestInputForm;

interface

uses

Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,

StdCtrls, DdhInpuB;

type

TForm1 = class(TForm)

Edit1: TEdit;

Label1: TLabel;

DdhInputButton1: TDdhInputButton;

DdhInputButton2: TDdhInputButton;

DdhInputButton3: TDdhInputButton;

procedure DdhInputButtonClick(Sender: TObject);

private

{ Private declarations }

public

{ Public declarations }

end;

var

Form1: TForm1;

implementation

{$R *.DFM}

procedure TForm1.DdhInputButtonClick(Sender: TObject);

begin

ShowMessage ('You have clicked the ' +

(Sender as TButton).Name + ','#13 +

'having the caption ' +

(Sender as TButton).Caption);

end;

end.

Взято с https://delphiworld.narod

Как получить список всех назначенных событий?

2013-08-19T16:48:56+07:00

Code:

uses TypInfo;

{ .... }

procedure TForm1.Button1Click(Sender: TObject);

var

x, y, z: Word;

pl: PPropList;

begin

y := GetPropList(Self, pl);

for x := 0to y - 1do

begin

if Copy(pl[x].Name, 1, 2) <> 'On'then Continue;

if GetMethodProp(Self, pl[x].Name).Code <> nilthen

Memo1.Lines.Add(Self.Name + ' - ' + pl[x].Name);

end;

for z := 0to Self.ComponentCount - 1do

begin

y := GetPropList(Self.Components[z], pl);

for x := 0to y - 1do

begin

if Copy(pl[x].Name, 1, 2) <> 'On'then Continue;

if GetMethodProp(Self.Components[z], pl[x].Name).Code <> nilthen

Memo1.Lines.Add(Self.Components[z].Name + ' - ' + pl[x].Name);

end;

Взято с сайтаhttps://www.swissdelphicenter.ch/en/tipsindex

Как присвоить событие в run-time?

2013-08-19T16:47:55+07:00

Пример стандартного присвоения события в run-time:

Code:

type

{©Drkb v.3(2007): www.drkb.ru,

®Vit (Vitaly Nevzorov) - nevzorov@yahoo.com}

TForm1 = class(TForm)

Button1: TButton;

procedure FormCreate(Sender: TObject);

private

procedure Click(Sender: TObject);

end;

var Form1: TForm1;

implementation

procedure TForm1.Click(Sender: TObject);

begin

// do something

end;

procedure TForm1.FormCreate(Sender: TObject);

begin

button1.OnClick:=Click;

end;

end.

Автор:Vit

Взято с Vingradruhttps://forum.vingrad

Введение

2013-08-15T20:27:20+07:00

Объектно-ориентированное программирование (ООП)

Объекты – это крупнейшее достижение в современной технологии программирования. Смеем утверждать, что изобретение и практическая реализация объектов являются подвигом человеческого гения. Это не пустые слова: объекты позволили строить программу не из чудовищных по сложности процедур и функций, а из кирпичиков-объектов, заранее наделенных нужными свойствами. Самое приятное в этом то, что внутренняя сложность объектов скрыта от программиста, он просто пользуется готовым строительным материалом.

Сейчас преимущества использования объектов очевидны для всех. Однако так было всегда. Сначала старая гвардия не поняла и не приняла объекты, поэтому они почти лет потихоньку развивались в различных языках, первыми из которых были Simula 67 и Smalltalk 72. Постепенно объектно-ориентированный подход нашел себе место и в более мощных языках: С++, Turbo Pascal 6.0/7.0, Modula, ADA и множестве других. Блестящим примером реализации объектов была библиотека Turbo Vision, предназначенная для построения пользовательского интерфейса DOS-программ.

Полную победу объекты одержали после воцарения Windows: теперь без них в программировании просто не обойтись. Delphi – не исключение, она в своей основе является объектно-ориентированной и говорить о программировании без объектов про бессмысленно. Чтобы вы не рылись в других книгах, собирая информацию по крохам, мы не поленились и собрали в этой главе все, что нужно знать об объектах Delphi. Для новичка важнейшее здесь: инкапсуляция, наследование, полиморфизм, остальное можно просто просмотреть и возвращаться к материалу по мере накопления опыта. Профессионалу полезно прочитать внимательно все от начала до конца. Так что давайте засучим рукава и приступим к делу.

Игра отражений

2013-08-15T20:40:50+07:00

Автор: Владимир Волосенков

Музыку любите, а на инструменте неприличное слово нацарапали.

"Республика ШКИД"

Данный материал является независимым дополнением/исправлением к статье Дмитрия Логинова "ЯП, ОПП и т.д. и т.п. в свете безопасности программирования". Поводом к написанию явилось наличие в исходном материале множества неточностей и откровенно ложных сведений, вводящих в заблуждение неподготовленного читателя.

Условно материал Дмитрия можно разделить на две части: историческую и непосредственно техническую. По исторической части у меня вопросов нет, и прочитал я ее с большим интересом. Целью данного материала является внесение ясности по техническим вопросам в меру моих скромных знаний.

Исходный текст я буду приводить курсивом. Т.к. в статье в основном сравнивается C++ и Delphi, то вместо Pascal или Object Pascal будет использоваться сокращение ОР. Т.к. автор в своем повествовании не ограничивался сравнением только безопасности программирования в С++ и ОР, то я также позволю себе сравнения по всем аспектам. Конечно, только в рамках технических фактов.

Кроме того, в скобках иногда будут встречаться комментарии за подписью КоТ. Это замечания одного непрофессионального программиста по поводу моих и Дмитрия размышлений. Пишет он в С++ и исключительно под Linux, называет себя не иначе, как глупым ламером. Впрочем, исходя хотя бы из того, что обычно настоящие ламеры себя таковыми не считают, его высказывания весьма интересны и часто к месту. Итак, приступим.

Сразу замечу, что размер страницы памяти для процессоров Intel и MIPS составляет 4К, а для Alpha - 8K (а не 2 и 4К соответственно).

Начнем с принципиальных отличий в модели обработки исключений в С++ от Делфи. И какие это порождает гадости (КоТ: почему именно гадости?). В первую очередь, Борланд ввел некоторые ограничения на перегенерацию собственных исключений. Вырезка из Help:

1) You cannot rethrow an operating system exception once the catch frame has been exited and have it be caught by intervening VCL catch frames.

2) You cannot rethrow an operating system exception once the catch frame has been exited and have it be caught by intervening operating system catch frames.

3) You cannot use "throw"(аналог Делфийского raise) to reraise an exception that was caught within VCL code.

Приведенная автором вырезка в Delphi Help отсутствует. Да и с какой стати там будет указываться ключевое слово "throw" из С++? Более всего это похоже на вырезку из хелпа C++ Builder. Соответственно и ограничения на работу с более мощной моделью исключений ОР, используемой в VCL (доказательства будут ниже). Выводы делаем сами…

Рассматривая модель ООП в Делфях и модель ООП в С++, легко прийти к выводу, что функционально модель С++ шире, и поэтому Борландовский Буилдер легко "глотает" делфийский VCL.

Используя модель ООП С++, создать, к примеру, среду Delphi или библиотеку VCL невозможно в принципе (если не касаться разработки новых компиляторов). Это было неоднократно доказано в дискуссиях с другими фанатами С++. Как ограничения выступают отсутствие классовых ссылок, виртуальных конструкторов и ущербная модель RTTI в С++. Не буду утверждать, как работает C++ Builder, но подозреваю, что ключевые моменты работы среды с компонентами написаны на ОР.

Думаю, если бы С++ позволял написать VCL, то Delphi пришлось бы сейчас "глотать" чужой код. Но пока все наоборот. Кстати, Borland имела прекрасную возможность пересмотреть свои воззрения на языковую основу VCL при разработке Kylix (этот проект включает и ОР и С++). Однако революции не произошло. Революция уже случилась в 95-м году с выходом Delphi 1 :)

В С++ классы могут находиться в любой памяти, из перечисленных выше трех [статическая, стек, динамическая].

(КоТ: Никакого плюса не вижу, говорю как С++ - программер. Мало геморроя с распределением динамической памяти, так еще и со всеми другими. Из-за этого я на линух от доса перешел - кстати. И вообще, на мой (ламерский) взгляд, распределение памяти - вопрос не к языку, а к мемори-модели операционной системы.)

В Делфи классы (объекты) могут располагаться только в динамической памяти

Что, безусловно, добавляет той самой безопасности программирования. К примеру, функция может вернуть ссылку на объект в стеке, который уже уничтожен. (КоТ: такие ошибки у меня часто были в досовском паскале. Именно тогда я привык инициализировать все переменные в процессе декларирования.) Если Дмитрий интересовался вопросами сборки мусора, то не мне ему объяснять, что сделать это в одной динамической памяти куда легче.

Из этого вытекает следующее отличие. Все конструкторы и деструкторы классов Паскаля вызываются явно.

object := TMyObject.Create. // где-то в начале

//....

object.Free; // где-то в конце

С одной стороны хорошо. Все ясно, как никогда. Но это специфика Паскаля заставляет программера делать уйму работы, и порой ошибаться (КоТ: а что, С++ прямо так вот и гарантирует безошибочность?) Частенько бывает необходимо иметь "неявный" вызов или конструктор "по умолчанию". Конструктор класса С++, например, вызывается как только встречается описание экземпляра (переменной) класса. И, соответственно, деструктор вызовется, как только класс "выйдет из области видимости".

(КоТ: опять подмена терминов. Т.е. банально нечестная игра. Справедливей, имхо, сказать, что в определенных задачах приходится не надеяться на механизм порождения классов дельфы. Но ведь и в С++ есть точно такие же ситуации - где-то ты можешь положиться на язык (компилятор), где-то - не можешь. Так в чем же преимущество?)

Не нужно преувеличивать количество работы программера. Вызвать конструктор и деструктор совсем не сложно. К тому же, компоненты на форме, например, создаются и уничтожаются автоматически, что очень облегчает жизнь новичкам. При уничтожении компонента ссылка на него в обязательном порядке обнуляется компонентом-владельцем.

А что касается области видимости класса и времени жизни, то это элементарно организуется использованием интерфейсов. Всю работу по подсчету количества ссылок и автоматическому менеджменту памяти возьмет на себя Delphi. (КоТ: кстати, в том же С++ такой же механизм я сам организовывал часов за восемь. Не скажу, что просто и легко, но возможно. Минус - лишний геморрой, плюс - можешь сделать сам, какой нужно, с точностью до битовых полей и регистров.) В Delphi этот механизм также может быть легко реализован по-своему.

К тому же, такая форма конструирования имеет под собой четкую логическую основу. Она напрямую ориентированна на использование классовых ссылок, когда вместо статического указания типа (TMyObject) используется переменная типа "тип класса":

TComponentClass = class of TComponent; //ссылка на класс

Code:

function CreateAny(AType: TComponentClass): TComponent;

begin

Result := AType.Create(nil);

end;

…

Form1.InsertComponent(CreateAny(TButton));

// Создали кнопку

Form1.InsertComponent(CreateAny(Edit1.ClassType));

// Создали еще одно поле редактирования

Скажем прямо, такие решения в С++ недоступны. В качестве лирического отступления можно сказать, что именно на этом основана работа Delphi IDE с любым компонентом.

Вас не удивляло, что Delphi способна не то что без перекомпиляции, а даже без перезапуска брать внешние, абсолютно не знакомые ей классы (компоненты, которые можно инсталлировать хоть каждые 5 минут, тип которых, конечно, неизвестен) и строить на их основе другие классы (формы и т.д.) в run-time (для разработчика design-time)?

(КоТ: круто, конечно)

Очень занимательный вопрос, скажу я вам. Прикиньте, как бы вы реализовали это в своем приложении. Механизм должен быть очень универсальным, работающим для любого компонента. Компоненты поставляются, например, в виде DLL (или packages - разновидность DLL). Тут никакая RTTI в чистом виде не поможет. Применительно к этой задаче даже шаблоны С++ абсолютно бесполезны, т.к. они являются механизмом compile-time only.

Секрет заключается в механизме классовых ссылок, которые фактически являются ссылками на VMT класса. Классовые ссылки регистрируются в пакетах с помощью процедуры Register. Ну и без виртуальных конструкторов, конечно, здесь тоже каши не сваришь.

Ну теперь самое интересное - динамическая память. Тут еще проще - у указателей конструкторов и деструкторов нет. Но, повторюсь, это у встроенных типов. Чтобы вызвать конструктор у указателя надо воспользоваться оператором new. В случае же удаления - оператором delete.

TComplex* c; // переменная указатель на тип TComplex - ниче не вызывается.

(КоТ: ну кто же в софтине будет САМ создавать указатель на пустое место? Зачем? Чтобы stack error'ом по хоботу получить? Объявил переменную - инициализируй!!! Вот так:

TСomplex* c=new TComplex(1,1)

// "а будешь делать не так, надеру уши" (с) Зеф, "Обитаемый остров")

c = new TComplex(1,1); // выделяется память под TComplex и вызывается его конструктор с параметрами.

delete c; // освобождаем память предварительно вызвав деструктор Tcomplex

Вот здесь работа с классами похожа на Делфийскую работу. Похожа-то, похожа - да не совсем.

. (КоТ: на CENSORED похожа, да и работы я здесь не вижу что-то.)

Во-первых: как вы успели заметить new и delete - это операторы. Значит их можно переопределять (КоТ: кстати, НЕ ВСЯКИЙ оператор С++ переопределяется). Значит, где захочу - там и будут лежать мои классы. Так можно организовать несколько куч, даже не имея "много-кучевого" менеджера ОС. Я позже опишу, как это влияет на безопасность

Странно, но Дмитрию не известно, что управление памятью классов в ОР реализовано даже не с помощью операторов, а гораздо красивее - на уровне TObject, виртуальными (!) методами NewInstance и FreeInstance. Таким образом, абсолютно ЛЮБОЙ класс может переопределить эти методы для осуществления желания "где хочу - там и буду лежать". Соответственно организуется и "многокучность".

Во-вторых: здесь всплывает понятие "ВРЕМЯ ЖИЗНИ КЛАССА" и то, как обрабатываются исключения в конструкторах и деструкторах. Рассмотрим это поближе. В Делфи время жизни класса таково:

Рождение: Класс начинает свое существование сразу ПОСЛЕ окончания работы КОНСТРУКТОРА(вызов AfterConstruction).

Смерть: Класс заканчивает свое существование сразу ПОСЛЕ окончания работы ДЕСТРУКТОРА(вызов BeforeDestruction).

Неправильно. Before он на то и Before, чтобы отрабатывать ДО вызова деструктора. И это вовсе не значит, что класс уже уничтожен. Для справки: BeforeDestruction введен для того, чтобы создатель класса был уверен, что необходимые действия перед его уничтожением будут выполнены всегда, независимо от того, вызовут или нет его потомки унаследованный деструктор. По поводу AfterConstruction разговор будет чуть позже.

Кроме того, и конструкторы и деструкторы в ОР имеют приятную особенность (и далеко не одну). Они могут вызываться как обычные методы. Для этого в них передается неявный параметр. Не путать с неявным Self или this. Кстати, Self в классовых методах ОР является классовой ссылкой, а не объектной.

Так что вопросы рождения и смерти в ОР далеко не так тривиальны. Впрочем, самые интересные подробности еще впереди.

В С++ немножечко по другому:

Рождение: Сразу ПЕРЕД телом конструктора.

Смерть: Сразу ПОСЛЕ тела деструктора.

Это несколько меняет работу с конструкторами/деструкторами родителями и конструкторами/деструкторами членами. Вот С++:

class TChild : public TMama,TPapa{ // :o)

TMemberOne member_1_;

TMembarTwo member_2_;

public:

TChild() { cout<<"TChild created!"; }

}

Порядок конструкторов будет следующий: TMama, TPapa, TMemberOne, TMemberTwo и только потом вызовется ТЕЛО конструктора TChild. Это логично и похоже на правду. (КоТ: немножко беременной быть можно? Это похоже на правду, или это правда? Разницу чувствуете?) Действительно, когда мы можем получить доступ к методам и полям(переменным класса) родителей и классов-членов(конкретных классов)? Мы можем получить этот доступ только, когда они сконструированы. И это лучше оставить на совести компилятора, чем надеяться на программера.

Вообще типичной идеологией компилятора С++ считается: "Ну, парень, если ты хочешь сделать именно так, делай, а я умываю руки". А тут такая удивительная забота о программере! Только вот она в данном случае совсем не к месту, по крайней мере, в таком виде. Как контраст - конструкторы ОР.

Допустим, у нас есть иерархия классов A -> B -> C. Мы конструируем класс С. Действительно, в С++ последовательность конструирования будет A -> B -> C. И никак иначе.

Теперь признайтесь, когда вы пишите конструктор в ОР, вы ведь первым делом указываете вызов inherited. Да? В этом случае последовательность конструирования абсолютно аналогична. Но! Стоит вам убрать inherited, и Delphi будет конструировать класс C в последовательности C -> B -> A. Неплохо для начала, но это еще цветочки.

Незаметное inherited дает вам полный контроль над тем КАК, КОГДА и КАКИЕ конструкторы будут вызываться (и будут ли вызываться вообще, ведь inherited можно и в if засунуть). Нет никаких ограничений на расположение inherited в теле конструктора. А ведь его еще можно дополнить именем конкретного конструктора предка с указанием нужных параметров. Ну и, конечно, можно вызывать собственные конструкторы. (КоТ: это здорово, однако).

Таким образом, сначала, например, может отработать часть конструктора С, затем конструкторы предков, затем оставшаяся часть конструктора С. Для чего все это?

Прозаический пример. В конструкторе С создается некоторый объект (аллокатор памяти, например), который используется для работы в конструкторе предка B. Другой наследник, класс D, может создавать совершенно другой объект. Создание этого объекта можно вынести в виртуальную функцию, которую вызывать перед inherited.

Да, такие возможности используются не слишком часто, но им есть реальное применение. Показательно, что подобный подход нереализуем в С++ никакими способами. Он никогда не даст создать что-то ПЕРЕД работой конструктора предка.

(КоТ: сорри, сир! Переопределив new под это дело (кстати, одно из упражнений в каком-то С++-учебнике), вполне возможно и вызвать. Только потом приходится delete лечить - он-то базируется на стандартных умолчаниях. То есть, данных объекта нет, и объекту адрес не выделен, но VMT его есть. В библиотеке или там где еще, не суть. И к этой VMT можно добраться через разную там… гм… CENSORED Плюс дельфы в откровенности доступа ко всем VMT проекта, независимо, созданы ли объекты соответствующих классов).

Как правило, на этом месте фанаты С++ начинают кричать, что это де нелогично, так быть не должно… Но на самом деле нет ничего плохого в том, что конструктор использует в своей работе виртуальные принципы. Никто не утверждает, что экземпляр станет объектом С или В раньше, чем он станет объектом А. Конструкторы всего лишь выполняют свою работу, не важно в каком порядке.

(КоТ: От слабости кричать. Т.к. это, безусловно, бонус дельфе перед С++, но и С++-модель определенные преимущества все-таки имеет).

Более того, вызов указанной виртуальной функции совершенно бесполезен. Почему? В С++ при работе каждого из конструкторов A, B, C таблица виртуальных методов VMT будет соответствовать именно тому классу, к которому принадлежит конструктор. Т.е. вызов ЛЮБЫХ виртуальных методов в конструкторе С++ теряет всякий смысл, т.к. не является виртуальным (будет вызван соответствующий метод для класса А или В, а не для С). То же касается и деструкторов С++.

В ОР при работе любого из конструкторов предков VMT всегда соответствует РЕАЛЬНОМУ создаваемому классу, т.е. классу С. Вызовы виртуальных методов будут правильными. В принципе, это может создать опасную ситуацию, когда в данном виртуальном методе какой-то из наследников подразумевает, что класс уже полностью сконструирован. Именно для разрешения этой проблемы и существует виртуальный метод AfterConstruction.

Теперь мы четко видим, что конструкторы ОР обладают НАМНОГО большей гибкостью и мощью. Конечно, при условии, что программист понимает, что делает. (КоТ: при условии, что программист понимает, что делает, и С++ не так уж плох ;-) А это не так уж и сложно. По крайней мере, практика показывает, что эти конструкторы не доставляют никаких хлопот программистам. А значит, увеличение мощи не уменьшило "безопасности программирования" :) Продолжим.

Code:

class E: public A,B {

C* c_;

D* d_;

public:

E(); // реализацию см.ниже

~E() { delete d_; delete c_; }

}

E::E() // конструктор класса E

try

: A(1), B(1), c_( new C ), d_( new D ) // список инициализации

{ //начало тела конструктора

cout<<"Constructor body";

}// конец тела конструктора

catch(...){ // ловим любое исключение

A::~A();

B::~B();

delete c_;

delete d_;

}

Непривычное написание, не так ли? Да, в Делфях нельзя ВЕСЬ процесс конструирования поместить в блок try except.

Неправильно! Скорее можно сказать, что в ОР нельзя НЕ поместить весь процесс конструирования в блок try…except. При вызове конструктора ОР как классового (статического, в терминах С++) метода (т.е. через классовую ссылку) блок try…except устанавливается АВТОМАТИЧЕСКИ. При возникновении любого необработанного исключения в конструкторе автоматически вызывается деструктор. Это, однако, не мешает вписать в тело конструктора свои блоки обработки исключений, в том числе и для полной, безопасной обработки некоторых их типов.

Здесь уместно более подробно осветить различия в способах вызова конструкторов ОР. Как я уже говорил, конструктору компилятором неявно передается параметр, который говорит, что он вызывается как классовый или как обычный метод.

В случае классового метода:

устанавливается блок try…except;

вызывается виртуальный метод NewInstance, выделяющий память под экземпляр класса. В случае переопределения Вами этого метода:

размер экземпляра можно получить методом InstanceSize;

память нужно очистить методом InitInstance;

отрабатывает тело конструктора;

вызывается виртуальный метод AfterConstruction.

В случае обычного метода выполняется только тело конструктора. Блок try…except НЕ устанавливается. Так вызываются все собственные конструкторы и конструкторы предков из тела какого-либо конструктора класса (они все равно попадут в установленный блок обработки исключений). Конструктор может быть вызван где угодно. Главное - использовать объектную ссылку (Self.Create), а не классовую. Условно, реальный код конструктора мог бы выглядеть так:

Code:

function TSomething.Create(IsClassRef: boolean): TSomething;

begin

if IsClassRef then

try

Self := TSomthing.NewInstance;

InitInstance(Self);

Self.Create(False); // Тело конструктора,

// написанное разработчиком

Self.AfterConstruction;

except

Self.Destroy; // Если что - харакири :)

end

else

Self.Create(False); // Тело конструктора

Result := Self;

end;

Аналогичная песня с деструкторами. Но здесь обойдемся без лишних объяснений:

Code:

procedure TSomething.Destroy(Deallocate: boolean);

begin

if Deallocate then

Self.BeforeDestruction;

Self.Destroy(False);

if Deallocate then

begin

Self.CleanupInstance;

Self.FreeInstance;

end;

Еще раз замечу, что это чисто гипотетический код, создаваемый компилятором, а не реализация конкретного класса. Конечно, в нем нет никаких рекурсивных вызовов. Продолжим.

Но как же быть с динамическими ресурсами? Спросите вы. Все очень просто:

Code:

E::E() // конструктор класса E

try

: A(1), B(1), c_( NULL ), d_( NULL ) // список инициализации

{ //начало тела конструктора

try{

c_ = new C;

d_ = new D;

cout<<"Constructor body";

}

catch(...){

if(c_) delete C;

if(d_) delete D;

throw;

}

} // конец тела конструктора

catch(...){ // ловим любое исключение

throw E_ErrorCreate();

}

Видно, что я использовал блок try...catch только для "перевода" одного исключения в другое. И назначение этого блока только такое и никакого другого. Использование его в других целях может привести к гадостям (КоТ: если ножом кухонным неправильно пользоваться, это МОЖЕТ привести даже к смерти… Но ведь не обязательно же приводит! Так претензии к ножу (языку), или к кривым рукам?) ,поэтому в некоторых С++ компиляторах (фирмы Борланд например) эта возможность от греха подальше убрана. Вы еще не заскучали?

Нет, Дмитрий, с Вами не соскучишься :)

Здесь хочу лишь заметить, что в ОР нет необходимости чистить ресурсы в конструкторе. На это есть деструктор! (КоТ: Вот!!!) Логично, не так ли? Зачем плодить двойной код. А вот конструкции вида

if Assigned(MyObject1) then

FreeAndNil(MyObject1);

if Assigned(MyObject2) then

FreeAndNil(MyObject2);

ОЧЕНЬ рекомендуется использовать именно в деструкторе. Это хороший стиль. (КоТ: что да, то да.) Конструкция аналогичная if (c_) delete c_ (кстати, здесь была ошибка).

(КоТ: с != 0 бывает, т.к NULL-тип машинно-зависимый. Но пустой указатель где-то представлен, напр, отрицательным числом. Если мне понадобилось, я бы писал

if (С ! = NULL) // что надо сделать с С

хотя Страуструп и советует использовать 0 вместо NULL - в третьей редакции книги. В первой, помнится, советовал обратное ;)

Ведь деструктор может быть вызван в любой момент работы конструктора, и часть ресурсов будет неинициализирована.

Привел я этот пример не для демонстрации возможностей блока try...catch, а для того чтобы показать как С++ сам делает безопасным процесс "конструирования" класса. В Делфи все это ложиться на хрупкие плЭчи программера.

(КоТ: "Врать не надо по телефону" (с) Булгаков)

Теперь мы видим, кто действительно "сам делает безопасным процесс конструирования класса", а кто перекладывает все это на чьи-то "хрупкие плЭчи".

Кстати о Делфях, я там не нашел аналог функции С++ - uncaught_exception() - показывает статус стека исключений. Благодаря этой функции ваш деструктор знает - нормальное это "устранение" класса или не нормальное. По-моему, очень даже пользительно.

Что значит ненормальное устранение класса? Может, мы еще будем считать возникновение исключения ненормальной ситуацией? Между прочим, на исключениях вполне можно выстроить логику работы класса или библиотеки. В ОР этому, кстати, очень способствуют такие преимущества модели исключений перед ANSI C++, как наличие общего предка исключений (и то, что это вообще классы, а не абы что) и наличие блока try…finally (ну это просто добавляет удобств по сравнению с try…catch(…){ throw; })

Поэтому не совсем понятно, зачем понадобилась некая функция uncaught_exception(). Зачем лезть в идеологию работы исключений со своим уставом? Ведь они как раз и избавляют разработчика от чрезмерного применения if. Это еще называется реактивной моделью программирования. Но, раз есть спрос, то есть и предложение:

ExceptAddr function - returns the address at which the current exception was raised.

ExceptObject function - returns a reference to the object associated with the current exception.

ExceptProc variable - points to the lowest-level RTL exception handler.

Фича в том, что оператор new уже выделил память для экземпляра класса TObject, а тут ррраз! И исключение! Что делает С++? Он тут же освободит память - не надо ставить блок try...catch. Все сделает С++. Ну, как говориться, приятная неожиданность.

(КоТ: это стандарт, и кто не знает его, как может говорить, что знает С++?)

Ну, это только для тех, кто не очень хорошо знает ОР и С++. Впрочем, такие "детские" неожиданности не избавляют программера в С++ от необходимости защиты динамических ресурсов. В ОР же в это время можно попить пива ;)

Я не привожу примеры реализации более полезных УМНЫХ указателей, реализующих сборку мусора и правильную работу с ресурсами вообще.

Судя по всему, автор прочитал книгу Джефа Элджера "C++", испестренную идеями УМНЫХ, ВЕДУЩИХ, ГЕНИАЛЬНЫХ указателей и сборки мусора. Здесь хочу заметить, что я иногда читаю книги с карандашом в руке. Это очень хорошая, умная (КоТ: ведущая и гениальная ;-) книга про С++. Только во время ее чтения, постоянно задумываешься, а как можно сделать тоже самое в ОР. В результате после прочтения книга превратилась в записную книжку, испестренную замечаниями о том, насколько проще и красивее выглядела бы в ОР большая часть предлагаемых решений. Для интересующихся - основная идея в использовании свойств и интерфейсов.

1) Работа с несколькими "собственными" кучами. Например, все покупатели складываются в одну кучу. А поступаемые товары в другую… Как видите осталось только реализовать менеджер кучи, что в рамках С++ вещь простая и ведущая себя незаметно (как встроенная фича). Можно так извернуться в Делфях? Нет

(КоТ: Если можно проще и лучше, так изворачиваться-то нафиг?)

Мы уже выяснили, что можно. И как-то изворачиванием это и не назовешь. Обычная работа. Хочешь, переопределяй работу с памятью на уровне классов, хочешь, глобальный менеджер памяти напиши.

2) Помимо "многокучности", оператор new предоставляет вам возможность "виртуального" размещения объекта. Например в файле, в Сети, где вашей душеньке будет угодно. Это тоже недоступно в Делфях.

(КоТ: Это и в С++ без корбы тоже не особенно хорошо получается, кстати. И опять же, нафига? чтобы без спроса прога в своп лазила? Или в инет звонила?)

Откуда такая категоричность? Возможностей "виртуального" размещения у ОР ничуть не меньше. Или операционная система предоставляет для программ на С++ особые механизмы работы с файлами, с сетью и т.д.?

Кстати о преобразовании типов. Делфи обязан безопасному преобразованию типов(as и is) C++, а точнее шаблону dynamic_cast.

(КоТ: Страуструп: "как правило, НЕБЕЗОПАСНО (выделено мной - КоТ) использовать указатель, преобразованный или приведенный с помощью функций …_cast к типу, отличному от типа объекта, на который он указывает.") Да, а в ОР эта вещь абсолютно безопасна…

Не уверен, что кто-то кому-то обязан, тем более шаблону. У ОР всегда была и остается система RTTI, намного превосходящая возможности С++. Да и вообще, RTTI - это обобщенный языковой механизм. При чем здесь конкретные реализации?

Правда в Делфях такое же ограничение на множественное наследование, как и в Яве. Один класс должен быть интерфейсным.

Что за терминология? Дмитрий, наверное, имел в виду, что в списке предков класса ДОЛЖЕН быть указан один класс, и МОЖЕТ быть указано сколько угодно интерфейсов.

Дело в том, что в Делфи тип class реализован через одно очень загадочное место. Связано это с большой нелюбовью паскаля к памяти

(КоТ: это БЫЛО в ДОСе, десять лет назад, но ведь с тех пор воды утекло - !!!)

Можно, конечно, и так сказать. Все в мире относительно. Но я до сих пор встречал очень мало людей, достаточно глубоко знающих устройство классов в Delphi, точнее мне доводилось только читать их труды. И статью Дмитрия тяжело отнести к таким трудам. И почему он решил, что ОР не любит память?

Тип указатель в паскале создан только для того, чтобы указывать на что-то в динамической памяти(куче). Он создан, как шлюз между статической памятью паскаля и кучей. Странно, но зачем-то разработчики языка оставили возможность приводить целое к указателю (КоТ: к дождю, может быть? ;-)

Ни разу не доводилось слышать об ограничении указателей ОР на работу только с кучей. Возможность же приводить целое к указателю позволяет "двигаться" по памяти (не думаю, что это секрет для Дмитрия). Кстати, для указателей на строки допустимы операции "+" и "-" (в том числе в комбинации с целыми) без приведения типов.

Такое понятие как ссылка не знакомо паскалю

(КоТ: тогда в 6.0 под ДОС я работал не с ссылками… а с чем???)

Ссылка в терминологии ОР - это типизированный указатель. А используя термины С++ (КоТ: Страуструп: "Ссылка является альтернативным именем объекта.") ссылкой в ОР являются формальные параметры методов, объявленные с использованием var или out (возможно кто-то не знал, out - то же, что и var, только работает исключительно на возврат значения). Кроме того, чистой воды ссылками являются объектные переменные (Button1: TButton).

Если вы пишите класс "комплексное число", а затем решаете создать массив чисел, то array [1..10] of TComplex; будет на самом деле занимать в памяти 4*10 байт плюс выравнивание. Т.о. вы может быть хотели именно массив ТОЛЬКО КОМПЛЕКСНЫХ чисел, а не указателей на них. Но вместо этого, после инициализации, у вас будет израсходовано (4*10 + 10*sizeof(TComplex)) байт памяти. Короче сами считайте

Действительно, использовать классы ОР в массивах не очень удобно. Есть несколько более экономичных решений:

1) Можно организовать свой менеджмент памяти для TComplex, размещая экземпляры в памяти подряд (например, в заранее выделенном пуле), и работу, скажем, на основе динамического массива. Не самое простое решение, но весьма эффективное и красивое (КоТ: Кстати, активно применяется в С++-модели).

2) Можно вместо классов использовать записи record, организовав их в массив, являющийся свойством по умолчанию какого-то класса:

Code:

TItem = record …

end;

TArray = class

public

property Items[Index: integer]: TItem

read GetItem

write SetItem;

default;

end;

Это будет самое экономичное решение, т.к. каждый экземпляр любого класса имел бы как минимум ссылку на таблицу VMT. А запись содержит только необходимые данные. Вся же логика работы - в классе TArray.

3) Можно использовать старые "объекты" Паскаля вместо "классов": TComplex = object … end; И массив таких объектов будет содержать сами объекты, а не ссылки на них. Это будет самое оригинальное решение. Кстати, на таких объектах построена библиотека KOL (https://xcl.cjb.net/) - аналог VCL. Размер EXE файлов с использованием этой библиотеки начинается от 4.5К (если не изменяет склероз :)

Одним словом, проблема в разработчике, а не в языке. (КоТ: Вот!!!)

Паскаль маленький язык и это не недостаток. (КоТ: Уф!. Ну сколько можно говорить о паскале 10-летней давности?) ?) Его не замечаешь, когда пишешь прогу большую или маленькую. (КоТ: это высшая похвала паскалю вообще. Лучшая одежда - та, которой не замечаешь.) Почему? (КоТ: Потому, что это хороший язык.)

Потому что Паскаль от Борланд специальный язык, т.е. предназначен для узкой области. Узкая - это не значит, что программ мало, просто цели в этой области отличаются не намного.

(КоТ: "С++ создавался для того, чтобы ИЗБАВИТЬ автора и его друзей ОТ ПРОГРАММИРОВАНИЯ НА АССЕМБЛЕРЕ" - (с) Бьерн Страуструп. Дельфа, возможно, создавалась для того, чтобы избавить автора от программирования на паскале, который вообще создавался изначально для ОБУЧЕНИЯ ПОНЯТИЯМ информатики. Оба эти языка свои цели выполнили с блеском. Ну так о чем же спор, цели-то разные?)

Не знаю, может быть ОР и маленький язык. Однако я оцениваю свои знания ОР не более, чем на 60-70% (хотя меня как-то угораздило сдать экзамен на сертификат Brainbench Certified Master Delphi Programmer :), не включая сюда VCL или среду Delphi, разговор только о самом языке. Если охватить все, то я вообще ничего не знаю. Поэтому мне даже как-то неловко заниматься здесь исправлениями. Я считаю, что для этого необходим куда больший кругозор. Но пока за эту задачу никто не взялся. Видимо настоящим профессионалам просто не до этого.

По поводу узости области применения. До последнего времени я считал, что единственное, что нельзя делать в Delphi - это писать драйвера (ОР тут ни причем, это не языковое ограничение). Но недавно натолкнулся на пример создания в Delphi 3 драйвера VxD. Что еще? Игрушки, сетевые сервисы, системные утилиты, распределенные базы данных, научные программы, средства мультимедиа в Delphi пишут и очень успешно. Так о чем речь?

Поэтому резонно было бы выбрать язык, который необходим только для склеивания компонентов или их написания. За все остальное отвечает среда.

После таких утверждений становится странно, как человек позволяет себе критиковать продукт, о котором имеет лишь зачаточное представление. За что "все остальное" отвечает среда? В виде списка, пожалуйста.

Delphi IDE - это, по большому счету, лишь оболочка, набор зацепок к возможностям библиотеки VCL и шикарный пример использования возможностей языка. Это продукт, тратящий наименьшее количество усилий для выполнения одной и той же работы в сравнении с аналогами. Ведь в лице библиотеки VCL он в design-time использует тот же самый код, который работает в готовом приложении. Для сохранения спроектированной формы со всеми компонентами в ресурс Delphi достаточно одной строчки кода!

И потом, "склеивание" и "написание" компонент - вещи по своей сложности абсолютно разные. Visual Basic тоже хорошо склеивает COM-компоненты, только вот с их написанием у VB как-то не очень… То, что ОР позволяет легко и непринужденно создавать и склеивать любые компоненты говорит лишь о его мощности, продуктивности и универсальности. Совершенно очевидно, что сегодня ОР по этому показателю не имеет не то что конкурентов, а даже толковых аналогов.

VCL не является языковым расширением Паскаля - это "ОО" библиотека. Транспортом же между такими библиотеками и отдельными компонентами выступает некая переделка СОМ от Борланд.

Да, VCL - вещь самостоятельная, пока она строится на ОР. Далее автор, похоже, говорит о RTTI. Но причем здесь транспорт между библиотеками и отдельными компонентами? Библиотека - понятие чисто условное. Каждый написанный мной компонент становится полноправной частью VCL. Правильнее, наверно, говорить о транспорте между компонентами и их пользователями, в частности средой Delphi IDE.

К вопросу о переделках. Delphi начинала разрабатываться где-то в 92-93 году. Трудно говорить, кто кого переделал. Да это и не важно. Важно то, что компонент Delphi в полной мере обладает обоими механизмами.

И опять же отбросьте этот транспорт, который не является частью языка, и от Делфи ничего не останется. (КоТ: Отбрось Gdb\Gtk, STL - что останется от милого нашему сердцу С++?) Поэтому Делфи очень гармоничная со своими недостатками среда для разработки GUI приложений под винды.

Да, RTTI - незаметная, но ключевая для Delphi технология. А вот с тем, что она не является частью языка можно крепко поспорить. Достаточно вспомнить операторы AS и IS, которые целиком базируются на RTTI. Да и от TObject никуда не убежишь. Попробуй скажи, что это не часть языка. А ведь основное содержание TObject - реализация RTTI.

Кроме того, Delphi идеально подходит не только для создания GUI приложений, но и консольных, и приложений без визуального интерфейса вообще (например, сервисы Windows NT). К счастью компоненты Delphi не ставят во главу угла визуальность/невизуальность. Это абсолютно универсальные в применении классы. Уже поэтому Delphi разительно отличается от, например, MSVC++, где в основе слова "Visual" лежит наличие у компонента оконного идентификатора и множество маловразумительных макросов и комментариев по тексту, которые нельзя (!) редактировать. Вот где действительно безопасный язык! Ведь программист может все испортить :)

По поводу недостатков можно сказать лишь то, что вряд ли у конкурирующих с Delphi продуктов их меньше. А вообще, давайте взглянем на Delphi 6 и Kylix. Уверен, что сюрпризов там будет более чем достаточно.

(Кот: я очень надеюсь, что у нас научатся, наконец, считать "Итого", а не только недостатки и достоинства отдельно).

Похоже, Дмитрий применительно к безопасности программирования рассматривал только те моменты, которые, по его мнению, хорошо смотрелись в С++ в сравнении с ОР. Здесь, кстати, стоит упомянуть такие преимущества С++ над ОР, как возможность понижать видимость членов класса, а также указание const при объявлении метода, что гарантирует неизменность атрибутов объекта при вызове метода.

Однако не стоит забывать, что ОР является языком, который действительно ставит во главу угла безопасность практически во всем. Можно долго перечислять все его тонкости, избавляющие программера от головной боли и рутиной работы. Как пример, можно привести директиву implements для свойств (делегирование реализации) или объявление глобальных переменных в разделе threadvar для поддержки многопоточности, или замечательную реализацию работы со строками и динамическими массивами на уровне компилятора. Очень важное для безопасности программирования свойство - объявление новых типов.

Гради Буч: "К сожалению, конструкция typedef не определяет нового типа данных и не обеспечивает его защиты. Например, следующее описание в С++:

typedef int Count;

просто вводит синоним для примитивного типа int."

В ОР же мы можем создать абсолютно новый тип. Для этого надо применить ключевое слово type:

type

Count = type int64; // другой тип

Alias = int64; // синоним

Типы Count и int64 уже не будут совместимы без приведения типов.

А вот пример стандартизованной фичи компилятора (соответственно и языка) С++:

long FileSize = 256 * 1024;

В 16-битном компиляторе вы в результате получите 0. Очень приятный сюрприз! А дело в том, что 256 и 1024 по отдельности попадают в int (2 байта), а их произведение уже в long (4 байта). Однако стандарт С++ как раз в том и заключается, что произведение будет также помещено в int. И уже только после этого произойдет присвоение к long. Соответственно туда попадает только младшая часть произведения, которая равна нулю. Спасает написание в форме 256 * 1024L. На 32 битах все будет нормально, т.к. размеры типов int и long совпадают (4 байта).

Некоторые начинают вяло возражать, что такие вещи нужно помнить, что это, мол, нормально. Однако в эту проблему (обнаружили ее случайно) конкретно уперлись два программера на С++ с очень хорошим опытом работы и в течение получаса не смогли ее решить. С ходу помог только действительно матерый эксперт С++. Ну, и как это выглядит с точки зрения безопасности программирования?

(КоТ: плохо выглядит).

А как "эстетичны" в каждом header'е С++ конструкции типа:

#ifndef _MYHEADER_H

#define _MYHEADER_H

… body of the header …

#endif

Получается, я вместо компилятора должен следить, чтобы в проекте оказалась только одна копия каждого файла.

Кстати, особенности ОР как языка обеспечивают не только безопасность программирования, но и безопасность полученного софта, как таковую. К примеру, более половины дыр в безопасности программ отраженных в Bugtraq возникают из-за проблемы переполнения буфера. А эта проблема является визитной карточкой С/С++. Дошло до того, что выпускаются специальные пакеты, которые патчят исходники С++. Как один из вариантов решения проблем безопасности предлагают писать на Pascal…

После всего, что я тут наговорил, может возникнуть мысль: "А почему же тогда Борланд двигает Делфи?". "И почему VCL написан на паскале, а не на С++?". Резонно. Мыслям вообще свойственно появляться в головах человеков.

Нет, мысль возникает не такая. С этим все ясно и так, VCL и Delphi не могут быть написаны ни на чем другом (можно, конечно, на С++ написать компилятор ОР, что вполне реализуемо, и потом в нем все делать, но ведь разработчика такой способ явно не устроит).

Возникает другая мысль. Почему уровень знаний ОР у очень многих программистов так удручающе низок (КоТ: С С++ ситуация ничуть не лучше. Груда книг всяких, прости господи, пересмешников. А если прочитать 1 (один) раз Страуструпа, множество вопросов просто отпадет). Понятно, что литература у нас в основном "для чайников". Но иногда надо хотя бы help читать. Похоже считается делом чести начитаться умных книжек "с примерами приложений на С++", а для Delphi, мол, можно ограничиться знанием Object Inspector'а.

При этом многие такие программисты почему-то считают для себя возможным критиковать возможности ОР. Может быть потому, что Delphi дала им возможность быстро и легко воплотить свои идеи? А потом вдруг что-то не получилось… И вот, виновата Delphi. Можно с уверенностью сказать, что С++ такому программисту все равно не поможет.

Кажется беда Delphi как раз в том, что за внешней простотой многие не могут разглядеть ее истинные возможности. Да и решения об использовании конкретного языка принимаются зачастую на уровне руководства, которое вообще ничего не видит, кроме финансовых показателей дяди Билли.

(КоТ: за что я вообще и выбрал линух - это система людей, имеющих роскошь на рынок в некоторых местах вообще плевать. Хотя от рынка, конечно уйти нельзя. Да и зачем? В умеренных дозах рынок - это очень хорошо.)

Для любящих спорить. Не стоит критиковать какие-то возможности продукта, не до конца в них разобравшись. Современные языки слишком многогранны, чтобы один человек досконально знал хотя бы два языка. Я лично не уверен, что все мои рассуждения на 100% достоверны, но старался, как мог. Поэтому буду рад техническим исправлениям.

"Портос, если Вы говорите глупости, то делайте это, пожалуйста, только от своего имени"

P.S. Красота драгоценного камня, как известно, зависит не только от породы, но и от мастерства огранщика. Только тогда обычный белый свет превращается в нем в причудливую игру разноцветных искр. Так что учите матчасть, и Delphi вас не подведет :)

(КоТ: Два слова напоследок - не удержался. Я полагаю, что С++, что дельфа - языки одного уровня, но разных подуровней. Бессмысленно их сравнивать вообще. С++ старше - хотя бы поэтому дельфа лучше, т.к написана на его крови, если можно так сказать.

Но дельфа все-таки следующее поколение языков. Стоит ли сравнивать сына с отцом, и чему удивляться? Уже народ типами не оперирует, уже оперирует свойствами и объектами. Кто даст хороший язык для этого, тот и выиграет.

А что до С++ - учите матчасть… И не хуже будет, чем в дельфе. ;)

P.P.S. Да, в конце концов, все измеряется способностями конкретного "юзера" языка. Хочется верить, что эта статья поможет кому-нибудь сделать очередной шаг на длинном пути от "чайника" к "профи".

https://delphiworld.narod

DelphiWorld 6.0

Краеугольные камни ООП

2013-08-15T20:30:22+07:00

КРАЕУГОЛЬНЫЕ КАМНИ ООП

ФОРМУЛА ОБЪЕКТА

Авторы надеются, что читатель помнит кое-что из второй главы и такие понятия, как тип данных, процедура, функция, запись для него не в новинку. Это прекрасно. Та вот, в конце 60-х годов кому-то пришло в голову объединить эти понятия и то, что получилось, назвать объектом. Рассмотрение данных в неразрывной связи с методами их обработки позволило вывести формулу объекта:

Объект = Данные + Операции

На основании этой формулы была разработана методология объектно-ориентированного программирования (ООП).

ПРИРОДА ОБЪЕКТА

Об объектах можно думать как о полезных существах, которые «живут» в вашей программе и коллективно решают некоторую прикладную задачу. Вы, как Демиург, лепите этих существ, распределяете между ними обязанности и устанавливаете правила их взаимодействия.

В общем случае каждый объект «помнит» необходимую информацию, «умеет» выполнять некоторый набор действий и характеризуется набором свойств. То, что объект «помнит», хранится в его полях. То, что объект «умеет делать», реализуется в виде его внутренних процедур и функций, называемых методами. Свойства объектов аналогичны свойствам, которые мы наблюдаем у обычных предметов. Значения свойств можно устанавливать и читать. Программно свойства реализуются через поля и методы.

Например, объект «кнопка» имеет свойство «цвет». Значение цвета кнопка запоминает в одном из своих полей. При изменении значения свойства «цвет» вызывается метод, который перерисовывает кнопку.

Кстати, этот пример позволяет сделать важный вывод: свойства имеют первостепенное значение для программиста, использующего объект. Чтобы понять суть и назначение объекта, вы обязательно должны знать его свойства, иногда — методы, очень редко — поля (объект и сам знает, что с ними делать).

ОБЪЕКТЫ И КОМПОНЕНТЫ

Когда прикладные программы создавались для операционной системы MS-DOS и были консольно-ориентированными, объекты казались пределом развития программирования, поскольку были идеальным средством разбиения сложных задач на простые подзадачи. Однако с появлением графических систем, в частности Windows, программирование пользовательского интерфейса резко усложнилось. Программист в какой-то мере стал дизайнером, а визуальная компоновка и увязка элементов пользовательского интерфейса (кнопок, меток, строк редактора) начали отнимать основную часть времени. И тогда программистам пришла в голову идея визуализировать объекты, объединив программную часть объекта с его видимым представлением на экране дисплея в одно целое. То, что получилось в результате, было названо компонентом.

Компоненты в Delphi — это особые объекты, которые являются строительными кирпичиками среды визуальной разработки и приспособлены к визуальной установке свойств. Чтобы превратить объект в компонент, первый разрабатывается по определенным правилам, а затем помещается в Палитру Компонентов. Конструируя приложение, вы берете компоненты из Палитры Компонентов, располагаете на форме и устанавливаете их свойства в окне Инспектора Объектов. Внешне все выглядит просто, но чтобы достичь такой простоты, потребовалось создать механизмы, обеспечивающие функционирование объектов-компонентов уже на этапе проектирования приложения! Все это было придумано и блестяще реализовано в среде Delphi. Таким образом, компонентный подход значительно упростил создание приложений с графическим пользовательским интерфейсом и дал толчок развитию новой индустрии компонентов.

В данной главе мы рассмотрим лишь вопросы создания и использования объектов, Чуть позже мы научим вас превращать объекты в компоненты.

КЛАССЫ ОБЪЕКТОВ

Каждый объект всегда принадлежит некоторому классу. Класс — это обобщенное (абстрактное) описание множества однотипных объектов. Объекты являются конкретными представителями своего класса, их принято называть экземплярами класса. Например, класс СОБАКИ — понятие абстрактное, а экземпляр этого класса МОЙ ПЕС БОБИК — понятие конкретное.

ТРИ КИТА ООП

Весь мир ООП держится на трех китах: инкапсуляции, наследовании и полиморфизме. Для начала о них надо иметь только самое общее представление.

Наблюдаемое в объектах объединение данных и операций в одно целое было обозначено термином инкапсуляция (первый кит ООП). Применение инкапсуляции сделало объекты похожими на маленькие программные модули и обеспечило сокрытие их внутреннего устройства. Для объектов появилось понятие интерфейса, что значительно повысило их надежность и целостность.

Второй кит ООП — наследование. Этот простой принцип означает, что если вы хотите создать новый класс, лишь немногим отличающийся от того, что уже существует, то нет необходимости в переписывании заново всех полей, методов и свойств. Вы объявляете, что новый класс является потомком (или дочерним классом) имеющегося класса, называемого предком (или родительским классом), и добавляете к нему новые поля, методы и свойства. Иными словами добавляется то, что нужно для перехода от общего к частному. Процесс порождения новых классов на основе других классов называется наследованием. Новые классы имеют как унаследованные признаки, так и, возможно, новые. Например, класс СОБАКИ унаследовал многие свойства своих предков — ВОЛКОВ.

Третий кит — это полиморфизм. Он означает, что в производных классах вы можете изменять работу уже существующих в базовом классе методов. При этом весь программный код, управляющий объектами родительского класса, пригоден для управления объектами дочернего класса без всякой модификации. Например, вы можете породить новый класс кнопок с рельефной надписью, переопределив метод отрисовки кнопки. Новую кнопку можно «подсунуть» вместо стандартной в какую-нибудь подпрограмму, вызывающую отрисовку кнопки. При этом подпрограмма «думает», что работает со стандартной кнопкой, но на самом деле кнопка принадлежит производному классу и отображается в новом стиле.

Пока достаточно самого поверхностного понимания всех приведенных выше понятий, ниже мы рассмотрим их подробнее и покажем, как они реализованы в Delphi.

КЛАССЫ

Delphi поддерживает две модели представления объектов — старую и новую. Старая модель существует лишь для совместимости с более ранними версиями компилятора, в частности с Borland Pascal 7.0, поэтому мы не будем ее рассматривать. Все, что сказано ниже, относится к новой модели представления объектов, более мощной и богатой по своим возможностям.

Для поддержки ООП в язык Object Pascal введены объектные типы данных, с помощью которых одновременно описываются данные и операции над ними. Объектные типы называют классами, а их экземпляры — объектами.

Классы объектов определяются в секции type глобального блока. Описание класса начинается словом class и заканчивается словом end. По форме объявления классы похожи на обычные записи, но помимо полей данных могут содержать объявления пользовательских процедур и функций. Такие процедуры и функции обобщенно называют методами, они предназначены для выполнения над объектами различных операций.

Приведем пример объявления класса:

Code:

type

TDiskGauge = class { измеритель дискового пространства}

DriveLetter: Char; { буква дискового накопителя}

PercentCritical: Integer; { критический процент свободного пространства}

function GetPercentFree: Integer;

procedure CheckStatus;

end;

Заголовки методов, следующие за списком полей, играют роль предварительных (forward) объявлений. Программный код методов помещается ниже определения класса и будет приведен позже.

Класс обычно описывает сущность, моделируемую в программе. Например, класс TDiskGauge описывает измеритель дискового ресурса. Класс содержит два поля: DriveLetter— буква находящегося под наблюдением накопителя, и PercentCritical— процент свободного пространства на диске, с которым работает программа. Когда объем свободных ресурсов снижается до этого порога, пользователю выдается звуковое предупреждение. Функция GetPercentFree определена как метод работы над любым объектом класса TDiskGauge и возвращает процент свободного пространства на диске. Процедура CheckStatus служит для проверки состояния ресурса и выдачи звукового предупреждения.

Обратите внимание, что приведенное выше описание является не чем иным, как декларацией интерфейса для управления объектами класса TDiskGauge. Реализация методов GetPercentFree и CheckStatus отсутствует, но для создания и использования экземпляров класса она пока и не нужна. В этом как раз и состоит сила инкапсуляции, Которая делает объекты аналогичными программным модулям. Для использования модуля необходимо изучить лишь его интерфейсную часть, раздел реализации для этого изучать не требуется. Поэтому дальше от описания класса мы перейдем не к реализации методов, а к созданию на их основе объектов.

ОБЪЕКТЫ

Чтобы от описания класса перейти к объекту, следует выполнить соответствующее объявление в секции var:

Code:

var DiskGauge: TDiskGauge;

При работе с обычными типами данных этого объявления было бы достаточно для получения экземпляра типа. Однако объекты в Delphi являются динамическими данными, т.е. распределяются в «куче» (heap). Поэтому переменная DiskGauge— это просто ссылка на экземпляр объекта, которого физически еще не существует. Чтобы сконструировать объект класса TDiskGauge и связать с ним переменную DiskGauge, нужно в текст программы поместить следующий оператор (statement):

Code:

DiskGauge: = TDiskGauge.Create;

Create— это так называемый конструктор объекта; он всегда присутствует в классе и служит для создания и инициализации экземпляров. К сведению профессионалов заметим, что в памяти выделяется место только для полей объекта. Методы, так же как и обычные процедуры и функции, помещаются в область кода программы; они умеют работать с любыми экземплярами своего класса и в памяти никогда не дублируются,

После создания объект можно использовать в программе — читать и устанавливать его поля, вызывать методы. Доступ к полям и методам объекта происходит с помощью уточненных имен, например:

Code:

DiskGauge.DriveLetter: = 'С';

DiskGauge. PercentCritical: = 10;

DiskGauge.CheckStatus;

Кроме того, как и при работе с записями, допустимо использование оператора with, например:

Code:

with DiskGauge dobegin

DriveLetter: = 'С';

PercentCritical: = 10;

CheckStatus;

end;

Если наступает время, когда объект становится не нужен в программе, он должен быть удален вызовом специального метода Destroy, например:

Code:

DiskGauge.Destroy;

Destroy — это так называемый деструктор объекта; он присутствует в классе наряду с конструктором и служит для удаления объекта из динамической памяти. После вызова деструктора переменная DiskGauge становится несвязанной и не должна использоваться для доступа к полям и методам уже несуществующего объекта. Чтобы отличать в программе связанные объектные переменные от несвязанных, последние следует инициализировать значением nil. Например, в следующем фрагменте обращение к деструктору Destroy выполняется только в том случае, если объект реально существует.

Code:

DiskGauge: = nil;

if DiskGauge <> nilthen DiskGauge.Destroy;

Вызов деструктора для несуществующих объектов недопустим и при выполнении программы приведет к ошибке. Чтобы избавить программистов от лишних ошибок, в объекты ввели предопределенный метод Free, который следует вызывать вместо деструктора. Метод Free сам вызывает деструктор Destroy, но только в том случае, если значение объектной переменной не равно nil. Поэтому последнюю строчку в приведенном выше примере можно переписать следующим образом:

Code:

DiskGauge.Free;

Значение одной объектной переменной можно присвоить другой. При этом объект не копируется в памяти, а вторая переменная просто связывается с тем же объектом, что и первая:

Code:

var

DiskGaugel, DiskGauge2: TDiskGauge;

begin

{ Переменные DiskGauge1 и DiskGauge2 не связаны с объектом}

DiskGauge1: = TDiskGauge.Create;{Переменная DiskGauge1 связана с объектом, а DiskGauge2 — нет}

DiskGauge2: = DiskGauge1;{Обе переменные связаны с одним объектом}

DiskGauge2.Free; {Объект удален, переменные DiskGauge1 и DiskGauge2 с ним не связаны}

end;

Объекты могут выступать в программе не только в качестве переменных, но также элементов массивов, полей записей, параметров процедур и функций. Кроме того, они могут служить полями других объектов. Во всех этих случаях программист фактически оперирует указателями на экземпляры объектов в динамической памяти. Следовательно, объекты априори приспособлены для создания сложных динамических структур данных, таких как списки и деревья. Указатели на объекты для этого не нужны.

В некоторых случаях требуется, чтобы объекты разных классов содержали ссылки друг на друга. Возникает проблема: объявление первого класса будет содержать ссылку на еще не определенный класс. Она решается с помощью упреждающего объявления.

Code:

type

TGaugeList = class; { предварительное объявление класса TGaugeList }

TDiskGauge = class Owner: TGaugeList;

...

TGaugeList = class Gauges: array [0..2] of TDiskGauge;

end;

Первое объявление класса TGaugeList называется предварительным (от англ. forward). Оно необходимо для того, чтобы компилятор нормально воспринял объявление поля Owner в классе TDiskGauge.

Итак, вы уже имеете некоторое представление об объектах, перейдем теперь к вопросу реализации их методов.

МЕТОДЫ

Процедуры и функции, предназначенные для выполнения над объектами действий, называются методами. Предварительное объявление методов выполняется при описании класса в секции interface модуля, а их программный код записывается в секции implementation. Однако в отличие от обычных процедур и функций заголовки методов должны иметь уточненные имена, т.е. содержать наименование класса. Приведем, например, возможную реализацию методов в классе TDiskGauge:

Code:

function TDiskGauge.GetPercentFree: Integer; { uses SysUtils; }

var Drive: Byte;

begin

Drive := Ord(DriveLetter) - Ord('A') + 1;

Result := DiskFree(Drive) * 100div DiskSize(Drive);

end;

procedure TDiskGauge.CheckStatus; { uses Windows; }

begin

if GetPercentFree <= PercentCritical then Beep;

end;

Обратите внимание, что внутри методов обращения к полям и другим методам выполняются как к обычным переменным и подпрограммам без уточнения экземпляра объекта. Такое упрощение достигается путем использования в пределах метода псевдопеременной Self (стандартный идентификатор). Физически Self представляет собой дополнительный неявный параметр, передаваемый в метод при вызове. Этот параметр и указывает экземпляр объекта, к которому данный метод применяется. Чтобы пояснить сказанное, перепишем метод CheckStatus, представив его в виде обычной процедуры:

Code:

procedure TDiskGauge_CheckStatus (Self: TDiskGauge);

begin

with Self do

if GetPercentFree <= PercentCritical then Beep;

end;

Согласитесь, что метод CheckStatus выглядит более предпочтительно, чем процедура TDiskGauge_CheckStatus.

Практика показывает, что псевдопеременная Self редко используется в явном виде. Ее необходимо применять только тогда, когда при написании метода может возникнуть какая-либо двусмысленность для компилятора, например при использовании одинаковых имен и для локальных переменных, и для полей объекта.

Если выполнить метод CheckStatus

Code:

DiskGauge.CheckStatus;

то произойдет проверка состояния дискового ресурса. При этом неявный параметр Self будет содержать значение переменной DiskGauge. Такой вызов реализуется обычными средствами процедурного программирования приблизительно так:

Code:

TDiskGauge_CheckStatus(DiskGauge);

КОНСТРУКТОРЫ И ДЕСТРУКТОРЫ

Особой разновидностью методов являются конструкторы и деструкторы. Напомним, что конструкторы создают, а деструкторы — разрушают объекты. Создание объекта включает выделение памяти под экземпляр и инициализацию его полей, а разрушение — очистку полей и освобождение памяти.

Очевидно, что выполняемые при инициализации и деинициализации действия специфичны для каждого конкретного класса объектов. По этой причине Object Pascal позволяет переопределить стандартные конструктор Create и деструктор Destroy для выполнения любых полезных действий. Можно даже определить несколько конструкторов и деструкторов (имена им назначает сам программист), чтобы обеспечить различные способы создания и разрушения объектов.

Объявление конструкторов и деструкторов похоже на объявление обычных методов с той лишь разницей, что вместо зарезервированного слова procedure (или function) используются слова constructor и destructor:

Code:

type TDiskGauge = class DriveLetter: Char;

PercentCritical: Integer;

constructor Create;

destructor Destroy;

...

end;

Приведем их возможную реализацию:

Code:

constructor TDiskGauge.Create;

begin

DriveLetter := 'C';

PercentCritical := 10;

end;

destructor TDiskGauge.Destroy;

begin

{ Разрушение встроенных объектов и освобождение динамических данных}

end;

Конструктор иногда имеет параметры, в которых передаются исходные значения полей объекта. Если объект содержит встроенные объекты или другие динамические данные, то конструктор — это как раз то место, где их нужно создавать.

Конструктор применяется к классу или к объекту. Если он применяется к классу

Code:

DiskGauge: = TDiskGauge.Create;

то выполняется следующая последовательность действий:

•	в динамической памяти выделяется место для нового объекта;

•	выделенная память заполняется нулями; в результате все числовые поля и поля порядкового типа приобретают нулевые значения, строковые поля становятся пустыми, а поля, содержащие указатели и объекты, получают значение nil;

•	затем выполняются заданные программистом действия конструктора;

•	ссылка на созданный объект возвращается в качестве значения конструктора; тип возвращаемого значения совпадает с типом класса, использованного при вызове (в нашем примере это тип TDiskGauge).

Если конструктор применяется к объекту (DiskGauge.Create;)то новый объект не создается, а происходит переинициализация полей существующего. В этом случае конструктор не возвращает никакого значения.

Деструктор уничтожает объект, к которому применяется (DiskGauge.Destroy;)

В результате:

•	выполняется заданный программистом код деинициализации;

•	освобождается занимаемая объектом динамическая память.

В теле деструктора обычно должны уничтожаться встроенные объекты и динамические данные, созданные конструктором.

СВОЙСТВА

ПОНЯТИЕ СВОЙСТВА

Помимо полей и методов в объектах существуют свойства. При работе с объектом свойства выглядят как поля: они принимают значения и участвуют в выражениях. Но в отличие от полей свойства не занимают места в памяти, а операции их чтения и записи ассоциируются с обычными полями или методами. Это позволяет создавать необходимые побочные эффекты при обращении к свойствам. Например, присваивание свойству Visible значения True вызовет отображение графического объекта на экране, а значения False— его исчезновение.

Объявление свойства выполняется с помощью зарезервированного слова property, например:

Code:

type

TDiskGauge = class FPercentCritical: Integer;

procedure SetPercentCritical (Percent: Integer);

property PercentCritical: Integer read FpercentCritical

write SetPercentCritical;

end;

После слова read указывается поле или метод, к которому происходит обращение при чтении значения свойства, а после слова write— поле или метод, к которому происходит обращение при записи значения свойства. Например, чтение свойства PercentCritical заменяется на чтение поля FPercentCritical, а установка свойства — на вызов метода SetPercentCritical. Чтобы имена свойств не совпадали с именами полей, последние принято писать с буквы F (от англ. field).

Атрибуты read и write называются спецификаторами доступа. Если один из них опущен, то значение свойства можно либо только читать (задан спецификатор read), либо только записывать (задан спецификатор write). В следующем примере объявлено свойство, значение которого можно только читать:

Code:

type

TDiskGauge = class

property PercentFree: Integer read GetPercentFree;

end;

Обращение к свойствам выглядит в программе как обращение к полям:

Code:

var

DiskGauge: TDiskGauge;

A : Integer;

А := DiskGauge.PercentCritical;

{ эквивалентно А := DiskGauge.FPercentCritical;}

DiskGauge.PercentCritical := A + 10;

{ эквивалентно DiskGauge.SetPercentCritical(A + 10);}

Однако в отличие от полей свойства не имеют адреса в памяти, поэтому к ним запрещено применять операцию @. Кроме того, их нельзя передавать в var-параметрах процедур и функций.

Технология объектно-ориентированного программирования в Delphi предписывает избегать прямого обращения к полям, создавая вместо этого соответствующие свойства. Это упорядочивает работу с объектами, изолируя их данные от непосредственной модификации. В будущем внутренняя структура класса, которая иногда является достаточно сложной, может быть изменена с целью повышения эффективности работы программы. При этом потребуется переработать только методы чтения и записи значений свойств; внешний интерфейс класса не изменится.

МЕТОДЫ ПОЛУЧЕНИЯ И УСТАНОВКИ СВОЙСТВ

Методы чтения и записи свойств подчиняются определенным правилам. Метод чтения свойства — это всегда функция, возвращающая значение того же типа, что и тип свойства. Метод записи свойства — это обязательно процедура, принимающая параметр того же типа, что и тип свойства. В остальном это обычные методы объекта. Примерами методов чтения и записи свойств являются GetPercentFree и SetPercentCritical в классе TDiskGauge:

Code:

type TDiskGauge = class

FPercentCritical: Integer;

function GetPercentFree: Integer;

procedure SetPercentCritical (Value: Integer);

property PercentFree: Integer read GetPercentFree;

property PercentCritical: Integer

read FPercentCritical write SetPercentCritical;

end;

Использование методов для получения и установки свойств позволяет проверить корректность значения свойства, сделать дополнительные вычисления, установить значения зависимых полей и т.д. Например, в методе SetPercentCritical целесообразно сделать проверку на то, что устанавливаемое значение находится в диапазоне от 0 до 100:

Code:

procedure TDiskGauge.SetPercentCritical (Value: Integer);

begin

if (Value >= 0) and (Value < 100)

then FpercentCritical := Value;

end;

МЕТОДЫ, ОБСЛУЖИВАЮЩИЕ НЕСКОЛЬКО СВОЙСТВ

0дин и тот же метод может использоваться для получения (установки) значений нескольких свойств одного типа. В этом случае каждому свойству назначается целочисленный индекс, который передается в метод первым параметром. В следующем примере методы Get и Set обслуживают три свойства: GaugeA, GaugeB и GaugeC:

Code:

type

TGaugeList = class

FGauges: array [0..2] of TDiskGauge;

...

function Get (Index: Integer): TDiskGauge;

procedureSet (Index: Integer; Value: TDiskGauge);

...

property GaugeA: TDiskGauge index0read Get writeSet;

property GaugeB: TDiskGauge index1read Get writeSet;

property GaugeC: TDiskGauge index2read Get writeSet;

...

end;

function TGaugeList.Get (Index: Integer): TDiskGauge;

begin

Result := FGauges [Index];

end;

procedure TGaugeList.Set (Index: Integer; Value: TDiskGauge);

begin

FGauges [Index] := Value;

end;

Обращения к свойствам GaugeA, GaugeB и GaugeC заменяются на соответствующие Вызовы методов Get и Set:

Code:

var

GaugeList: TGaugeList;

DiskGauge: TDiskGauge;

...

GaugeList.GaugeC := DiskGauge;

{ эквивалентно GaugeList.Set (2, DiskGauge) }

GaugeList.GaugeC.CheckStatus;

{ эквивалентно GaugeList.Get(2).CheckStatus }

...

СВОЙСТВА-МАССИВЫ

Кроме обычных свойств в объектах существуют свойства-массивы (array properties), Свойство-массив — это индексированное множество свойств. В виде свойства-массива удобно, например, представить множество измерителей ресурсов в классе TGaugeList

Code:

type

TGaugeList = class

...

property Gauges[Index: Integer]: TdiskGauge

read Get writeSet;

...

end;

Обратите внимание, что методы Get и Set обслуживают и свойство-массив Gauges, и индексированные свойства GaugeA, GaugeB и GaugeC. Если в описании обычных свойств могут участвовать поля, то в описании свойств-массивов разрешено использовать только методы.

Основная выгода от применения свойств-массивов — возможность выполнения итераций с помощью цикла for, например:

Code:

var

GaugeList: TGaugeList;

I: Integer;

...

for I := 0to2do

with GaugeList do Gauges [I] .CheckStatus;

...

Свойства-массивы могут быть многомерными. В этом случае методы чтения и записи их элементов имеют столько же индексных параметров соответствующего типа, что и массив.

Свойства-массивы имеют два важных отличия от обычных массовов:

•	их индексы не ограничиваются диапазоном и могуптаеть-любой тип-данных, а не только Integer; например, можно создать свойство-массив, в котором индексами будут строки; обращение к такому свойству могло бы выглядеть так:

GaugeList.Gauges['GaugeA'] := DiskGauge;

• операции над свойством-массивом в целом запрещены; разрешены операции только с его элементами.

СВОЙСТВО-МАССИВ КАК ОСНОВНОЕ СВОЙСТВО ОБЪЕКТА

Свойство-массив можно сделать основным свойством объектов данного класса. Для этого в его описание добавляется слово default:

Code:

type

TGaugeList = class

...

property Gauges [Index: Integer]: TdiskGauge

read Get writeSet; default;

...

end;

Такое объявление свойства Gauges позволяет рассматривать сам объект класса TGaugeList как массив и опускать имя свойства-массива при обращении к нему из программы, например:

Code:

var GaugeList: TGaugeList;

I: Integer;

...

for I := 0to2do GaugeList [I] := nil; { эквивалентно GaugeList.Gauges[I] := nil; }

Следует помнить, что только свойства-массивы могут быть основными свойствами объектов; для обычных свойств это недопустимо.

Метаклассы

2013-08-15T20:36:07+07:00

МЕТАКЛАССЫ

ССЫЛКИ НА КЛАССЫ

Язык Object Pascal позволяет рассматривать классы как своего рода объекты, которыми можно манипулировать в программе. Такая возможность рождает новое понятие —класс класса; его принято обозначать термином метакласс.

Для поддержки метаклассов введен специальный тип данных —ссылка на класс (class reference). Он описывается с помощью словосочетания class of, например:

Code:

type

TResourceGaugeClass = classof TResourceGauge;

Переменная типа TResourceGaugeClass объявляется в программе обычным образом:

Code:

var

ClassRef: TResourceGaugeClass;

Значениями переменной ClassRef могут быть класс TResourceGauge и все порожденные от него классы. Допустимы, например, следующие операторы:

Code:

ClassRef := TResourceGauge;

ClassRef := TDiskGauge;

ClassRef := TMemoryGauge;

По аналогии с тем, как для всех классов существует общий предок TObject, у ссылок на классы существует базовый тип TCIass:

Code:

type TCIass = classof TObject;

Переменная типа TCIass может ссылаться на любой класс.

Практическая ценность ссылок на классы состоит в возможности создавать программные модули, работающие с любыми классами объектов, даже с теми, которые еще не разработаны.

МЕТОДЫ КЛАССОВ

Метаклассы привели к возникновению нового типа методов — методов класса. Метод класса оперирует не экземпляром объекта, а непосредственно классом. Он объявляется как обычный метод, но перед словом procedure или function записывается зарезервированное слово class, например:

Code:

type

TResourceGauge = class

...

classfunction GetClassName : string;

end;

Псевдопараметр Self, передаваемый в метод класса, содержит не ссылку на объект, а ссылку на класс, поэтому в теле метода нельзя обращаться к полям, методам и свойствам объекта. Зато можно вызывать другие методы класса, например:

Code:

classfunction TResourceGauge.GetClassName: string;

begin

Result := ClassName;

end;

Метод ClassName объявлен в классе TObject и возвращает имя класса, к которому применяется. Очевидно, что надуманный метод GetClassName просто дублирует эту функциональность для класса TResourceGauge и всех его наследников.

Методы класса применимы и к классам, и к объектам. В обоих случаях в параметре Self передается ссылка на класс объекта. Пример:

Code:

var

Gauge: TResourceGauge;

S: string;

begin

{ Вызов метода с помощью ссылки на класс }

S := TDiskGauge.GetClassName; { S получит значение 'TDiskGauge' }

Gauge := TDiskGauge.Create('С');

{ Вызов метода с помощью ссылки на объект }

S := Gauge.GetClassName; { S получит значение 'TDiskGauge' }

end;

Методы классов могут быть виртуальными. Например, в классе TObject определен виртуальный метод класса Newlnstance. Он служит для распределения памяти под объект и автоматически вызывается конструктором. Его можно перекрыть в своем классе, чтобы обеспечить нестандартный способ выделения памяти для экземпляров. Метод Newlnstance должен перекрываться вместе с другим методом Freelnstance, который автоматически вызывается из деструктора и служит для освобождения памяти. Добавим, что размер памяти, требуемый для экземпляра, можно узнать вызовом предопределенного метода класса InstanceSize.

ВИРТУАЛЬНЫЕ КОНСТРУКТОРЫ

Особая мощь ссылок на классы проявляется в сочетании с виртуальными конструкторами. Виртуальный конструктор объявляется с ключевым словом virtual. Вызов виртуального конструктора происходит по фактическому значению ссылки на класс, а не по ее формальному типу. Это позволяет создавать объекты, классы которых неизвестны на этапе компиляции. Механизм виртуальных конструкторов применяется в Delphi при создании форм и компонентов.

На этом закончим изучение теории объектно-ориентированного программирования и в качестве практики рассмотрим несколько широко используемых инструментальных классов Delphi. Разберитесь с их назначением и работой. Это поможет глубже понять ООП и пригодится на будущее.

КЛАССЫ ОБЩЕГО НАЗНАЧЕНИЯ В DELPHI

Как показывает практика, в большинстве задач приходится использовать однотипные структуры данных: списки, массивы, множества и т.д. От задачи к задаче изменяются только их элементы, а методы работы сохраняются. Например, для любого списка нужны процедуры вставки и удаления элементов. В связи с этим возникает естественное желание решить задачу «в общем виде», т.е. создать универсальные средства для управления основными структурами данных. Эта идея не нова. Она давно пришла в голову разработчикам инструментальных пакетов, которые быстро наплодили множество вспомогательных библиотек. Эти библиотеки содержали классы объектов для работы со списками, коллекциями (динамические массивы с переменным количеством элементов), словарями (коллекции, индексированные строками) и другими «абстрактными» структурами. Для Delphi тоже разработаны аналогичные классы объектов. Их большая часть сосредоточена в модуле Classes. Наиболее нужными для вас являются списки строк (TStrings, TStringList) и потоки (TSream, THandleSream, TFileStream, TMemoryStream и TBIobStream). Рассмотрим кратко их назначение и применение.

КЛАССЫ ДЛЯ ПРЕДСТАВЛЕНИЯ СПИСКА СТРОК

Для работы со списками строк служат классы TStrings и TStringList. Они используются в библиотеке VCL повсеместно и имеют гораздо большую универсальность, чем та, что можно почерпнуть из их названия. Классы TStrings и TStringList служат для представления не просто списка строк, а списка элементов, каждый из которых представляет собой пару строка-объект. Если со строками не ассоциированы объекты, получается обычный список строк.

Класс TStrings используется визуальными компонентами и является абстрактным. Он не имеет собственных средств хранения строк и определяет лишь интерфейс для работы с элементами. Класс TStringList является наследником TStrings и служит для организации списков строк, которые используются отдельно от управляющих элементов. Объекты TStringList хранят строки и объекты в динамической памяти.

Свойства класса TStrings описаны ниже.

Count: Integer— число элементов в списке.

Strings[lndex: Integer]: string— обеспечивает доступ к массиву строк по индексу. Первая строка имеет индекс, равный 0. Свойство Strings является основным свойством объекта.

Objects[lndex: Integer]: TObject — обеспечивает доступ к массиву объектов. Свойства Strings и Objects позволяют использовать объект TStrings как хранилище строк и ассоциированных с ними объектов произвольных классов.

Text: string— позволяет интерпретировать список строк как одну большую строку, в которой элементы разделены символами #13#10 (возврат каретки и перевод строки),

Наследники класса TStrings иногда используются для хранения строк вида Имя=3начение, в частности, строк INI-файлов (см. гл. 6). Для удобной работы со строками такой структуры в классе TStrings дополнительно имеются следующие свойства.

Names[lndex: Integer]: string— обеспечивает доступ к той части строки, в которой содержится имя.

Values[const Name: string]: string— обеспечивает доступ к той части строки, в которой содержится значение. Указывая вместо Name ту часть строки, которая находится слева от знака равенства, вы получаете ту часть, что находится справа.

Управление элементами списка осуществляется с помощью следующих методов:

Add(const S: string): Integer— добавляет новую строку S в список и возвращает ее позицию. Новая строка добавляется в конец списка.

Add0bject(const S: string; AObject: TObject): Integer— добавляет в список строку S и ассоциированный с ней объект AObject. Возвращает индекс пары строка—объект.

AddStrings(Strings: TStrings)— добавляет группу строк в существующий список. Append(const S: string)— делает то же, что и Add, но не возвращает значения. Clear— удаляет из списка все элементы.

Delete(lndex: Integer)— удаляет строку и ассоциированный с ней объект. Метод Delete, так же как метод Clear, не разрушает объектов, т.е. не вызывает у них деструктор. Об этом вы должны позаботиться сами.

Equals(Strings: TStrings): Boolean— возвращает True, если список строк в точности равен тому, что передан в параметре Strings.

Exchange(lndex1, lndex2: Integer)— меняет два элемента местами.

GetText: PChar — возвращает все строки списка в виде одной большой нуль-терминированной строки.

lndex0f(const S: string): Integer— возвращает позицию строки S в списке. Если заданная строка в списке отсутствует, функция возвращает значение —1.

lndexOfName(const Name: string): Integer— возвращает позицию строки, которая имеет вид Имя=3начение и содержит в себе Имя, равное Name.

lndexOfObject(AObject: TObject): Integer— возвращает позицию объекта AObject в массиве Objects. Если заданный объект в списке отсутствует, функция возвращает значение —1.

lnsert(lndex: Integer; const S: string)— вставляет в список строку S в позицию Index.

lnsert0bject(lndex: Integer; const S: string; AObject: TObject)— вставляет в список строку S и ассоциированный с ней объект AObject в позицию Index.

LoadFromFile(const FileName: string)— загружает строки списка из текстового файла.

LoadFromStream(Stream: TStream)— загружает строки списка из потока данных (см. ниже).

Move(Curlndex, Newlndex: Integer)— изменяет позицию элемента (пары строка-объект) в списке.

SaveToFile(const FileName: string)— сохраняет строки списка в текстовом файле.

SaveToStream(Stream: TStream)— сохраняет строки списка в потоке данных.

SetText(Text: PChar)— загружает строки списка из одной большой нуль-терминированной строки.

Класс TStringList добавляет к TStrings несколько дополнительных свойств и методов, а также два свойства-события для уведомления об изменениях в списке. Они описаны ниже.

Свойства:

Duplicates: TDuplicates— определяет, разрешено ли использовать дублированные строки в списке. Свойство может принимать следующие значения: duplgnore (дубликаты игнорируются), dupAccept (дубликаты разрешены), dupError (дубликаты запрещены, попытка добавить в список дубликат вызывает ошибку).

Sorted: Boolean— если имеет значение True, то строки автоматически сортируются в алфавитном порядке.

Методы:

Find(const S: string; var Index: Integer): Boolean— выполняет поиск строки S в списке строк. Если строка найдена, Find помещает ее позицию в переменную, переданную в параметре Index, и возвращает True.

Sort— сортирует строки в алфавитном порядке.

События:

OnChange: TNotifyEvent— указывает на обработчик события, который выполнится при изменении содержимого списка. Событие OnChange генерируется после того, как были сделаны изменения.

OnChanging: TNotifyEvent— указывает на обработчик события, который выполнится при изменении содержимого списка. Событие OnChanging генерируется перед тем, как будут сделаны изменения.

Ниже приводится фрагмент программы, демонстрирующий создание списка строк и манипулирование его элементами:

Code:

var

Items: TStrings;

I: Integer;

begin

{ Создание списка }

Items := TStringList.Create;

Items.Add('Туризм');

Items.Add('Наука');

Items.Insert(1, 'Бизнес');

...

{ Работа со списком }

for I := 0to Items. Count - 1do

Items[I] := Uppercase(Items [I]);

...

{ Удаление списка }

Items.Free;

end;

КЛАССЫ ДЛЯ ПРЕДСТАВЛЕНИЯ ПОТОКА ДАННЫХ

В Delphi существует иерархия классов для хранения и последовательного ввода-вывода данных. Классы этой иерархии называются потоками. Потоки лучше всего представлять как файлы. Классы потоков обеспечивают различное физическое представление данных:

файл на диске, раздел оперативной памяти, поле в таблице базы данных (см. табл. 1).

Таблица 1.

Класс Описание

TStream Абстрактный поток, от которого наследуются все остальные. Свойства и методы класса TStream образуют базовый интерфейс потоковых объектов.

THandleStream Поток, который хранит свои данные в файле. Для чтения-записи файла используется дескриптор (handle), поэтому поток называется дескрипторным. Дескриптор - это номер открытого файла в операционной системе. Его возвращают низкоуровневые функции создания и открытия файла.

TFileStream Поток, который хранит свои данные в файле. Отличается от ThandleStream тем, что сам открывает (создает) файл по имени, переданному в конструктор.

TMemoryStream Поток, который хранит свои данные в оперативной памяти. Моделирует работу с файлом. Используется для хранения промежуточных результатов, когда файловый поток не подходит из-за низкой скорости передачи данных.

TResourceStream Поток, обеспечивающий доступ к ресурсам в Windows-приложении.

TBIobStream Обеспечивает последовательный доступ к большим полям таблиц в базах данных.

Потоки широко применяются в библиотеке VCL и наверняка вам понадобятся. Поэтому ниже кратко перечислены их общие ключевые свойства и методы.

Общие свойства:

Position: Longint— текущая позиция чтения-записи.

Size: Longint— текущий размер потока в байтах.

Общие методы:

CopyFrom(Source: TStream; Count: Longint): Longint— копирует Count байт из потока Source в свой поток.

Read(var Buffer; Count: Longint): Longint— читает Count байт из потока в буфер Buffer, продвигает текущую позицию на Count байт вперед и возвращает число прочитанных байт. Если значение функции меньше значения Count, то в результате чтения был достигнут конец потока.

ReadBuffer(var Buffer; Count: Longint)— читает из потока Count байт в буфер Buffer и продвигает текущую позицию на Count байт вперед. Если выполняется попытка чтения за концом потока, то генерируется ошибка.

Seek(0ffset: Longint; Origin: Word): Longint— продвигает текущую позицию в потоке на Offset байт относительно позиции, заданной параметром Origin. Параметр Origin может иметь одно из следующих значений: 0 — смещение задается относительно начала потока; 1 — смещение задается относительно текущей позиции в потоке; 2 — смещение задается относительно конца потока.

Write(const Buffer; Count: Longint): Longint— записывает в поток Count байт из буфера Buffer, продвигает текущую позицию на Count байт вперед и возвращает реально записанное количество байт. Если значение функции отличается от значения Count, то при записи была ошибка.

WriteBuffer(const Buffer; Count: Longint)— записывает в поток Count байт из буфера Buffer и продвигает текущую позицию на Count байт вперед. Если по какой-либо причине невозможно записать все байты буфера, то генерируется ошибка.

Ниже приводится фрагмент программы, демонстрирующий создание файлового потока и запись в него строки:

Code:

var

Stream: TStream;

S: AnsiString;

StrLen: Integer;

begin

{ Создание файлового потока }

Stream := TFileStream.Create('Sample.Dat', fmCreate);

...

{ Запись в поток некоторой строки }

StrLen := Length(S) * SizeOf(Char);

Stream.Write (StrLen, SizeOf (Integer) ) ; { запись длины строки }

Stream.Write (S, StrLen); { запись символов строки }

...

{ Закрытие потока }

Stream.Free;

end;

итоги

Теперь для вас нет секретов в мире ООП. Вы на достаточно серьезном уровне познакомились с объектами и их свойствами; узнали, как объекты создаются, используются и уничтожаются. Если не все удалось запомнить сразу — не беда. Возвращайтесь к материалам главы по мере решения стоящих перед вами задач, и работа с объектами станет простой, естественной и даже приятной. Когда вы добьетесь понимания того, как работает один объект, то автоматически поймете, как работают все остальные. Теперь мы рассмотрим то, с чем вы встретитесь очень скоро — ошибки программирования.

Наследование

2013-08-15T20:34:52+07:00

НАСЛЕДОВАНИЕ

ПОНЯТИЕ НАСЛЕДОВАНИЯ

Классы инкапсулируют (т.е. включают в себя) поля, методы и свойства; это их первая черта. Следующая не менее важная черта классов — способность наследовать поля, методы и свойства других классов. Чтобы пояснить сущность наследования, обратимся к примеру с измерителями ресурсов.

Класс TDiskGauge описывает измеритель дискового ресурса и непригоден для измерения ресурса другого типа, например оперативной памяти. С появлением измерителя оперативной памяти нужен новый класс объектов:

Code:

type

TMemoryGauge = class

FPercentCritical: Integer;

constructor Create;

function GetPercentFree: Integer;

procedure SetPercentCritical (Value: Integer) ;

procedure CheckStatus;

property PercentFree: Integer read GetPercentFree;

property PercentCritical: Integer

read FPercentCritical write SetPercentCritical;

end;

Поля, методы и свойства класса TMemoryGauge аналогичны тем, что определенывклассе TDiskGauge. Отличие состоит в отсутствии поля DriveLetter и другой реализации конструктора Create и метода GetPercentFree. Если в будущем появится класс, описывающий измеритель ресурса какого-то нового типа, то придется снова определять общие для всех классов поля, методы и свойства. Чтобы избавиться от дублирования атрибутов при определении новых классов, воспользуемся механизмом наследования. Прежде всего выделим атрибуты, общие для всех измерителей ресурсов, в отдельный класс TResourceGauge:

Code:

type

TResourceGauge = class

FPercentCritical: Integer;

constructor Create;

function GetPercentFree: Integer;

procedure SetPercentCritical (Value: Integer) ;

procedure CheckStatus;

property PercentFree : Integer read GetPercentFree;

property PercentCritical: Integer

read FPercentCritical write SetPercentCritical;

end;

constructor TResourceGauge.Create;

begin

FPercentCritical := 10;

end;

function TResourceGauge.GetPercentFree: Integer;

begin

Result := 0;

end;

procedure TResourceGauge.SetPercentCritical (Value: Integer);

begin

if (Value >= 0) and (Value < 100) then FPercentCritical := Value;

end;

procedure TResourceGauge.CheckStatus;

begin

if GetPercentFree <= FPercentCritical then Beep;

end;

При реализации класса TResourceGauge ничего не известно о том, что в действительности представляет собой ресурс, поэтому функция GetPercentFree возвращает нуль. Очевидно, что создавать объекты класса TResourceGauge не имеет смысла. Для чего тогда нужен класс TResourceGauge? Ответ: чтобы на его основе породить два других класса — TDiskGauge и TMemoryGauge, описывающих конкретные виды измерителей ресурсов, — измеритель диска и измеритель памяти:

Code:

type

TDiskGauge = class(TResourceGauge)

DriveLetter: Char;

constructor Create (ADriveLetter: Char) ;

function GetPercentFree: Integer;

end;

TMemoryGauge = class(TResourceGauge)

function GetPercentFree: Integer;

end;

Классы TDiskGauge и TMemoryGauge определены как наследники TResourceGauge (об этом говорит имя в скобках после слова class). Они автоматически включают в себя все описания, сделанные в классе TResourceGauge и добавляют к ним некоторые новые. В результате формируется следующее дерево классов (рис. 1):

Рисунок 1

Класс, который наследует атрибуты другого класса, называется порожденным классом или потомком. Естественно, что класс, от которого происходит наследование, выступает в роли базового, или предка. В примере класс TDiskGauge является непосредственным потомком класса TResourceGauge. Если от TDiskGauge породить новый класс, то он тоже будет потомком TResourceGauge, но уже не таким близким, как TDiskGauge.

Очень важно, что в отношениях наследования любой класс может иметь только одного непосредственного предка и сколь угодно много потомков. Поэтому все связанные отношением наследования классы образуют иерархию. Примером иерархии классов является библиотека Visual Component Library (VCL); с ее помощью в Delphi обеспечивается разработка Windows-приложений.

ПРЕДОК ПО УМОЛЧАНИЮ

В языке Object Pascal существует предопределенный класс TObject, который служит неявным предком тех классов, для которых предок не указан. Это означает, что объявление

Code:

type

TResourceGauge = class

...

end;

эквивалентно следующему:

Code:

type

TResourceGauge = class(TObject)

...

end;

Класс TObject выступает корнем любой иерархии классов. Он содержит ряд методов, которые по наследству передаются всем остальным классам. Среди них конструктор Create, деструктор Destroy, процедура Free и некоторые другие методы.

Таким образом, полная иерархия классов для измерителей ресурсов выглядит так (рис. 2):

Рисунок 2

ПЕРЕКРЫТИЕ АТРИБУТОВ В НАСЛЕДНИКАХ

В механизме наследования можно условно выделить три основных момента:

§	наследование полей;

§	наследование свойств;

§	наследование методов.

Любой порожденный класс наследует от родительского все поля данных, поэтому классы TDiskGauge и TMemoryGauge автоматически содержат поле FPercentCritical, объявленное в классе TResourceGauge. Доступ к полям предка осуществляется по имени, как если бы они были определены в порожденном классе. В наследниках можно определять новые поля, но их имена должны отличаться от имен полей предка.

Наследование свойств и методов имеет свои особенности.

Свойство базового класса можно перекрыть (от англ. override) в производном классе, например чтобы добавить ему новый атрибут доступа или связать с другим полем или методом.

Метод базового класса тоже можно перекрыть в производном классе, например чтобы изменить логику его работы. Обратимся, например, к классам TDiskGauge и TMemoryGauge. В них методы SetPercentCritical и CheckStatus унаследованы от TResourceGauge, так как логика их работы не зависит от типа ресурса. А вот метод GetPercentFree перекрыт, так как способ вычисления процента свободного пространства специфичен для диска и оперативной памяти:

Code:

function TDiskGauge.GetPercentFree: Integer;

var

Drive: Byte;

begin

Drive := Ord(DriveLetter) - Ord('A') + 1;

Result := DiskFree(Drive) * 100div DiskSize(Drive) ;

end;

function TMemoryGauge.GetPercentFree: Integer; { uses Windows; }

var

MemoryStatus: TMemoryStatus;

begin

MemoryStatus.dwLength := SizeOf(MemoryStatus);

GlobalMemoryStatus(MemoryStatus);

Result := 100 - MemoryStatus.dwMemoryLoad;

end;

В классе TDiskGauge перекрыт еще и конструктор Create. Это необходимо для инициализации дополнительного поля DriveLetter:

Code:

constructor TDiskGauge.Create (ADriveLetter: Char) ;

begin

inherited Create;

DriveLetter := ADriveLetter;

end;

Как видно из примера, в наследнике можно вызвать перекрытый метод предка, указав перед именем метода зарезервированное слово inherited. Кстати, данный пример демонстрирует важный принцип реализации конструкторов: сначала вызывается конструктор предка, а затем инициализируются дополнительные поля данных. В деструкторах применяется обратная последовательность действий: сначала разрушаются данные, недоступные предку, а затем вызывается унаследованный деструктор.

СОВМЕСТИМОСТЬ ОБЪЕКТОВ РАЗЛИЧНЫХ КЛАССОВ

Для классов, связанных отношением наследования, вводится новое правило совместимости типов. Вместо объекта базового класса можно подставить объект любого производного класса. Обратное неверно. Например, переменной типа TResourceGauge можно присвоить значение переменной типа TDiskGauge:

Code:

var

R: TResourceGauge;

...

R := TDiskGauge.Create;

...

Объектная переменная R формально имеет тип TResourceGauge, а фактически связана с экземпляром класса TDiskGauge.

Правило совместимости классов чаще всего применяется при передаче объектов в параметрах процедур и функций. Например, если процедура работает с объектом класса TResourceGauge, то вместо него можно передать объект класса TDiskGauge или TMemoryGauge.

КОНТРОЛЬ И ПРЕОБРАЗОВАНИЕ ТИПОВ

Поскольку реальный экземпляр объекта может оказаться наследником класса, указанного при описании объектной переменной или параметра, бывает необходимо проверить, к какому классу принадлежит объект на самом деле. Чтобы программист мог выполнять такого рода проверки, каждый объект хранит информацию о своем классе. В Object Pascal существуют операторы is и as, с помощью которых выполняется соответственно проверка на тип (type checking) и преобразование к типу (type casting).

Например, чтобы выяснить, принадлежит ли некоторый объект Obj, объявленный в программе как

Code:

var

Obj: TObject;

к классу TResourceGauge или его наследнику, следует записать

Code:

if Obj is TResourceGauge then{ да, принадлежит } ;

Для преобразования объекта к нужному типу используется оператор as, например:

Code:

with Obj as TResourceGauge do CheckStatus;

Стоит отметить, что для объектов применим и обычный способ приведения типа:

Code:

with TResourceGauge(Obj ) do CheckStatus;

Вариант с оператором as лучше, поскольку безопасен. Он генерирует ошибку (точнее, исключительную ситуацию) при выполнении программы (run-time error), если реальный экземпляр объекта Obj несовместим с классом TResourceGauge. Забегая вперед, скажем, что ошибку приведения типа можно обработать и таким образом избежать досрочного завершения приложения.

ВИРТУАЛЬНЫЕ МЕТОДЫ

ПОНЯТИЕ ВИРТУАЛЬНОГО МЕТОДА

Все методы, которые до сих пор рассматривались, имеют одну общую черту — все они статические. При обращении к статическому методу компилятор точно знает класс, которому данный метод принадлежит. Поэтому, например, обращение к статическому методу GetPereentFree в методе CheckStatus компилируется в вызов TResourceGauge.GetPercentFree:

Code:

procedure TResourceGauge.CheckStatus;

begin

if GetPereentFree <= FPercentCritical then Beep;

{ if TResourceGauge.GetPereentFree <= FPercentCritical then Beep; }

end;

Метод CheckStatus работает неправильно в наследниках TResourceGauge, так как внутри него вызов перекрытого метода GetPereentFree не происходит. Конечно, в классах TDiskGauge и TMemoryGauge можно продублировать все методы и свойства, которые прямо или косвенно вызывают GetPereentFree, но при этом теряются преимущества наследования. ООП предлагает изящное решение этой проблемы — метод GetPereentFree всего-навсего объявляется виртуальным:

Code:

type

TResourceGauge = class

...

function GetPereentFree: Integer; virtual;

...

end;

В производных классах виртуальный метод перекрывается с использованием ключевого слова override. Перекрытый метод должен иметь точно такой же формат (список параметров, а для функций еще и тип возвращаемого значения), что и перекрываемый:

Code:

type

TDiskGauge = class(TResourceGauge)

...

function GetPercentFree: Integer; override;

end;

TMemoryGauge = class(TResourceGauge)

function GetPercentFree: Integer; override;

end;

Суть виртуальных методов в том, что они вызываются по фактическому типу экземпляра, а не по формальному типу, записанному в программе. Поэтому после сделанных изменений метод CheckStatus будет работать так, как ожидает программист:

Code:

procedure TResourceGauge.CheckStatus;

begin

if GetPercentFree <= FPercentCritical then Beep;

{ if «фактический класс>.GetPercentFree <= FpercentCritical then Beep; }

end;

Работа виртуальных методов основана на механизме позднего связывания (late binding). В отличие от раннего связывания (early binding), характерного для статических методов, позднее связывание основано на вычислении адреса вызываемого метода при выполнении программы. Метод вычисляется по хранящемуся в каждом объекте описателю типа.

Благодаря механизму наследования и виртуальным методам, в Delphi реализуется такая концепция ООП как полиморфизм. Полиморфизм существенно облегчает труд программиста, так как обеспечивает повторное использование кода уже написанных методов.

АБСТРАКТНЫЕ ВИРТУАЛЬНЫЕ МЕТОДЫ

При построении иерархии часто возникает ситуация, когда работа виртуального метода в базовом классе неизвестна и наполняется содержанием только в наследниках. Так случилось, например, с методом GetPercentFree, который в классе TResourceGauge состоит всего из одного оператора: Result := 0. Конечно, тело метода можно сделать пустым или почти пустым (так мы и поступили), но лучше воспользоваться директивой abstract:

Code:

type

TResourceGauge = class

...

function GetPercentFree : Integer; virtual; abstract;

...

end;

Директива abstract записывается после слова virtual и исключает необходимость написания кода виртуального метода для данного класса. Такой метод называется абстрактным, т.е. подразумевает конкретное логическое действие, а не способ его реализации. Абстрактные виртуальные методы часто используются при создании классов-полуфабрикатов. Свою реализацию такие методы получают в законченных наследниках.

ДИНАМИЧЕСКИЕ МЕТОДЫ

Разновидностью виртуальных методов являются так называемые динамические методы. При их объявлении вместо слова virtual записывается ключевое слово dynamic, например:

Code:

type

TResourceGauge = class

...

function GetPercentFree: Integer; dynamic; abstract;

...

end;

В наследниках динамические методы перекрываются так же, как и виртуальные, т.е. с помощью зарезервированного слова override.

Семантически динамические и виртуальные методы идентичны. Различие состоит только в механизме их вызова. Методы, объявленные с директивой virtual, вызываются максимально быстро, но платой за это является большой размер системных таблиц, с помощью которых происходит их диспетчеризация. Размер этих таблиц начинает сказываться с увеличением числа классов в иерархии. Методы, объявленные с директивой dynamic, вызываются несколько дольше, но при этом таблицы диспетчирования имеют более компактный вид, что способствует экономии памяти. Таким образом, программисту предоставляются два способа оптимизации объектов: по скорости работы (virtual) или по объему памяти (dynamic).

МЕТОДЫ ОБРАБОТКИ СООБЩЕНИЙ

Специализированной формой динамических методов являются методы обработки сообщений. Они объявляются с помощью ключевого слова message, за которым следует целочисленная константа —номер сообщения, например:

Code:

type

TMyControl = class(TWinControl)

procedure WMPaint (varMessage: TWMPaint) ; message WM_PAINT;

end;

Методы обработки сообщений всегда имеют формат процедуры и содержат единственный var-параметр. При перекрытии метода его название и имя параметра не имеют значения. Вызовом соответствующего обработчика занимается метод Dispatch, наследуемый из класса TObject.

Методы обработки сообщений применяются внутри библиотеки VCL для обработки сообщений Windows и редко нужны ее пользователям, т.е. нам с вами.

КЛАССЫ В ПРОГРАММНЫХ МОДУЛЯХ

Классы очень удобно собирать в модули. При этом их описание помещается в секцию interface, а код методов — в секцию implementation. Создавая модули классов, нужно придерживаться следующих правил:

q	все классы, предназначенные для использования за пределами модуля, следует определять в секции interface;

q	описание классов, предназначенных для употребления внутри модуля, следует располагать в секции implementation;

q	если модуль В использует модуль А, то в модуле В можно определять классы, порожденные от классов модуля А.

Соберем рассмотренные ранее классы TResourceGauge, TDiskGauge и TmemoryGauge в отдельный модуль Resgauge:

Code:

unit Resgauge;

interface

type

TResourceGauge = class

private

FPercentCritical: Integer;

procedure SetPercentCritical(Value: Integer);

protected

function GetPercentFree: Integer; virtual; abstract;

public

constructor Create;

procedure CheckStatus;

property PercentFree: Integer read GetPercentFree;

property PercentCritical: Integer read FPercentCritical write SetPercentCritical;

end;

TDiskGauge = class(TResourceGauge)

private

DriveLetter: Char;

protected

function GetPercentFree : Integer; override;

public

constructor Create (ADriveLetter: Char) ;

end;

TMemoryGauge = class (TResourceGauge)

protected

function GetPercentFree: Integer; override;

end;

implementation

uses

SysUtils, Windows;

{ TResourceGauge }

constructor TResourceGauge.Create;

begin

FPercentCritical := 10;

end;

procedure TResourceGauge.SetPercentCritical(Value: Integer);

begin

if (Value >= 0) and (Value < 100) then FPercentCritical := Value;

end;

procedure TResourceGauge.CheckStatus;

begin

if PercentFree <= PercentCritical then Beep;

end;

{ TDiskGauge }

constructor TDiskGauge.Create (ADriveLetter: Char) ;

begin

inherited Create;

DriveLetter := ADriveLetter;

end;

function TDiskGauge.GetPercentFree: Integer;

var

Drive: Byte;

begin

Drive := Ord (DriveLetter) - Ord('A') + 1;

Result := DiskFree(Drive) * 100div DiskSize(Drive) ;

end;

{ TMemoryGauge }

function TMemoryGauge.GetPercentFree: Integer;

var

MemoryStatus: TMemoryStatus ;

begin

MemoryStatus.dwLength := SizeOf(MemoryStatus);

GlobalMemoryStatus(MemoryStatus);

Result := 100 - MemoryStatus.dwMemoryLoad;

end;

end.

Как можно заметить, в описании классов присутствуют новые слова private, protected и public. С их помощью регулируется видимость частей класса для других модулей и основной программы. Назначение каждой директивы поясняется ниже.

ВИДИМОСТЬ АТРИБУТОВ ОБЪЕКТА

Программист имеет возможность ограничить видимость атрибутов класса для других программистов (и для себя в том числе). Для этого служат директивы private, protected, public, published, automated (последние две директивы не используется в модуле Resgauge).

Private. Все, что объявлено в секции private, недоступно за пределами модуля. Секция private позволяет скрыть те поля и методы, которые относятся к так называемым особенностям реализации. Например, в этой секции объявлены поле FPercentCritical и метод SetPercentCritical.

Public. Поля, методы и свойства, объявленные в секции public, не имеют никаких ограничений на использование, т.е. всегда видны за пределами модуля. Все, что помещается в секцию public, служит для манипуляций с объектами и составляет программный интерфейс класса. Например, в этой секции объявлены конструктор Create, процедура CheckStatus, свойства PercentFree и PercentCritical.

Protected. Поля, методы и свойства, объявленные в секции protected, видны за пределами модуля только потомкам данного класса; остальным частям программы они не видны. Так же как и private, директива protected позволяет скрыть особенности реализации класса, но в отличие от нее разрешает другим программистам порождать новые классы и обращаться к полям, методам и свойствам, которые составляют так называемый интерфейс разработчика. В эту секцию обычно помещаются виртуальные методы чтения и записи свойств. Примером такого метода является GetPercentFree.

Published. Устанавливает правила видимости те же, что и директива public. Особенность состоит в том, что для элементов, помещенных в секцию published, компилятор генерирует информацию о типе, которая позволяет превращать объекты в компоненты визуальной среды разработки. Секцию published разрешено использовать только тогда, когда для самого класса или его предка включена директива компилятора $TYPEINFO.

Automated. Устанавливает правила видимости те же, что и директива public. Директива automated используется в наследниках класса TAutoObject при создании серверов OLE Automation. Для помещенных в эту секцию методов и свойств компилятор генерирует специальную информацию о типе, которая обеспечивает их видимость за пределами приложения.

Перечисленные секции могут чередоваться в объявлении класса в произвольном порядке, однако в пределах секции сначала следует описание полей, а потом методов и свойств. Если в определении классанет ключевых слов private, protected, public, published и automated, то дляобычных классов всем полям, методам и свойствам приписывается атрибут видимости public, а для тех классов, что порождены от классов VCL — атрибут видимости published.

Заметим, что внутри модуля не действуют никакие ограничения видимости на атрибуты реализованного в модуле класса. Это, кстати, отличается от соглашений, принятых в других языках программирования, в частности в C++.

УКАЗАТЕЛИ НА МЕТОДЫ ОБЪЕКТОВ

В Object Pascal существуют процедурные типы данных для методов объектов. Внешне объявление процедурного типа для метода отличается от обычного словосочетанием of object, записанным после прототипа процедуры или функции:

Code:

type

TFewResourcesEvent = procedure (Sender: TObject) ofobject;

Переменная такого типа называется указателем на метод (method pointer). Она занимает в памяти 8 байт и хранит одновременно ссылку на объект и адрес его метода:

Code:

var

OnFewResources: TFewResourcesEvent = nil;

Методы объектов, объявленные по приведенному выше шаблону, становятся совместимы по типу с переменной OnFewResources.

Code:

type

Tform1 = class(TForm)

procedure FewResources (Sender: TObject) ;

end;

var

Form1: Tform1;

Ecли переменную OnFewResources связать с методом FewResources объекта Form1

Code:

OnFewResources:= Form1.FewResources;

и переписать метод CheckStatus,

Code:

procedure TResourceGauge.CheckStatus ;

begin

if PercentFree <= PercentCritical then

if Assigned(OnFewResources) then OnFewResources(Self) ;

end;

то выдача предупреждения о нехватке ресурсов будет переадресована (говорят еще делегирована) методу FewResources объекта Form1. Обратите внимание, что вызов метода через указатель происходит лишь в том случае, если указатель не равен nil. Эта проверка выполняется с помощью стандартной функции Assigned, которая возвращает True, если ее аргумент является связанным указателем.

Делегирование позволяет сосредоточить в одном объекте обработку событий, возникающих в других объектах. Это избавляет программиста от необходимости порождать многочисленные классы-наследники и перекрывать в них виртуальные методы. Делегирование широко применяется в Delphi. Например, все компоненты делегируют обработку своих событий форме, на которой они находятся.

Переназначения объектов

2013-08-15T20:38:37+07:00

Существует ли возможность переключения набора данных, используемого DBNavigator на набор данных активного элемента управления без из прямого указания?

Все, что вы хотите, поместится в пару строк кода. Добавьте "TypInfo" в список используемых модулей и сделайте примерно следующее:

Code:

var

PropInfo: PPropInfo;

begin

PropInfo := GetPropInfo(PTypeInfo(ActiveControl.ClassInfo), 'DataSource');

if (PropInfo <> nil)

and (PropInfo^.PropType^.Kind = tkClass)

and (GetTypeData(PropInfo^.PropType)^.ClassType = TDataSource) then

DBNavigator1.DataSource := TDataSource(GetOrdProp(ActiveControl, PropInfo));

end;

Некоторая избыточность в проверках гарантирует вам, что вам не попадется некий странный объект (от сторонних производителей компонентов, например), имеющий свойство DataSource, но не типа TDataSource.

Взято из Советов по Delphi отВалентина Озерова

Сборник Kuliba

Сабклассинг и суперклассинг в Delphi для начинающих

2013-08-15T20:39:51+07:00

"Сабклассинг и суперклассинг в Delphi для начинающих"

В данной статье я постараюсь рассказать об использовании двух мощных средств технологии Windows API - сабклассинга и суперклассинга. Все примеры к статье были составлены мною. Вы найдете их в прикрепленном к статье файле.

Сабклассинг

Сабклассинг (subclassing) - контроль сообщений окон путем модификации оконной процедуры последних. Сабклассинг подразумевает использование изменённой оконной процедуры до оригинальной (а её можно вовсе и не использовать), позволяя нам создать сколь угодно заготовок оконных процедур для данного объекта. Хотя на практике обычно используется только одна.

Оконная процедура

Оконная процедура (window procedure) - специальная функция любого окна, имеющего дескриптор, которая принимает и обрабатывает все поступающие окну сообщения (от других программ или от Windows). Оконная процедура является косвенно вызываемой (callback) пользовательской (user-defined) функцией. Соответственно, реакцию на сообщения задаёт программист.

Оконная процедура - самое существенное из всего того, что принадлежит окну, поэтому сабклассинг является очень мощной технологией, необходимой для полноценной работы с Windows API. Важно уметь правильно обрабатывать сообщения, чтобы использовать сабклассинг.

Оконная процедура обычно назначается при создании окна, когда заполняется структура класса последнего TWndClass(Ex).

Оконная процедура имеет такой прототип:

Code:

Function XWindowProc(HWnd: THandle; Msg: Cardinal;

WParam, LParam: Integer): Integer; Stdcall;

Где X - любой префикс (можно и опустить), по которому можно идентифицировать

нужную оконную процедуру (например, Edit или New).

Рассмотрим, какие параметры передаются при вызове оконной процедуры. В параметре HWnd передаётся дескриптор окна, классу которого принадлежит оконная процедура. В параметре Msg передаётся идентификатор поступившего сообщения. В параметрах WParam и LParam передаётся дополнительная информация, которая зависит от типа посланного сообщения.

Возвращаемый функцией результат должен определить программист.

Рекомендуется обрабатывать сообщения через оператор Case:

Code:

Case Msg Of

WM_DESTROY:

End;

Чтобы сообщение не обрабатывалось оригинальной оконной процедурой, необходимо после своих действий осуществить выход из блока Case:

Code:

Case Msg Of

WM_CLOSE:

Begin

MessageBox(0, 'WM_CLOSE', 'Caption', MB_OK);

{ Осуществляем выход из текущей процедуры }

Exit;

End;

Этот способ применяется также для того, чтобы функция DefWindowProc не обрабатывала сообщение. Данная функция предназначена для выполнения стандартных действий системы при поступлении очередного сообщения. В сабклассинге она практически не используется (её роль выполняет оригинальная оконная процедура, в которой, быть может, и находится вызов DefWindowProc).

Для вызова оконной процедуры по её адресу используется функция CallWindowProc. По параметрам она аналогична любой оконной процедуре, но помимо этого она имеет еще один параметр, определяющий адрес требуемой оконной процедуры для вызова (параметр первый).

Code:

...

{ Тип первого параметра представляет собой простой указатель }

TFarProc = Pointer;

TFNWndProc = TFarProc;

...

Function CallWindowProc(lpPrevWndFunc: TFNWndProc; HWnd: HWND; Msg: Cardinal;

WParam: Integer; LParam: Integer): Integer; Stdcall;

Функция CallWindowProc позволяет нам, по сути, менять поведение окна, ведь мы можем сабклассировать его множество раз с сохранением адресов оконных процедур, а потом вызывать нужные оконные процедуры по надобности. Но на практике эта функция используется для вызова одной оригинальной оконной процедуры окна, которая была до его сабклассирования.

После детального рассмотрения основ сабклассинга непосредственно перейдём к его реализации в Delphi.

Примечание: суперклассинг, как один из видов сабклассинга, будет описан далее отдельно!

Примечание: сабклассинг для окон, принадлежащих чужим процессам, в данной статье не рассматривается! В частности, для начинающих программистов он достаточно сложен.

Основная функция сабклассирования окна: SetWindowLong. Вообще, эта функция предназначена для изменения определённого атрибута окна (функция может изменять атрибут как самого окна, так и атрибут его класса). Рассмотрим её параметры.

Объявление функции:

Code:

Function SetWindowLong(HWnd: HWND; nIndex: Integer;

dwNewLong: LongInt): LongInt; Stdcall;

Параметр HWnd определяет окно, с которым будет производиться работа. Параметр nIndex определяет индекс аттрибута, который мы хотим изменить. Пока нас будут интересовать значения GWL_WNDPROC и GWL_USERDATA. Первый индекс определяет, что изменения затронут оконную процедуру окна, второй - то, что будет изменена специальная внутренняя четырёхбайтовая переменная, которой обладает каждое окно. В ней удобно хранить адрес старой оконной процедуры при сабклассинге.

Рассмотрим, как по шагам засабклассировать окно.

Создаём заготовку новой оконной процедуры;

Помещаем в переменную GWL_USERDATA адрес старой оконной процедуры;

Изменяем адрес оконной процедуры на новый.

Последние два действия можно объединить в одно, так как функция SetWindowLong возвращает предыдущее значение изменённого параметра.

Далее я публикую примеры кода, в которых будут рассмотрены способы сабклассирования окон как средствами VCL, так и средствами WinAPI. Все примеры кода хорошо комментированы.

Сабклассинг окон на VCL

В VCL на компонентном уровне сабклассинг реализуется достаточно просто и быстро. Его использование предпочтительней, чем использование сабклассинга на WinAPI (разумеется, при программировании с VCL) - всегда, если возможно, делайте сабклассинг именно через VCL. Для сабклассирования оконного компонента необходимо расширить его функциональность путём добавления обработчика желаемого сообщения, либо через перекрытие оконной процедуры компонента.

Ниже приведен пример сабклассирования компонента TEdit таким образом, чтобы последний не реагировал на вставку текста:

Code:

Unit UMain;

Interface

Uses

Windows, Messages, SysUtils, Classes,

Graphics, Controls, Forms, Dialogs,

StdCtrls;

Type

TMainForm = Class(TForm)

procedure FormCreate(Sender: TObject);

procedure FormDestroy(Sender: TObject);

Private

{ Private declarations }

Public

{ Public declarations }

End;

{ Новый класс с дополнительным методом,

который вызвается при сообщении WM_PASTE }

TNewEdit = Class(TEdit)

Protected

{ Обработчик сообщения }

Procedure WMCopy(Var Msg: TWMPaste); Message WM_PASTE;

End;

Var

MainForm: TMainForm;

{ Экземпляр нового класса }

Edit: TNewEdit;

Implementation

{$R *.dfm}

{ TNewEdit }

Procedure TNewEdit.WMCopy(Var Msg: TWMPaste);

Begin

{ Игнорируем сообщение }

Msg.Result := 0;

End;

Procedure TMainForm.FormCreate(Sender: TObject);

Begin

{ Создание и размещение компонента на форме }

Edit := TNewEdit.Create(Self);

Edit.Parent := Self;

Edit.Left := 8;

Edit.Top := 8;

Edit.Width := MainForm.Width - 23;

{ Следующий метод работать не будет }

Edit.PasteFromClipboard;

End;

Procedure TMainForm.FormDestroy(Sender: TObject);

Begin

Edit.Free;

End;

End.

Таким образом, чтобы засабклассировать оконный компонент, нужно просто реализовать свой обработчик сообщений. Есть еще один способ, который заключается в модификации оконной процедуры компонента на VCL-уровне:

Code:

Unit UMain;

Interface

Uses

Windows, Messages, SysUtils, Classes,

Graphics, Controls, Forms, Dialogs,

StdCtrls;

Type

TMainForm = Class(TForm)

procedure FormCreate(Sender: TObject);

procedure FormDestroy(Sender: TObject);

Private

{ Private declarations }

Public

{ Public declarations }

End;

TNewEdit = Class(TEdit)

Protected

{ Перекрытая оконная процедура компонента }

Procedure WndProc(Var Msg: TMessage); Override;

End;

Var

MainForm: TMainForm;

{ Экземпляр нового класса }

Edit: TNewEdit;

Implementation

{$R *.dfm}

{ TNewEdit }

Procedure TNewEdit.WndProc(Var Msg: TMessage);

Begin

Case Msg.Msg Of

WM_PASTE:

Begin

Msg.Result := 0;

{ Звуковой сигнал, оповещающий пользователя о

невозможности вставки текста }

MessageBeep(0);

{ Выход после обработки необходим, чтобы

оригинальная оконная процедура не имела

возможности обработать WM_PASTE; в противном

случае вставка текста всё равно произойдёт }

Exit;

End;

{ Не забывайте вызывать унаследованную оконную процедуру }

Inherited WndProc(Msg);

End;

Procedure TMainForm.FormCreate(Sender: TObject);

Begin

{ Создание и размещение компонента на форме }

Edit := TNewEdit.Create(Self);

Edit.Parent := Self;

Edit.Left := 8;

Edit.Top := 8;

Edit.Width := MainForm.Width - 23;

{ Следующий метод работать не будет }

Edit.PasteFromClipboard;

End;

Procedure TMainForm.FormDestroy(Sender: TObject);

Begin

Edit.Free;

End;

End.

Этот способ по функциональности ничем не отличается от первого (только озвучкой).

Вот и всё! Думаю, что Вы разобрались в примерах и мы можем переходить к сабклассингу средствами Windows API. Ту часть кода примеров, которые не относятся к теме статьи, я снабдил краткими комментариями.

Сабклассинг окон с помощью Windows API

В следующем примере будет показано, как усовершенствовать кнопку (Button) и поле ввода (Edit). Вот список усовершенствований:

1) Для кнопки: создать такую кнопку, которая при нажатии левой кнопки мыши отображала бы текущую дату;

2) Для поля ввода: запретить контекстное меню; установить шрифт для текста синего цвета

Разберем, как это выглядит в теории. Для создания кнопки, отображающей дату, мы должны получить текущую дату функцией GetLocalTime. В переданной функции структуре будет находиться текущая дата. Нас интересует только текущие час, минута и секунда. Мы преобразуем полученные значения в строковый формат и дополняем нулями слева, если это необходимо. После этого отображаем дату на кнопке, по срабатыванию таймера.

Что касается поля ввода, то для запрета контекстного меню необходимо проигнорировать сообщение WM_CONTEXTMENU, после чего осуществить выход из оконной процедуры. Для изменения цвета текста необходимо использовать функция SetTextColor для контекста Edit'а. Этот контекст можно получить, обрабатывая сообщение WM_CTLCOLOREDIT (обратите внимание, что это сообщение посылается родительскому окну поля ввода). Данное сообщение посылается при каждой отрисовке Edit'а, передавая в параметре WParam контекст для рисования. Не следует забывать включить прозрачность фона функцией SetBkMode (хотя для нашего примера эта функция ничего не изменяет, попробуйте использовать другие цвета, чтобы убедиться в её надобности).

Code:

Program SampleProject03;

{$R *.res}

{$R WinXP.res}

Uses

Windows,

Messages,

SysUtils;

Procedure InitCommonControls; Stdcall; External'comctl32.dll';

Const

{ Идентификатор таймера }

BtnTimer = 450;

{ Константы с заголовками дочерних окон }

StaticInfoText = 'Метка без сабклассирования';

BtnText = 'Кнопка для сабклассирования';

Var

{ Главное окно }

HWnd: THandle;

{ Три дочерних компонента для сабклассирования }

Btn, Edit, InfoStatic: THandle;

{ Устанавливает для окна AWindow шрифт для контролов по умолчанию }

Procedure SetDefFont(AWindow: THandle);

Begin

SendMessage(AWindow, WM_SETFONT, GetStockObject(DEFAULT_GUI_FONT), 1);

End;

{ Косвенно-вызваемая процедура сообщений таймера }

{ Эта процедура выполняется при каждом срабатывании таймера }

Procedure BtnTimerProc(HWnd: THandle; Msg: Cardinal;

IDEvent, DWTime: Cardinal); Stdcall;

Var

{ Переменная, куда будет помещено текущее время }

Time: TSystemTime;

{ Для анализа времени }

Hour, Minute, Second: String;

Begin

{ Получаем время }

GetLocalTime(Time);

{ Инициализируем переменные }

Hour := IntToStr(Time.wHour);

Minute := IntToStr(Time.wMinute);

Second := IntToStr(Time.wSecond);

{ Добавляем нули при необходимости }

If Length(Hour) = 1Then Hour := '0' + Hour;

If Length(Minute) = 1Then Minute := '0' + Minute;

If Length(Second) = 1Then Second := '0' + Second;

{ Отображаем дату }

SetWindowText(HWnd, PChar(Hour + ':' + Minute + ':' + Second));

End;

{ Модифицированная оконная процедура поля ввода }

Function EditWinProc(HWnd: THandle; Msg: Cardinal;

WParam, LParam: Integer): Cardinal; Stdcall;

Begin

Case Msg Of

{ Запрещаем показ контекстного меню }

WM_CONTEXTMENU:

Begin

Result := 0;

MessageBeep(0);

Exit;

End;

{ Не забываем вызвать оригинальную оконную процедуру }

Result := CallWindowProc(Pointer(GetWindowLong(HWnd, GWL_USERDATA)),

Hwnd, Msg, WParam, LParam);

End;

{ Модифицированная оконная процедура кнопки }

Function BtnWinProc(HWnd: THandle; Msg: Cardinal;

WParam, LParam: Integer): Cardinal; Stdcall;

Begin

Case Msg Of

{ При нажатии мыши запускаем таймер, интервал - 10 миллисекунд }

WM_LBUTTONDOWN: SetTimer(HWnd, BtnTimer, 10, @BtnTimerProc);

{ При отпускании мыши уничтожаем таймер }

WM_LBUTTONUP:

Begin

KillTimer(HWnd, BtnTimer);

{ Восстанавливаем прежний текст }

SetWindowText(HWnd, BtnText);

End;

{ Не забываем вызвать оригинальную оконную процедуру }

Result := CallWindowProc(Pointer(GetWindowLong(HWnd, GWL_USERDATA)),

HWnd, Msg, WParam, LParam);

End;

{ Оконная процедура главного окна }

Function MainWinProc(HWnd: THandle; Msg: Cardinal;

WParam, LParam: Integer): Cardinal; Stdcall;

{ Конвертирует сроку PChar в String }

Function StrPas(Const AStr: PChar): String;

Begin

Result := AStr;

End;

Begin

Case Msg Of

{ Здесь будет произведено создание дочерних окон }

WM_CREATE:

Begin

InfoStatic := CreateWindowEx(0, 'Static', StaticInfoText,

WS_CHILD Or WS_VISIBLE Or SS_LEFT,

8, 8, 270, 16, HWnd, 0, HInstance, NIL);

SetDefFont(InfoStatic);

Edit := CreateWindowEx(WS_EX_CLIENTEDGE, 'Edit', NIL,

WS_CHILD Or WS_VISIBLE Or ES_LEFT,

8, 28, 300, 21, HWnd, 0, HInstance, NIL);

SetDefFont(Edit);

{ Выделяем весь текст }

SendMessage(Edit, EM_SETSEL, 0, -1);

{ Далее делаем сабклассинг поля ввода }

SetWindowLong(Edit, GWL_USERDATA,

SetWindowLong(Edit, GWL_WNDPROC, LongInt(@EditWinProc)));

Btn := CreateWindowEx(0, 'Button', BtnText, WS_CHILD Or WS_VISIBLE

Or BS_PUSHBUTTON, 8, 52, 300, 25, HWnd, 0,

HInstance, NIL);

SetDefFont(Btn);

{ Далее делаем сабклассинг кнопки }

SetWindowLong(Btn, GWL_USERDATA,

SetWindowLong(Btn, GWL_WNDPROC, LongInt(@BtnWinProc)));

End;

WM_KEYDOWN:

{ Закрытие окна по нажатию Enter'а }

If WParam = VK_RETURN Then PostQuitMessage(0);

{Данное сообщение посылается при отрисовке Edit'a;

вы можете использовать переданный контекст для рисования

фона, либо для смены цвета текста; после завершения рисования

верните модифицированный контекст как результат сообщения и не

забудьте сделать выход из оконной процедуры, так как в противном

случае DefWindowProc снова разукрасит Edit в стандартный системный цвет }

WM_CTLCOLOREDIT:

Begin

{ Устанавливаем прозрачность фона }

SetBkMode(WParam, TRANSPARENT);

{ Устанавливаем цвет шрифта }

SetTextColor(WParam, $FF0000);

{ Возвращаем нужный нам контекст }

Result := WParam;

Exit;

End;

WM_DESTROY:

Begin

{ Выход для освобождения памяти }

PostQuitMessage(0);

End;

{ Обработка всех остальных сообщений по умолчанию }

Result := DefWindowProc(HWnd, Msg, WParam, LParam);

End;

Procedure WinMain;

Var

Msg: TMsg;

{ Оконный класс }

WndClassEx: TWndClassEx;

Begin

{ Подготовка структуры класса окна }

ZeroMemory(@WndClassEx, SizeOf(WndClassEx));

{************* Заполнение структуры нужными значениями ******************* }

{ Размер структуры }

WndClassEx.cbSize := SizeOf(TWndClassEx);

{ Имя класса окна }

WndClassEx.lpszClassName := 'SubclassSampleWnd';

{ Стиль класса, не окна }

WndClassEx.style := CS_VREDRAW Or CS_HREDRAW;

{ Дескриптор программы (для доступа к сегменту данных) }

WndClassEx.hInstance := HInstance;

{ Адрес оконной процедуры }

WndClassEx.lpfnWndProc := @MainWinProc;

{ Иконки }

WndClassEx.hIcon := LoadIcon(HInstance, MakeIntResource('MAINICON'));

WndClassEx.hIconSm := LoadIcon(HInstance, MakeIntResource('MAINICON'));

{ Курсор }

WndClassEx.hCursor := LoadCursor(0, IDC_ARROW);

{ Кисть для заполнения фона }

WndClassEx.hbrBackground := COLOR_BTNFACE + 1;

{ Меню }

WndClassEx.lpszMenuName := NIL;

{ Регистрация оконного класса в Windows }

If RegisterClassEx(WndClassEx) = 0Then

MessageBox(0, 'Невозможно зарегистрировать класс окна',

'Ошибка', MB_OK Or MB_ICONHAND)

Else

Begin

{ Создание окна по зарегистрированному классу }

HWnd := CreateWindowEx(0, WndClassEx.lpszClassName,

'Subclassing Sample by Rrader', WS_OVERLAPPEDWINDOW AndNot WS_BORDER

AndNot WS_MAXIMIZEBOX AndNot WS_SIZEBOX,

Integer(CW_USEDEFAULT), Integer(CW_USEDEFAULT), 320, 116, 0, 0,

HInstance, NIL);

If HWnd = 0Then

MessageBox (0, 'Окно не создалось!',

'Ошибка', MB_OK Or MB_ICONHAND)

Else

Begin

{ Показ окна }

ShowWindow(HWnd, SW_SHOWNORMAL);

{ Обновление окна }

UpdateWindow(HWnd);

{ Цикл обработки сообщений }

While GetMessage(Msg, 0, 0, 0) Do

Begin

TranslateMessage(Msg);

DispatchMessage(Msg);

End;

{ Выход по прерыванию цикла }

Halt(Msg.WParam);

End;

Begin

InitCommonControls;

{ Создание окна }

WinMain;

End.

Все примеры очень простые, они должны дать Вам базовое представление о сабклассинге.

Теперь можно переходить к суперклассингу.

Суперклассинг

Сабклассинг особенно удобен, когда дело касается изменения одного окна, класс которого не совпадает с другими окнами, подлежащими сабклассированию. А что, если нам нужно засабклассировать сотню Edit'ов? Сабклассинг здесь будет громоздким. Решением этой проблемы является суперклассинг.

Суперклассинг (superclassing) - создание и регистрация нового класса окна в системе. После чего этот класс окна готов к использованию.

VCL-суперклассинг мы рассматривать не будем. Думаю, Вам понятно, что реализация суперклассинга на VCL - это создание компонентов. При создании оконного компонента в Delphi вы неявно создаёте подобие суперкласса. После этого вы можете использовать хоть сотню таких компонентов (например, создать из них массив). Заметьте, что такой компонент будет, как правило не стандартным, например, кнопка TBitBtn. Чтобы Вам было понятней, почему это суперкласс, можете посмотреть имя класса окна компонента через любой сканер окон (я использовал InqSoft Window Scanner) - это имя будет совпадать с тем именем, которое обозначает имя компонента в Delphi (например, TBitBtn или TLabeledEdit). Из этого мы можем сделать вывод, что суперклассинг прекрасно прижился в Delphi и широко там используется.

У каждого потомка класса TWinControl в Delphi есть метод CreateParams. Можете воспользоваться им, чтобы изменить название класса окна.

Гораздо более интересен суперклассинг на WinAPI. Необходимо уметь его использовать.

Рассмотрим, как по шагам создать суперкласс.

Вызываем функцию GetClassInfoEx, чтобы получить информацию о классе окна, который мы будем далее модернизировать. Эта функция заполнит переданную ей запись TWndClassEx параметрами класса;

Изменяем всё, что нам нужно в полученной записи. Нужно задать свое имя класса, размер структуры, а также дескриптор HInstance, также нас будет интересовать оконная процедура - мы также изменим её у класса;

Регистрируем новый класс при помощи функции RegisterClassEx;

По окончании работы программы освобождаем класс функцией UnregisterClass.

Далее новый класс можно использовать. В примерах я буду делать простые изменения в классах окон.

Давайте рассмотрим функции для суперклассинга более подробно.

Суперклассинг начинается с функции GetClassInfoEx.

Объявление функции:

Code:

Function GetClassInfoEx(Instance: Cardinal; Classname: PChar;

Var WndClass: TWndClassEx): LongBool; Stdcall;

Первый параметр функции - дескриптор приложения, которое создало класс. Если же Вы желаете модифицировать предопределённые класс окон Windows (например, классы 'Button', 'Edit', 'ListBox' и т. п.), то передайте нуль в параметре.

Следующий параметр - собственно название интересующего Вас класса. Сюда можно передать атом (см. ниже)

В последнем параметре передается структура типа TWndClassEx, в которую в случае успешного вызова функции будет помещена информация о классе.

Когда информация о классе получена, можно изменить его (что обязательно к этому, сказано выше).

После подготовки класса окна Вы регистрируете его в Windows с помощью функции RegisterClassEx.

Code:

Function RegisterClassEx(Const WndClass: TWndClassEx): Word; Stdcall;

Функция возвращает атом, который по сути есть числовое уникальное значение. Это будет идентификатор класса окна в системе.

По завершению работы приложения желательно уничтожить класс. В противном случае - "утечка памяти".

Для этого существует функция UnregisterClass:

Code:

Function UnregisterClass(lpClassName: PChar; hInstance: Cardinal): LongBool; Stdcall;

Эта функция уничтожает класс окна из Windows, освобождая память, ранее под него выделенную.

Первый параметр функции - имя класса для деинсталляции. Обратите внимание, что эта функция сможет уничтожить только класс, который был зарегистрирован приложением, чей дескриптор передан во втором параметре. Глобальные предопределённые классы (см. выше) Windows (например, класс Edit) не могут быть уничтожены. В первом параметре также разрешается передавать атом-идентификатор класса.

Для полного ознакомления с суперклассингом следует обобщить знания о самом классе окна.

Класс окна

Вообще, класс окна - объемная тема. Мы рассмотрим её самые главные особенности.

Класс окна (window class) - набор свойств, который используются как шаблон для создания окон. Класс окна всегда можно расширить, изменить. Давайте подробнее разберем атрибуты класса.

Первый атрибут - имя класса. Оно позволяет отличать одни классы от других. Классы с одинаковыми именами считаются идентичными. После создания окна по классу это окно может подвергнуться сабклассингу. Сабклассинг не изменяет класс окна. Не делайте имена классов длиннее 64 символов.

Второй атрибут - это адрес оконной процедуры для окна. Об оконной процедуре подробно рассказано выше.

Третий атрибут - дескриптор приложения (или DLL), которое зарегистрировало класс.

Четвёртый - курсор окна при создании.

Пятый - дескриптор большой иконки для окна.

Шестой - тоже дескриптор иконки, но маленькой. Этого атрибута нет у структуры типа TWndClass (поняли, в чем отличие TWndClass от TWndClassEx?).

Седьмой - дескриптор кисти, которой будет зарисована клиентская область окна.

Восьмой - дескриптор меню, которое присваивается окну при создании.

Девятый - стили класса (см. ниже)

Десятый - дополнительная память, выделяемая классу (тип Integer).

Одиннадцатый - дополнительная память (Integer), выделяемая под каждое окно класса.

Напоследок рассмотрим стили класса. Стили класса - это комбинация значений, которые определяют поведение класса.

Вот они:

CS_BYTEALIGNCLIENT - выстраивает клиентскую часть окна на границу байта, что позволяет достичь большей производительности при отрисовке;

CS_BYTEALIGNWINDOW - то же, что и CS_BYTEALIGNCLIENT, только увеличивает производительность при перемещении окна;

CS_CLASSDC - создает контекст устройства, который разделяется между всеми наследниками этого класса - общий контекст для рисования;

CS_DBLCLKS - разрешает обработку сообщений при двойном щелчке мыши;

CS_GLOBALCLASS - разрешает создание окон с независимыми идентификаторами (HInstance) приложений. Создаётся глобальный класс. Если этот флаг не указан, то значение HInstance при создании окна должно быть таким же как и при регистрации класса RegisterClass(Ex).

CS_HREDRAW - перерисовывает окно при его перемещении по горизонтали (и при изменении горизонтальных размеров);

CS_VREDRAW - перерисовывает окно при его перемещении по вертикали (и при изменении вертикальных размеров);

CS_NOCLOSE - убирает команду "Закрыть" из системного меню окна;

CS_OWNDC - создает уникальный контекст устройства для каждого вновь создаваемого окна.

На суперклассинг я публикую один пример, в котором на главном окне будет создано 10 "измененных" Edit'ов. Каждый такой Edit при клике на нём мышки уничтожит себя сам.

Code:

Program SampleProject04;

{$R *.res}

{$R WinXP.res}

Uses

Windows, Messages;

Procedure InitCommonControls; Stdcall; External'comctl32.dll';

Var

{ Главное окно }

HWnd: THandle;

{ Массив Edit'ов }

Edits: Array[0..9] Of THandle;

{ Сюда будет помещено значение оригинальной оконной процедуры класса Edit }

OldProc: Pointer;

{ Устанавливает для окна AWindow шрифт для контролов по умолчанию }

Procedure SetDefFont(AWindow: THandle);

Begin

SendMessage(AWindow, WM_SETFONT, GetStockObject(DEFAULT_GUI_FONT), 1);

End;

{ Модифицированная оконная процедура каждого поля ввода }

Function EditWinProc(HWnd: THandle; Msg: Cardinal;

WParam, LParam: Integer): Cardinal; Stdcall;

Begin

Case Msg Of

{Уничтожение Edit'а }

WM_LBUTTONDOWN: DestroyWindow(HWnd);

End;

{ Вызов оригинальной оконной процедуры }

Result := CallWindowProc(OldProc,

HWnd, Msg, WParam, LParam);

End;

{ Оконная процедура главного окна }

Function MainWinProc(HWnd: THandle; Msg: Cardinal;

WParam, LParam: Integer): Cardinal; Stdcall;

Var

TmpEdit: TWndClassEx;

I: Integer;

Begin

Case Msg Of

{ Здесь будет произведено создание дочерних окон }

WM_CREATE:

Begin

{ Начало суперклассинга }

IfNot GetClassInfoEx(0, 'Edit', TmpEdit) Then Halt;

{ Запоминаем оконную процедуры для правильной работы окна }

OldProc := TmpEdit.lpfnWndProc;

{ Модификация класса }

TmpEdit.cbSize := SizeOf(TWndClassEx);

TmpEdit.lpfnWndProc := @EditWinProc;

TmpEdit.lpszClassName := 'Sample04EditWindowClass';

TmpEdit.hInstance := GetModuleHandle(NIL);

{ Регистрация класса }

If RegisterClassEx(TmpEdit) = 0Then Halt;

{ Подготовка массива }

FillChar(Edits, SizeOf(Edits), 0);

For I := Low(Edits) To High(Edits) Do

Begin

Edits[I] := CreateWindowEx(WS_EX_CLIENTEDGE,

'Sample04EditWindowClass', 'Sample',

WS_CHILD Or WS_VISIBLE Or ES_LEFT,

8, 28, 300, 21, HWnd, 0, HInstance, NIL);

SetDefFont(Edits[I]);

End;

WM_KEYDOWN:

{ Закрытие окна по нажатию Enter'а }

If WParam = VK_RETURN Then PostQuitMessage(0);

WM_DESTROY:

Begin

{ Уничтожение классов}

UnregisterClass('Sample04EditWindowClass', HInstance);

{ Выход для освобождения памяти }

PostQuitMessage(0);

End;

{ Обработка всех остальных сообщений по умолчанию }

Result := DefWindowProc(HWnd, Msg, WParam, LParam);

End;

Procedure WinMain;

Var

Msg: TMsg;

{ Оконный класс }

WndClassEx: TWndClassEx;

Begin

{ Подготовка структуры класса окна }

ZeroMemory(@WndClassEx, SizeOf(WndClassEx));

{************* Заполнение структуры нужными значениями ******************* }

{ Размер структуры }

WndClassEx.cbSize := SizeOf(TWndClassEx);

{ Имя класса окна }

WndClassEx.lpszClassName := 'SuperclassSampleWnd';

{ Стиль класса, не окна }

WndClassEx.style := CS_VREDRAW Or CS_HREDRAW;

{ Дескриптор программы (для доступа к сегменту данных) }

WndClassEx.hInstance := HInstance;

{ Адрес оконной процедуры }

WndClassEx.lpfnWndProc := @MainWinProc;

{ Иконки }

WndClassEx.hIcon := LoadIcon(HInstance, MakeIntResource('MAINICON'));

WndClassEx.hIconSm := LoadIcon(HInstance, MakeIntResource('MAINICON'));

{ Курсор }

WndClassEx.hCursor := LoadCursor(0, IDC_ARROW);

{ Кисть для заполнения фона }

WndClassEx.hbrBackground := COLOR_BTNFACE + 1;

{ Меню }

WndClassEx.lpszMenuName := NIL;

{ Регистрация оконного класса в Windows }

If RegisterClassEx(WndClassEx) = 0Then

MessageBox(0, 'Невозможно зарегистрировать класс окна',

'Ошибка', MB_OK Or MB_ICONHAND)

Else

Begin

{ Создание окна по зарегистрированному классу }

HWnd := CreateWindowEx(0, WndClassEx.lpszClassName,

'Superclassing Sample by Rrader', WS_OVERLAPPEDWINDOW AndNot WS_BORDER

AndNot WS_MAXIMIZEBOX AndNot WS_SIZEBOX,

Integer(CW_USEDEFAULT), Integer(CW_USEDEFAULT), 320, 116, 0, 0,

HInstance, NIL);

If HWnd = 0Then

MessageBox (0, 'Окно не создалось!',

'Ошибка', MB_OK Or MB_ICONHAND)

Else

Begin

{ Показ окна }

ShowWindow(HWnd, SW_SHOWNORMAL);

{ Обновление окна }

UpdateWindow(HWnd);

{ Цикл обработки сообщений }

While GetMessage(Msg, 0, 0, 0) Do

Begin

TranslateMessage(Msg);

DispatchMessage(Msg);

End;

{ Выход по прерыванию цикла }

Halt(Msg.WParam);

End;

Begin

InitCommonControls;

{ Создание окна }

WinMain;

End.

Этобылобазовоезнакомствоссабклассингомисуперклассингом. Надеюсь, материалданнойстатьипоможетВамприпрограммировании!

Автор:Rrader

Взято с Vingrad

Сущность ООП

2013-08-15T20:37:40+07:00

Одна из вещей, которую вы могли бы захотеть реализовать - пользовательский интерфейс, предоставляющий доступ к файлу персональных данных. ООП предоставляет вам безусловно лучшие механизмы для его хранения, создания, и эксплуатации, делая эти вещи понятными и легкими для понимания.

Вот как вы можете сделать это. Забудьте об диалоговом окне хотя бы на минуту и сконцентрируйтесь на создании файла персональных данных. Скажем, вы редактируете запись человека со следующими полями: First Name, Last Name, Age и Active. Скажем, вам нужны следующие операции при работе с записью: добавление, изменение, удаление и построение списка.

Вам необходимо создать невизуальный объект доступа к файлу, инкапсулирующий вышеупомянутую функциональность. Это может выглядеть приблизительно так:

Code:

interface

PPersonRecord = ^TPersonRecord;

TPersonRecord = record

FirstName: string;

LastName: string;

Age: Byte;

Active: Boolean;

end;

TPersonFile = class(TObject)

private

FFileName: TFileName;

FFile: fileof TPersonRec;

public

constructor Create(AFileName: TFileName);

destructor Destroy; override;

procedure LoadRecord(Index: Integer);

procedure SaveRecord(Index: Integer);

procedure Add(NewPersonRecord: TPersonRecord);

procedure Change(ChangedPersonRecord: TPersonRecord; Index: Integer);

procedure Delete(Index: Integer);

procedure List(AStringList: TStringList);

property Person[Index: Integer]: TPersonRecord read LoadRecord write

SaveRecord;

end;

implementation

constructor TPersonFile.Create(AFileName: TFileName);

begin

inherited.Create;

AssignFile(FFile, AFileName);

Reset(FFile, SizeOf(TPersonRec));

New(FPersonRecord);

end;

destructor TPersonFile.Destroy;

begin

CloseFile(FFile);

Dispose(FPersonRecord);

inherited Destroy;

end;

function TPersonFile.LoadRecord(Index: Integer): PPersonRec;

begin

{ позиция файла в точке коррекции для чтения записи }

{ ... }

end;

procedure TPersonFile.SaveRecord(Index: Integer);

begin

{ позиция файла в точке коррекции для записи записи }

{ ... }

end;

procedure TPersonFile.Add(NewPersonRecord: TPersonRecord);

begin

{ файл позиционируется в конец для записи записи }

{ ... }

end;

procedure TPersonFile.Change(ChangedPersonRecord: TPersonRecord; Index:

Integer);

begin

{ именение TStatus ??? }

{ позиция файла в точке коррекции для записи записи }

{ ... }

end;

procedure TPersonFile.Delete(Index: Integer);

begin

{ изменение TStatus ??? }

{ позиция файла в точке коррекции для записи записи }

{ ... }

end;

procedure TPersonFile.List(AStringList: TStringList);

begin

{ в цикле обходим все записи, пополняя AStringList??? }

end;

OK, я надеюсь вы поняли мою идею. Вышеприведенный код взят мною из головы и, вероятно, несвободен от ошибок, поскольку я не до конца понял как работает тип file (для доступа к бинарному файлу я использую TFileStream), но идея следующая: инкапсуляция ваших функций работы с файлом в невизуальный объект как показано выше.

Теперь вы можете начать думать о ваших диалогах. Вам необходимо создать диалог, у которого в обработчике события OnCreate была бы примерно такая строчка кода:

Code:

MyPersonFile := TPersonFile.Create('c:\person.dat');

Естественно, вам необходим модуль, в котором вы объявляете TPersonFile в секции используемых модулей, а в классе формы необходимо поле с именем MyPersonFile. Вам также необходимо помнить об освобождении MyPersonFile в методе формы onClose. Я думаю вы сообразите как разместить в вашей программе необходимые элементы управления (менюшки, кнопки и прочие причиндалы), хотя бы для того, чтобы с помощью них можно было бы открыть файл.

Теперь вы должны разместить на форме компоненты типа Edit, CheckBox и др., отображающие и позволяющие редактировать поля записи через свойство Record. Убедитесь в том, что вы поддерживаете должный порядок, и освобождаете объект (запись) после его создания и использования. Конечно, эту работу красивой не назовешь, но от нее вас никто еще не освобождал. Вот красота ООП:

*После создания комбинации объект / форма диалога вся работа уже сделана.*

Вот другая хорошая вещь:

*Если вы изменяете ваш пользовательский интерфейс (например, при отказе от кучи диалогов или от использования Delphi (молчу-молчу)), ООП предоставляет вам простой и легкий в использовании способ переноса логики приложения, инкапсулированной в объекте TPersonFile.

https://delphiworld.narod

DelphiWorld 6.0

Демонстрация DefineProperties

2013-08-19T16:43:08+07:00

Хорошо, создайте на основе опубликованного ниже кода модуль PropDemo.pas и добавьте новый компонент в палитру компонентов. Расположите его на форме и сохраните ее. Затем посмотрите файл DFM каким-либо шестнадцатиричным редактором и проверьте наличие определенных свойств по их именованным тэгам. Вы можете также попробовать закрыть форму и модуль, а затем открыть его с помощью пункта меню File | Open file..., изменив тип файла в выпадающем списке на *.DFM.

Mike Scott

Mobius Ltd.

Code:

unit PropDemo;

{ Демонстрация DefineProperties.Mike Scott, CIS 100140,2420. }

interface

uses

SysUtils, WinTypes, WinProcs, Messages, Classes, Graphics, Controls,

Forms, Dialogs;

type

TDemoProps = class(TComponent)

private

{ Private declarations }

FStringThing: string;

FThing: record

i, j, k: integer;

x, y: real;

ch: char;

end;

procedure ReadStringThing(Reader: TReader);

procedure WriteStringThing(Writer: TWriter);

procedure ReadThing(Stream: TStream);

procedure WriteThing(Stream: TStream);

protected

{ Protected declarations }

procedure DefineProperties(Filer: TFiler); override;

public

{ Public declarations }

constructor Create(AOwner: TComponent); override;

published

{ Published declarations }

end;

procedureRegister;

implementation

constructor TDemoProps.Create(AOwner: TComponent);

begin

inherited Create(AOwner);

{ создайте любые данные, чтобы было что передать в поток}

FStringThing := 'Всем привет!';

with FThing do

begin

i := 1;

j := 2;

k := 3;

x := PI;

y := 180 / PI;

ch := '?';

end;

procedure TDemoProps.ReadStringThing(Reader: TReader);

begin

FStringThing := Reader.ReadString;

end;

procedure TDemoProps.WriteStringThing(Writer: TWriter);

begin

Writer.WriteString(FStringThing);

end;

procedure TDemoProps.ReadThing(Stream: TStream);

begin

Stream.ReadBuffer(FThing, sizeof(FThing));

end;

procedure TDemoProps.WriteThing(Stream: TStream);

begin

Stream.WriteBuffer(FThing, sizeof(FThing));

end;

procedure TDemoProps.DefineProperties(Filer: TFiler);

begin

inherited DefineProperties(Filer);

Filer.DefineProperty('StringThing', ReadStringThing, WriteStringThing,

FStringThing <> '');

Filer.DefineBinaryProperty('Thing', ReadThing, WriteThing, true);

end;

procedureRegister;

begin

RegisterComponents('Samples', [TDemoProps]);

end;

end.

Взято из Советов по Delphi отВалентина Озерова

Сборник Kuliba

Использование записей для хранения информации полей

2013-08-19T16:44:21+07:00

Code:

{

You sometimes wish to store multiple information in a given class like

in the example: alltogether when it belongs together.

Thus accessing this information from out of the class can be achieved

using property declaration. Its a good way to "clean your code" and

make it as "logic" as possible.

You also may have to store or load information from your class using

file or stream technology. This can be done at once for the recorded

information from within the given class.

}

type

TPersonRecord = Record

FirstName: String;

LastName: String;

BirthDate: TDate;

End;

TForm4 = class(TForm)

Button1: TButton;

procedure Button1Click(Sender: TObject);

private

fActualUser: TPersonRecord;

...

procedure SaveActualUser(S: TFileStream); // it's an example

procedure LoadActualUser(S: TFileStream);

...

public

property FirstName: stringread fActualUser.FirstName

write fActualUser.FirstName;

property LastName : stringread fActualUser.LastName

write fActualUser.LastName;

property BirthDate: TDate read fActualUser.BirthDate

write fActualUser.BirthDate;

end;

procedure TForm4.SaveActualUser(S: TFileStream);

begin

// All that stuff at once in your Stream

S.Write(fActualUser, SizeOf(fActualUser))

end;

procedure TForm4.LoadActualUser(S: TFileStream);

begin

// All that stuff at once back in your class

S.Read(fActualUser, SizeOf(fActualUser));

end;

https://delphiworld.narod

DelphiWorld 6.0

Как скрыть свойства объекта?

2013-08-19T16:39:50+07:00

В иерархии VCL в большинстве случаев существует уровень объектов-"предшественников" (TCustomXXXX), в которых многие свойства скрыты. Для унаследованных от таких "предшественников" объектов можно "открывать" на выбор те или иные свойства. А как можно скрыть свойства, которые объявлены в published-области от Object Inspector'а, но при этом оставить возможность доступа во время работы программы? Решение состоит в объявлении свойства "по новой" в public-области. В примере скрытым будет у объекта TMyControl свойство Height.

Code:

TMyControl = class(TWinControl)

protected

procedure SetHeight(Value: Integer);

function GetHeight: Integer;

public

property Height: Integer read GetHeight write SetHeight;

end;

procedure TMyControl.SetHeight(Value: Integer);

begin

inherited Height := Value;

end;

function TMyControl.GetHeight;

begin

Result := inherited Height;

end;

Можно ли динамически изменять свойство owner компонента во время выполнения программы?

2013-08-19T16:42:05+07:00

Вы можете менять свойство "owner" и после создания компонента с помощью методов InsertComponent() и RemoveComponent().

Взято из

DELPHI VCL FAQПеревод с английского

Подборку, перевод и адаптацию материала подготовил Aziz(JINX)

специально для Королевства Дельфи