Ошибка фактический параметр должен быть переменной

Параметры процедур и функций

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

Если формальный параметр описан с предваряющим ключевым словом var или const , то его называют параметром-переменной и говорят, что он передается по ссылке . Если же параметр описан без слов var или const , то его называют параметром-значением и говорят, что он передается по значению . Слово ссылка используется в PascalABC.NET также в другом значении — для ссылочных типов.

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

Например, пусть имеется следующее описание процедуры:

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

Например, если описана процедура

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

При передаче параметра по ссылке в подпрограмму передается адрес фактического параметра. Поэтому если параметр занимает много памяти (массив, запись, строка), то обычно он также передается по ссылке. В результате в процедуру передается не сам параметр, а его адрес, что экономит память и время работы. При этом если параметр меняется внутри подпрограммы, то он передается с ключевым словом var , если не меняется — с ключевым словом const :

procedure Print(const p: Person);
begin
write(p.name,’ ‘,p.age,’ ‘,p.height,’ ‘,p.weight);
end;

Отметим особенности передачи динамических массивов в качестве параметров подпрограмм.

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

будет выведено 2. Передавать динамические массивы по ссылке имеет смысл только в случае если память под динамический массив перераспределяется внутри подпрограммы:

Источник

Фактический параметр должен быть переменной что это значит

Формальные параметры подпрограммы указывают, с какими параметрами следует обращаться к этой подпрограмме (количество параметров, их последовательность, типы). Они задаются в заголовке подпрограммы в виде списка формальных параметров, разбитого на группы, разделенные точками с запятыми. В группу формальных параметров включаются однотипные параметры одной категории.

Все формальные параметры можно разбить на четыре категории:

• параметры-значения (эти параметры в основной программе подпрограммой не меняются);
• параметры-переменные (эти параметры подпрограмма может изменить в основной программе);
• параметры-константы (используются только в версии 7.0);
• параметры-процедуры и параметры-функции (т. е. процедурного типа).

Для каждого формального параметра следует указать имя и, как правило, тип, а в случае параметра-переменной или параметра-константы — его категорию. Имена параметров могут быть любыми, в том числе и совпадать с именами объектов программы. Необходимо лишь помнить, что в этом случае параметр основной программы с таким именем становится недоступным для непосредственного использования подпрограммой. Тип формального параметра может быть практически любым, однако в заголовке подпрограммы нельзя вводить новый тип. Например, нельзя писать

function Max(A: arrayt1..100] of Real): Real;

Чтобы правильно записать этот заголовок, следует в основной программе ввести тип-массив, а затем использовать его в заголовке:

type tArr = arrayt1..100] of Real; function Max(A: tArr): Real;

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

10.3.1. Параметры-значения

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

Параметр-значение указывается в заголовке подпрограммы своим именем и через двоеточие — типом. Тип параметра-значения может быть любым за исключением файлового.

Если параметров-значений одного типа несколько, их можно объединить в од ну группу, перечислив их имена через запятую, а затем уже указать общий тип Как отмечалось выше, отдельные группы параметров отделяются друг от точкой с запятой.

procedure Inp(Max, Min: Real; N: Word);
function Mult(X, Y: Integer): Real;

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

Inp(Abs(Z), -Abs(T), 2 * К);
M:=Mult(X + Y, X — Y);
MA:=Max(B, 5);

Пример. Функция вычисления максимального элемента в массиве. Пусть в основной программе определен тип-массив, массив этого типа и переменная целого типа

type
tArr = array[1..100] of Integer;
var
Massiv: tArr;
Maxim: Integer;

Функция в этом случае может иметь вид:

function Max(Mas: tArr; N: Byte): Integer;
var Ma: Integer;
i: Byte;
begin
Ma := Mas[l];
for i := 2 to N do
if Ma

Теперь, например, для определения максимального числа из первых пяти чисел массива Massiv и записи его в переменную Maxim можно записать оператор:

Maxim : = Max(Massiv,5); /p>

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

10.3.2. Параметры-переменные

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

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

procedure MaxMin(A: tArr; var Max, Min: Real; N: Word);

Здесь Max, Min — параметры-переменные, А и N — параметры значения.

Тип параметров-переменных может быть любым, включая и файловый.

При вызове подпрограммы на месте параметра-переменной в качестве фактического параметра должна использоваться переменная идентичного типа (см. п. 9.1). Так, если формальный параметр имеет тип, определенный следующим образом:

type tArr = array[1..100] of Integer;

то и фактический параметр должен быть переменной или типизированной константой типа tArr.

Пример. Функция вычисления максимального элемента в массиве. Модифицируем подпрограмму примера п. 10.3.1, используя в качестве первого параметра параметр-переменную:

function Max(var Mas: tArr; N: Byte): Integer;
var Ma: Integer;
i: Byte;
begin
Ma := Mas[l];
for i := 2 to N do
if Ma

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

10.3.3. Параметры-константы

