Валентин Озеров - Советы по Delphi. Версия 1.4.3 от 1.1.2001

functionProc5( varMyVal : LongInt) : LongInt; far;

implementation

usesDialogs;

functionProc1(var MyVal : LongInt) : LongInt;

begin

MessageDlg('Процедура 1', mtInformation, [mbOK], 0);

Proc1 := 6;

end;

functionProc2( varMyVal : LongInt) : LongInt;

begin

MessageDlg('Процедура 2', mtInformation, [mbOK], 0);

Proc2 := 3;

end;

functionProc3( varMyVal : LongInt) : LongInt;

begin

MessageDlg('Процедура 3', mtInformation, [mbOK], 0);

Proc3 := 4;

end;

functionProc4( varMyVal : LongInt) : LongInt;

begin

MessageDlg('Процедура 4', mtInformation, [mbOK], 0);

Proc4 := 5;

end;

functionProc5( varMyVal : LongInt) : LongInt;

begin

MessageDlg('Процедура 5', mtInformation, [mbOK], 0);

Proc5 := 1;

end;

initialization

{ инициализируем содержание массива указателей на функции }

@ProcTable[1] := @Proc1;

@ProcTable[2] := @Proc2;

@ProcTable[3] := @Proc3;

@ProcTable[4] := @Proc4;

@ProcTable[5] := @Proc5;

end.

Я думаю это можно сделать приблизительно так: объявите в каждой форме процедуры, обрабатывающие нажатие кнопки, типа процедуры CutButtonPressed(Sender:TObject) of Object; затем просто назначьте события кнопок OnClick этим процедурам при наступлении событий форм OnActivate. Этот способ соответствует концепции ОО-программирования, но если вам не нравится это, то вы все еще можете воспользоваться указателями функций, которая предоставляет Delphi.

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

Пример: (Здесь может встретиться пара синтаксических ошибок — я не компилил это)

type

TBaseForm = class(TForm)

public

procedureMethod1; virtual; abstract;

end;

type

TDerivedForm1= class(TBaseForm)

public

procedureMethod1; override;

end;

TDerivedForm2= class(TBaseForm)

public

procedureMethod1; override;

end;

procedure TDerivedForm1.Method1;

begin

…

end;

procedureTDerivedForm2.Method1;

begin

…

end;

{Для вызова функции из вашего toolbar, получите активную в настоящий момент форму и вызовите Method1}

procedureOnButtonClick;

var

AForm: TBaseForm;

begin

AForm := ActiveForm asTBaseForm;

AForm.Method1;

end

Что лично я использую, чтобы вызвать какую-то функцию из DLL:

1. Объявите тип:

typeTYourDLLFunc = function(Parm1: TParm1; Parm2: TParm2): TParm3;

2. Объявите переменную этого типа:

var YourDllFunc: TYourDLLFunc;

3. Получаем дескриптор DLL:

DLLHandle := LoadLibrary('YourDLL.DLL');

Получаем адрес функции:

@YourDLLFunc := GetProcAddress(DLLHandle, 'YourDLLFuncName');

Для использования функции теперь используйте переменную YourDLLFunc, например:

Parm3 := YourDLLFunc(Parm1, Parm2);

Сначала вы должны создать тип:

TypePinteger: ^Integer;

VarMyPtr: Pinteger;

Мне кажется, что в начале вы использовали плохой пример, имеет смысл использовать 32-битный указатель для 16-битной величины или распределять 10 байт для переменной.

Pascal позволяет вам использовать методы NEW и DISPOSE, которые автоматически распределяют и освобождают правильные размеры блока.

Например,

NEW(MyPtr) = GetMem(MyPtr, Sizeof(MyPtr)).

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

Для полноты, это должно быть:

NEW(MyPtr) = GetMem(MyPtr, SizeOf(MyPtr^));

SizeOf(MyPtr) всегда будет равен 4 байта, как 16-битный указатель.

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

Type

pIntArr = ^IntArr;

IntArr = Array[1..1000] ofInteger;

Var

MyPtr : pIntArr;

Begin

GetMem(MyPtr, 10); { 10 = SizeOf(Integer) * 5 !!}

{ MyPtr[2]:=1; }

<<<< Заполняем массив >>>>

MyPtr[2]^:=1;

FreeMem(MyPtr,10);

End;

Технология похожа на ту, которуя Delphi использует при работе с pchar. Синтаксис очень похож:

typeintarray = array[0..20000] ofinteger;

procedureTForm1.Button1Click(Sender: TObject);

var

xptr: ^IntArray;

begin

GetMem(xptr, 10);

xptr^[idx] := 1; { где idx от 0 до 4, поскольку мы имеем 10 байте = 5 целых }

FreeMem(xptr, 10);

end;

Обратите внимание на то, в вам в действительности нет необходимости распределять массив для 20,000 элементов, но проверка диапазона Delphi не будет работать, если диапазон равен 20,000. (Предостережение будущим пользователям!)

В Delphi 1, для того, чтобы получить самый большой возможный участок памяти, мы могли использовать функцию MemAvail, существует ли эквивалент этой функции в Delphi 2?

Нет. Но чтобы получить аппроксимированную сумму доступной памяти, можно воспользоваться функцией API GlobalMemoryStatus (через поле dwAvailVirtual возвращаемой структуры TMemoryStatus).

Steve Schafer

Nomadicсоветует:

Так можно помещать в один блок памяти записи из TList (TCollection):

imlementation

{ To use the value of AHIncr, use Ofs(AHIncr). }

procedureAHIncr; far; external'KERNEL' index114;

const

NEXT_SELECTOR: string[13] = 'NEXT_SELECTOR';

functionWriteData: THandle;

var

DataPtr: PChar;

i: Integer;

begin

Result := GlobalAlloc(GMEM_SHARE orGMEM_ZEROINIT, {pазмеp большого блока});

ifResult = 0 thenExit;

DataPtr := GlobalLock(Result);

{записываем кол-во эл-тов}

Inc(DataPtr, {pазмеp счетчика эл-тов})

fori := 0 to{некий}Count-1 do begin