У меня Есть 2 Вопроса по Turbo Pascal 7.0:
1) Это даже не вопрос, а факты о противоречии разных авторов об одних вещах, - вопрос касается <структуры> Множество <set of ...>
Привожу Цитаты:
a) <... Исходя из особенностей внутреннего представления множеств можно сделать два основных вывода: [...] - все операции над множествами выполняются значительно эффективней, чем над другими структурами данных>
Рапаков Г. Г. (или как там), Ржеуцкая С. У. "Программирование на языке Pascal" Spb 2004. стр 282
б)<... Одна из причин редкого применения - очень низкая скорость выполнения операции с множествами.>
Издательская группа BHV "Турбо Паскаль 7.0" Киев 1999г. стр 157
Исходя из внутреннего устройство множества в Tubo Pascal я склонен верит первому высказыванию, и смело переписал некоторые фрагменты одной своей программы с их помощью. However, работа с отдельными битами нам не разрешена (даже в asm'е мы логически складываем, умножаем отдельные БАЙТЫ, чтобы переключить нужный нам бит). У кого-нибудь есть размышления (а лучше конкретные факты в пользу одной из двух высказываний).
p.S. Если кто-то посоветует сравнить книги по остальному содержанию, то он может дальше не читать
2) Вопрос второй касается распределения памяти. Вот фрагмент программы, которая корректно работает:
Главный Pas файл.
{=============================================}
{ Программа просит ввести аргументы и соответствующие им значения
функции. Затем Она Интерполирует их методом Лагранжа и получает
уравнение для зависимости. Далее Программа строит график этой функции
}
{ например вы знаете что x0 = 0 y0 = 0; x1 = 2 y1 = 4; x3 = 1; y3 = 1;
а она вам скажет что f(x) = x^2 }
{$N+}
Uses Crt, Polynom, Graph;
Const
lY: longint = 0; { Количество аргументов }
Var
i, j : integer; { счетчики }
pMassY: PdMass; { значения функции }
pMassX: PdMass; { аргументы }
pPolin: PdMass; { Указатель на полином }
pFunk : pointer; { Указатель на функцию }
procedure Init;
begin
{ Ввод pMassX и pMassY }
end;
{ Дальше я построю график данной функции }
function f(x: double): Double; far;
{ Считаем полином }
Var
i: integer;
y: Double;
begin
y:= pPolin^[1];
for i:= 2 to lY do y:= y * x + pPolin^[i];
f:= y
end;
{----------------------------------------------------------------------------}
begin
Init;
pPolin:= pBuildPol(lY, pMassX, pMassY); { Вот наш полином!!!!!!!!!!!!!!!! }
{ Включаем графику }
{ Сохраняем адрес функции, чтобы передать его в процедуру }
pFunk:= @f;
{ Передаем указатель на аргументы, их количество, указатель на функцию, и координаты окна в котором вывести график }
DrawShedule(pMassX, lY, pFunk, 30, 30, 600, 400);
{ Выключи графику }
...
end.
{---------------------------------------------------------------------------------}
{ А вот модуль Polynom, где процедура DrawShedule }{=============================================}
{$N+}
Unit Polynom;
interface
....
Type
...
TFunk = function (x: double): Double;
...
procedure DrawShedule(... p: Pointer...);
{ тут p = @f }
....
implementation
...
procedure DrawShedule(... p: Pointer ...); { тут p = @f }
....
Var
f : TFunk; { функция, график которой надо построить }
begin
....
@f:= p; { связываю переменную f с функцией адрес, которой лежал в p}
...
{ И используем её }
dX:= f(x)
end;
...
end.
{==============================================}
Вот таким способом я передал функцию в процедуры построения графика. Немного короче было бы передать функцию так
procedure DrawShedule(... f: TFunk ...); а вызов DrawShedule(... f ...);
Но об этом разговор дальше.
Так программа рабочая, я вставляю текст в виртуальный метод в другой программе
{==============================================}
interfaсe
.............
TMass = Object(TAssembly) {TAssembly - абстрактный класс }
Private
{ Данные } ...
Public
{ Методы } ...
Procedure Job; Virtual; {вот сюда}
end;
............
implementation
............
Procedure TMass.Job;
Var
......
pPolin: PdMass; { Указатель на коэффициенты полинома }
pFunc : Pointer;
......
{----------------------------------------------------------------------------------}
function f(x: double): Double; far;
{ И Горнор пригодился/ или Горнер xD }
Var
i: integer;
y: Double
begin
y:= pPolin^[1];
for i:= 2 to lX do y:= y * x + pPolin^[i];
f:= y
end;
{-----------------------------------------------------------------------------------}
begin
pFunc:= @f; { Сохраняем адрес }
pPolin:= pBuildPol(lX, pMassX, pMassY); { Вот наш полином!!!!!!!!!!!!!!!! }
{ Включаем графику }
{ Покажи график }
DrawShedule(... pFunc ...);
{ В гробу я видел эту интерполяцию xD }
end;
......
end.
{ Модуль Polynom остался прежним }
{==============================================}
Так Вот, Господа, приверженцы передачи имени процедуры с помощью типа в данном случае компилятор даже не захочет с вами общаться, Утверждая, Что то, что вы передаете в процедуру DrawShedule(... f ...) не указывает на область памяти, это про "f".
Передавая указатель, как в данном случае я и написал, компилятор не может отследить этот факт и благополучно компилирует программу.
Но, когда программа доходит до использования функции f - начинаются проблемы....
Они связанны с.....?? Это и есть мой вопрос.
Мой рассуждения. У виртуального метода локальная функция хранится либо в стеке, либо в сегменте кода, поэтому компилятор не захочет передавать имя функции в качестве формального параметра, ведь он боится, что на этапе позднего связывания, он не сможет определить расположение функции.
Рассуждения, как решить проблему: расположить код функции по конкретному адресу в памяти ( где-то тут $C000:0000 ) - Но как это реализовать?
А еще может мои рассуждения просто чушь, Посему я и обратился к Вам! Тема покажет, какие тут программисты на форуме.
p.s.s отдельная программа работает, как и при передаче имени функции, так и при передачи её адреса (как я написал). В виртуальном методе при передачи имени функции компилятор не захочет с вами иметь дело. А вот при передачи адреса он с вами будет дружить, он то будет, а вот процессор нет...
Ну, ваши соображения, уважаемые пользователи форума!
Не Забывайте я задал 2 вопроса
Приведите не эти обрывки, а нормально компилирующуюся программу, если хотите, чтоб Вам помогли в чем-то разобраться.