Часто в качестве параметра в подпрограмму следует передать ту или иную переменную, но изменять ее подпрограмма не должна. В этом случае нежелательно передавать этот параметр как параметр-переменную. Можно его передать как параметр-значение, однако, если эта переменная имеет большой размер (массив, запись и т. д.), то копия такого параметра займет большую часть стека и даже может его переполнить. Это же приводит и к уменьшению быстродействия программы. В этой ситуации параметр лучше передать как параметр-константу. Такой параметр, если он структурированного типа, передается своим адресом, не предусматривается защита от его изменения. Использовать параметр-константу можно только в версии 7.0.

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

function NewString(const S: string): string;

Тип параметра-значения может быть любым за исключением файлового.

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

Параметр-константу нельзя передавать в другую подпрограмму в качестве фактического параметра.

Пример. Функция вычисления максимального элемента в массиве. В примере п. 10.3.1 используем в качестве первого параметра параметр-константу:

function Max(const Mas: tArr; N: Byte): Integer;
var Ma: Integer;
i: Byte;
begin
Ma := Mas[l];
for i := 2 to N do
if Ma

10.3.4. Параметры без типа

В Turbo Pascal можно использовать параметры-переменные и параметры-константы без указания типа. В этом случае фактический параметр может быть переменной любого типа, а ответственность за правильность использования того или иного параметра возлагается на программиста.

function Equal(var Paraml, Param2; Len: Word): Boolean;

Здесь Param1, Param2 — параметры-переменные без типа (вместо них можно использовать, например, любые переменные простого типа, типа-массив, типа-запись и т. д.); Len — параметр-значение.

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

Пример. Функция вычисления максимального элемента в массиве. Рассмотрим другой вариант подпрограммы примера п. 10.3.1, используя в качестве первого параметра параметр-переменную без типа:

function Max(var Mas; N: Byte): Integer;
type
tArray = array[1..Maxint] of Integer;
<тип массива максимального размера>
var Ma: Integer;
i: Byte;
begin
Ma := tArray(Mas)[1];
for i := 2 to N do
if Ma

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

10.3.5. Массивы и строки открытого типа

В версии 7.0 можно в качестве параметров-переменных использовать массивы 1 и строки открытого типа, у которых не задаются размеры. В качестве фактического параметра в этом случае можно использовать массив или строку любого ра- 1 змера, однако массив должен состоять из тех же компонент, что и компоненты j открытого массива. Такие параметры введены для того, чтобы подпрограмма мо- ] гла обрабатывать массив или строку любого размера. Фактический размер массива в этом случае может быть определен с помощью функции High (см, j п. 16.1). Открытый массив задается как и обычный массив, но только без указания типа индекса. Следует иметь в виду, что индексация элементов открытого массива всегда начинается с нуля, а максимальный индекс элемента равен значению функции High.

Пример. Функция вычисления максимального элемента в массиве. Рассмотрим вариант подпрограммы примера п. 10.3.1, используя в качестве передаваемого параметра массив открытого типа:

function Max(var Mas: array of Integer): Integer;
var Ma: Integer;
i: Byte;
begin
Ma := Mas[0];
for i := 1 to High(Mas) do <цикл до наибольшего индекса>
if Ma

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

Разновидность открытого массива — открытая строка, которая может задаваться либо с помощью стандартного типа OpenString, либо с помощью типа string и использования ключа компилятора <$Р+>(см. п. 17.7.1), например заголовок процедуры, заполняющей каким-либо символом строку, может иметь вид:

procedure FillChar(var Str: OpenString; Ch: Char);

($p+)
procedure FillChar(var Str: string; Ch: Char);

10.3.6. Параметры-процедуры и параметры-функции

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

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

Для параметров-процедур и параметров-функций существуют те же правила, что и для других переменных процедурного типа: подпрограммы должны компилироваться с ключом <$F+) или иметь директиву far, не должны быть стандартными подпрограммами, не должны объявляться внутри других подпрограмм, не иметь директив inline или interrupt.

Пример. Программа, печатающая таблицы сложения и умножения двух целых чисел в заданном диапазоне.

program EXAMPLE15;
type
Func = function(X, Y: Integer): Integer;
($F+)
function Add(X, Y: Integer): Integer;
begin
Add := X + Y
end;
function Multiply(X, Y: Integer): Integer;
begin
Multiply := X * Y
end;

procedure PrintTable(A, B: Integer; Operation: Func);
<процедура печати таблицы>
var
i, j: Integer;
begin
for i := 1 to A do
begin
for j := 1 to В do
Write(Operation(i, j): 5);
WriteLn
end;
WriteLn
end;

begin <начало основной программы>
PrintTable(10, 10, Add);
PrintTable(10, 10, Multiply)
end.

Источник

Параметры-переменные

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

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

Пример

procedure
maxmin(a:tArr; var max, min :real; n :word);

Тип
параметров-переменных может быть любым,
включая файловый.

При вызове
подпрограммы на месте параметра-переменной
в качестве фактического параметра
должна использоваться переменная
идентичного типа.

Пример
Функция вычисления максимального
элемента в массиве.

type tarr =
array [1..100] of integer;

{фактический
параметр должен быть переменной или
типизированной
константой типа
tarr}

