Ограничение для выделения памяти под массив Опции

[Вячеслав Л.]

Как надо написать в var'e, когда необходимо выделить некоторое количество ячеек для массива?

Код

var
a:array[1..?] of integer;
...

write('kakoe koli4estvo simvolov bydet v massive');
readln(n);

for i:=1 to n do
{zapolnenie masiva lyubym sposobom}

Если место ? написать n, вылетает ошибка, тогда что должно быть место вопросительного занка? Нельзя же просто писать максимальную цифру от фонаря, типа 9999?

[Вячеслав Л.]

то непонимание тобой 5-й строки говорит о том, что ты невнимательно прочитал или не понял где-то выше по тексту, т.е. то, что скрывается за предыдущими 4-мя строками.

Специально, чтобы не было таких предложений, я привел краткий конспект вышесказанного. Про "Процедура FreeMem( var p: Pointer; size: Word ) ... " я там объяснения не нашел.

Невозможно ничего объяснить, не опираясь на что-то из того, что человеку уже известно. Поэтому расскажи, что ты знаешь о работе с памятью в компьютере.

Что именно тебя интересует? Одна ячейка памяти - это один бит, байт это 8 бит, ... 1 Кб = 1024 Байт и т. д. Касаемо памяти в Паскале, знаю только общие фразы из учебника (типа: каждой переменной должна быть присвоена определенная ячека памяти, тип Integer ограничивается таким-то числом, тип Longint ограничивается таким-то числом - краткий пересказ, не придирайтесь : ))

Ну просто array of написать не получится.
Но можно сделать так:

Смотри посты выше.

Слав, я тебе от души советую: научись придавать значение каждому слову в том, что читаешь.

Буду стараться...

Нда, тогда действительно у меня возникает путаница. В строчке

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

Тогда есть ошибка, имелось в виду, насчет динамической памяти. Я так понимаю FreeMem образовано от английского Free Memory (свободная память), соответственно, я нашел немного не насчет динамических массивов, а насчет динамической памяти.

Ошибиться довольно легко, потому что в сети масса недоразумений по этому поводу.

Согласен.

Если ты теперь действительно являешься счастливым обладателем FPC,

Действительно, являюсь - FPC 2.2.2

Что значит вот это

c: array of record

и вот это

d: double;

?

SetLength я, так, понял действует только для динамических массивов и во FPC?

Строчка SetLength(a,10) - означает присвоить массиву a память под 10 элементов. То есть если бы пользователь сам вводил количество элеметов массива для которых он хотел решать задачу, то было бы:

...
writeln('vvedite kol-vo elementov massiva');
readln(n);
...
setlength(a,n);
...

Или нет?

Процедура SetLength имеет такое же название, как аналогичная процедура для типа String.

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

Если же все же возникнет нужда - скажи, объясним )).

Нужда, кажется, возникнет: в основном в учебниках я встречаю FreeMem, хотелось бы знать конкретнее. Все таки интересно, что это значит ?

"Процедура FreeMem( var p: Pointer; size: Word ) освобождает участок памяти, адрес начала которого определен указателем p, а размер - параметром size. Значение указателя p становится неопределенным."

[Lapp]

Сначала о простом:
double - это один из вещественных типов. Занимает в паямяти 8 байт. Используется для расчетов повышенной точности (по сравнению с single, 4 байта, и real, 6 байт).
record - тип "запись", представляющий набор полей (переменных разных типов), сейчас рассказывать не буду, пройдешь позже. Извини, что упомянул.

краткий пересказ, не придирайтесь

Дело не в краткости. Дело в том, что ты не упомянул такое понятие, как адресация, а оно тут ключевое. Организация памяти - побайтовая, у каждого байта - адрес (грубо говоря, его номер). Если мы имеем дело с многобайтовой структурой (integer, string..), то ее адресом является адрес первого байта.

Адреса всех объявленных переменных зашиты намертво в программу. Но если мы хотим в программе использовать дополнительную память, то мы должны запросить ее у системы (ОС). Если у ОС память есть, она выделяет запрошенное нам количество байт (и записывает себе, что они теперь в деле) и выдает нам адрес начала этого куска. Эту память (начиная с выделенного адреса, и столько, сколько запросили) мы можем использовать (как - скажу ниже). Когда мы закончили работу с выделенной нам памятью, мы ее можем освободить, то есть сказать ОС, что кусок такой-то длины начиная с такого-то адреса теперь свободен.

В Паскале есть понятие pointer - переменная такого типа просто содержит адрес. Сначала рассмотрим две процедуры: GetMem и FreeMem. Они в точности соответствуют тому. что я сказал выше. Первая запрашивает память, вторая - освобождает. Длина участка памяти в них задается в байтах. Например:

var
  p: pointer;
begin
  GetMem(p,2);
  {используем}
  FreeMem(p,2);
end.

Этот пример не несет большого смысла. Смысл появится ниже..

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

var
  p: pointer;
  pi: ^integer;
begin
  GetMem(p,2);
  pi:=p;
  pi^:=3*4;
  WriteLn(pi^);
  FreeMem(p,2);
end.

В этом примере мы берем память (2 байта) и используем ее для целых вычислений. Появился небольшой смысл, но совсем маленький. Есть две непонятки:
1. почему бы нам сразу не сделать целую переменную i. Но это ясно - просто, чтоб изучить дин.память.
2. зачем нам был нужен пойнтер p? Ведь можно было просто так:

var
  pi: ^integer;
begin
  GetMem(pi,2);
  pi^:=3*4;  {ссылку по этому адресу мы используем как обычную целую переменную}
  WriteLn(pi^);
  FreeMem(pi,2);
end.

- так проще и лучше. Пока еще остается все-таки одна сложность: нам нужно "вручную" вычислять количество необходимой памяти в байтах. В принципе, с этим можно побороться так:

var
  pi: ^integer;
begin
  GetMem(pi,SizeOf(integer));
  pi^:=3*4;
  WriteLn(pi^);
  FreeMem(pi,SizeOf(integer));
end.

- вот, мы избавились от двойки. Можно еще универсальнее сделать:

type
  tInt=integer;
var
  pi: ^tInt;
begin
  GetMem(pi,SizeOf(tInt));
  pi^:=3*4;
  WriteLn(pi^);
  FreeMem(pi,SizeOf(tInt));
end.

В этом виде программа имеет то преимущество, что если нам станет мало типа integer и мы захотим перейти на LongInt, то нужно будет подредатировать всего одну строчку (тип).

Но все же неудобно тащить за собой SizeOf. И вот тут приходит на помощь пара процедур New и Release. Думаю, чтоб ты разобрался, достаточно будет привести пример - все та же наша прога, только с парой New/Release вместо пары GetMem/ FreeMem.

type
  tInt=integer;
var
  pi: ^tInt;
begin
  New(pi);
  pi^:=3*4;
  WriteLn(pi^);
  Release(pi);
end.

Тут нам вообще не нужно было связываться с длиной области - компилятор освободил нас от этой работы.

Пока хватит, спрашивай, что неясно.