function
max (var mas:tarr; n:byte):integer;

var

ma:integer;

i:byte;

begin

ma:=mas[1];

for
i:=2 to n do

if
ma<mas[i] then ma:=mas[i];

max:=ma;

end;

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

Однако,
при такой передаче параметра возможно
его нежелательное
изменение.

Подпрограмма
по-прежнему может работать с одним типом
массивов.

Параметры-константы

Условие – параметр
передается в подпрограмму, но изменять
его подпрограмма не должна. Нежелательно
передавать параметр как

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

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

Пример

function
NewString (const s :string) :string;

Тип
параметра-значения
может быть любым, кроме файлового.

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

Параметр-константу
нельзя передавать в другую подпрограмму
в качестве фактического параметра.

Пример
Функция вычисления максимального
элемента в массиве.

function
max(const mas: tarr;n: byte): integer;

var

ma:integer;

i:byte;

begin

ma:=mas[1];

for i:=1
to n do

if
ma<mas[i] then ma:=mas[i];

max :=ma;

end;

Пример

const

a:
integer = 5;

b:
integer = 7;

procedure
inc(var c: integer; b: integer)

begin

c:=
c+c;

b:=
b+b;

writeln(‘удвоенные
: ’,c:
5, b:
5);

end;

begin

writeln(‘исходные
: ’,a: 5, b: 5);

inc(a,b);

writeln(‘результат
: ’,a: 5,b: 5);

end.

b
– параметр-значение

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

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

а
– параметр-переменная

При
вызове подпрограмме передается сама
переменная (адрес переменной). Изменение
параметра-переменной приводит к изменению
фактического параметра в вызывающей
программе.

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

Пример
может служить иллюстрацией механизма
«закрывания» глобальной переменной
одноименной локальной: хотя b
объявлена как глобальная, в теле процедуры
её «закрывает» локальная, объявленная
как параметр-значение.

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

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

Оценка
вариантов передачи результатов работы
подпрограммы вызывающей программе

• злоупотребление
  глобальными связями делает программу
  запутанной, трудной в понимании и
  сложной в отладке;

• рекомендуется,
  где это возможно, использовать передачу
  результатов через фактические
  параметры-переменные;

• с
  другой стороны, описание всех формальных
  параметров, как параметров-переменных
  нежелательно по двум причинам: во-первых,
  это исключает возможность вызова
  подпрограммы с фактическими параметрами
  в виде выражений,
  что делает программу менее компактной,
  во-вторых, в подпрограмме возможно
  случайное использование формального
  параметра.

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

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

Соседние файлы в предмете [НЕСОРТИРОВАННОЕ]

• #
• #
• #
• #
• #
• #
• #
• #
• #
• #
• #

Цитата

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

Значит, что-то неправильно вызываешь…

Кстати, я посмотрел на твои изменения в программе. Ты очень много лишнего делаешь, тебе не кажется? Можно же обойтись одной структурой tlist для хранения обоих списков. Ведь Real совместим с Integer по присваиванию, то есть значение типа Integer можно без проблем занести в поле типа Real. И еще. Когда я говорил о написании процедуры Append, я имел в виду, что при заполнении первого списка тоже может использоваться эта процедура. Смотри:

uses crt;
type
  plist = ^tlist;
  tlist = record
    info: real; { <--- !!! }
    link: plist;
  end;
procedure append(var first, last: plist; value: real);
var p: plist;
begin
  new(p);
  p^.info := value; p^.link := nil;
  if first = nil then first := p
  else last^.link := p;
  last := p;
end;
procedure print(p: plist; len: integer);
begin
  while p <> nil do begin
    write(p^.info:7:len);
    p := p^.link
  end;
  writeln;
end;
procedure vvod(var first: plist);
var
  s: integer;
  p, last: plist;
begin
  first := nil; last := nil;
  repeat
    write('Vvedite sled element: '); readln(s);
    if s <> 25 then append(first, last, s);
  until s = 25;
end;
var
  first: plist;
  p, first_2, last_2: plist;
  ii, jj, nmin: plist;
  T: real;
begin
  clrscr;
  writeln('Perviy spisok:');
  vvod(first);
  print(first, 0); { Печатаем целые числа, 0 знаков после запятой }
  first_2 := nil; last_2 := nil;
  p := first; { <--- íà÷àëî òâîåãî ñïèñêà }
  while (p <> nil) and (p^.link <> nil) do begin
    append(first_2, last_2, (p^.info + p^.link^.info) / 2);
    p := p^.link;
  end;
  print(first_2, 2); { это - проверка, как средние заносятся в список }
  { Sortirovka }
  ii := first_2;
  while ii^.link <> nil do begin
    nmin := ii;
    jj := ii^.link;
    while jj <> nil do begin
      if jj^.info < nmin^.info then nmin := jj;
      jj := jj^.link;
    end;
    T := ii^.info;
    ii^.info := nmin^.info;
    nmin^.info := T;
    ii := ii^.link;
  end;
  writeln('Otsort spisok:');
  print(first_2, 2); { Ну, и результат }
end.

Не забудь удалить списки…