Способы передачи параметров в подпрограммы
Существует два способа передачи параметров в подпрограммы – передача по значению и передача по наименованию. Способ передачи указывается при объявлении параметра в списке формальных параметров.
По умолчанию предполагается, что параметры обычных типов, например, Real, Integer, String, передаются по значению, а параметры таких типов как визуальные компоненты, динамические массивы передаются по наименованию. Если возникает необходимость явно указать, что параметр передается по наименованию, то перед именем параметра, или перечнем имен одного типа, пишется слово var.
3.1.2.1 Передача параметров по значению
Передача параметров по значению предполагает, что при вызове подпрограммы в памяти будет выделена специальная область для записи копий значений фактических параметров, с которыми и будет работать подпрограмма.
Такой способ передачи защищает переменные, передаваемые в подпрограмму в качестве параметров, от непредусмотренного изменения, так как подпрограмма работает с копиями. Кроме того, такой способ позволяет в качестве фактических параметров задавать выражения. При передаче параметров будет вычислено значение этого выражения и передано в подпрограмму.
Недостаток такого способа передачи состоит в том, что при передаче параметров, требующих много памяти, например, большие массивы чисел или длинные строки, копии занимают много места в памяти и требуется много времени для пересылки данных из одного места памяти в другое.
3.1.2.2 Передача параметров по наименованию
При передаче параметров по наименованию в подпрограмму передаются адреса фактических параметров. Поэтому такой способ передачи называется еще передачей параметров по адресу или по ссылке.
При таком способе передачи в качестве фактических параметров можно передавать только переменные. Выражение и даже отдельное число или символ передать по наименованию нельзя.
Передача параметров по наименованию экономит память и сокращает время обращения к подпрограммам. Однако это имеет и побочный эффект. Так как подпрограмма работает непосредственно с фактическими параметрами, то любое изменение формального параметра является изменением фактического параметра. Для исключения такого эффекта нужно в объявлении формальных параметров вместо слова var использовать слово const.
Но побочный эффект имеет и положительную сторону. Передачу параметров по наименованию можно использовать для возвращения результатов работы подпрограммы через фактические параметры. Такой способ возвращения особенно эффективен, когда требуется вернуть несколько параметров. Ведь функция возвращает только одно значение.
Выше, в пункте 3.1.1 уже рассматривался пример процедуры с передачей параметра по наименованию.
Рассмотрим еще один пример использования передачи параметров по наименованию для возвращения результатов работы подпрограммы.
В создаваемом ниже приложении для расчетов по формуле используется процедура считывания коэффициентов уравнения. Исходный текст этой процедуры приведен ниже.
ProceduregetKoef (var kA, kB, kC:Real);
В этой процедуре содержимое текстовых полей преобразуется в вещественные числа, и результаты преобразования присваиваются формальным параметрам, которые объявлены как передаваемые по наименованию. На это указывает слово varперед именами параметров.
Обращение к этой процедуре происходит в другой процедуре, которая обрабатывает событие onClick кнопки «Расчет по формуле». Фрагмент этой процедуры приведен ниже.
До вызова процедуры значения переменных a, b, c были неопределенными (мусор). При вызове процедуры getKoef адреса этих переменных были переданы в качестве фактических параметров. При выполнении процедуры, по этим адресам были записаны результаты преобразования данных. В результате, после окончания работы процедуры getKoef переменные a, b, c приобрели новые значения, которые были вычислены в процедуре
procedure TfrmSubroutine.btnCalculateRootsClick(Sender: TObject);
// До вызова процедуры getKoefKvUr
// значения переменных a,b,c не определены
//После вызова процедуры значения переменных
// a,b,c соответствуют содержиммому тектовых полей
Передача параметров в функцию по значению. Параметры функции. Передача аргументов в функцию. #34
Источник
Способы передачи параметров функциям
Механизм параметров является основным способом обмена информацией между вызываемой и вызывающей функциями. В операторе вызова функции записывают аргументы функции, а в заголовке описания функции перечисляют параметры.
В С++ передача параметров осуществляется тремя способами:
· по копии (или по значению);
· по адресу (или через указатель);
Это определяется видом объявления параметра в заголовке функции.
Рассмотрим все три способа передачи на примере функции обмена Change(). Ей передаются два параметра, и она должна поменять местами их значения.
1. Передача по копии (по значению):
При передаче по значению объявление параметра похоже на объявление переменной: Тип ИмяПараметра. Такой параметр считается отдельной локальной переменной в теле функции. Ни в заголовке, ни в теле функции не должно быть других параметров или переменных с таким же именем.
Опишем работу программы. В области видимости функции main() существуют две локальные переменные A и B, которые проинициализированы значениями 10 и 20. В момент вызова функции Change() в стеке создаются параметры X и Y, которые получают копии значений аргументов A и B, а также переменная temp. Затем с помощью этой переменной происходит перестановка значений параметров X и Y (прежние значения выделены красным цветом). Однако по окончании работы функции Change() переменные X, Y и temp уничтожаются, поскольку являются локальными переменными, а значения аргументов A и B остаются неизменными.
Таким образом, функция Change() не решает поставленной перед ней задачи. Тем не менее, данный пример иллюстрирует особенность использования параметров-копий: никакие изменения значения параметра внутри функции не отражаются на значении переменной-аргумента, так как параметр является локальной переменной. Это способ передачи параметров в C++ используется по умолчанию.
2. Передача по адресу (через указатель):
Способ передачи параметров по адресу используется для того, чтобы через указатели обеспечить непосредственный доступ к значениям аргументов. В момент вызова функции Change() в стеке создаются параметры-указатели X и Y, которые получают копии адресов аргументов A и B. Теперь параметры X и Y указывают на аргументы A и B. Несмотря на то, что функции Change() не известны имена аргументов A и B, ей известны их адреса, поэтому она имеет доступ к их значениям. С помощью переменной temp происходит перестановка значений аргументов A и B (прежние значения выделены красным цветом). По окончании работы функции Change() переменные X, Y и temp уничтожаются, поскольку являются локальными переменными, но аргументы A и B остаются с новыми значениями. Таким образом, функция выполнила поставленную задачу.
3. Передача по ссылке:
Этот способ передачи параметров появился в C++ для того, чтобы упростить работу с указателями. При передаче по ссылке объявление параметра представляет собой объявление ссылки без инициализации: Тип &ИмяПараметра. Параметр-ссылка локальна в функции: ни в заголовке, ни в ее теле не должно быть объявлено других параметров и переменных с таким же именем. Инициализация параметра-ссылки выполняется во время вызова функции.
В самом простом случае при вызове функции в качестве аргумента задается имя переменной. Тип переменной-аргумента должен совпадать с типом параметра-ссылки. Ссылка становится альтернативным именем аргумента, поэтому любые действия, выполняемые со ссылкой в теле функции, мгновенно отражаются на состоянии аргумента.
В момент вызова функции Change() у аргументов A и B появляются вторые имена X и Y. Поэтому функция Change фактически напрямую работает с исходными переменными A и B и изменяет их.
Использование параметров-ссылок вместо передачи по значению или по адресу более эффективно, поскольку:
1) не требуется памяти для копирования аргументов в локальные переменные;
2) не требуется времени на их создание и уничтожение.
Поэтому программы с параметрами-ссылками работают быстрее и используют меньше памяти. Это имеет значение при передаче структур данных большого объема.
Передача параметра по ссылке также используется, если функция должна возвратить не один результат, а несколько.
Если требуется запретить изменение параметра, передаваемого по адресу или по ссылке, то используется модификатор const, например:
int Func( int a, const double &b);
СОВЕТ Рекомендуется указывать const перед всеми параметрами, изменение которых в функции не предусмотрено. Это облегчает отладку. Кроме того, на место параметра типа const& может передаваться константа.
Параметры, передаваемые в функцию, могут быть любого типа (например, вещественного, структурой, перечислением, объединением, указателем), кроме массива или функции, которые передаются с помощью указателей.
Источник
Java: передача параметров по значению или по ссылке
Простое объяснение принципов передачи параметров в Java.
Многие программисты часто путают, какие параметры в Java передаются по значению, а какие по ссылке. Давайте визуализируем этот процесс, и тогда вы увидите насколько все просто.
Данные передаются между методами через параметры. Есть два способа передачи параметров:
Передача по значению (by value). Значения фактических параметров копируются. Вызываемый метод создает свою копию значений аргументов и затем ее использует. Поскольку работа ведется с копией, на исходный параметр это никак не влияет.
Передача по ссылке (by reference). Параметры передаются как ссылка (адрес) на исходную переменную. Вызываемый метод не создает свою копию, а ссылается на исходное значение. Следовательно, изменения, сделанные в вызываемом методе, также будут отражены в исходном значении.
В Java переменные хранятся следующим образом:
Локальные переменные, такие как примитивы и ссылки на объекты, создаются в стеке.
Объекты — в куче (heap).
Теперь вернемся к основному вопросу: переменные передаются по значению или по ссылке?
Java всегда передает параметры по значению
Чтобы разобраться с этим, давайте посмотрим на пример.
Пример передачи примитивов по значению
Поскольку Java передает параметры по значению, метод processData работает с копией данных. Следовательно, в исходных данных (в методе main ) не произошло никаких изменений.
Теперь рассмотрим другой пример:
Передача объекта
Что здесь происходит? Если Java передает параметры по значению, то почему был изменен исходный список? Похоже, что Java все-таки передает параметры не по значению? Нет, неправильно. Повторяйте за мной: «Java всегда передает параметры по значению».
Чтобы с этим разобраться, давайте посмотрим на следующую диаграмму.
Память стека (stack) и кучи (heap)
В программе, приведенной выше, список fruits передается методу processData . Переменная fruitRef — это копия параметра fruit . И fruits и fruitsRef размещаются в стеке. Это две разные ссылки. Но самое интересное заключается в том, что они указывают на один и тот же объект в куче. То есть, любое изменение, которое вы вносите с помощью любой из этих ссылок, влияет на объект.
Давайте посмотрим на еще один пример:
Передача объекта по ссылке Память стека (stack) и кучи (heap)
В этом случае для изменения ссылки fruitRef мы использовали оператор new . Теперь fruitRef указывает на новый объект, и, следовательно, любые изменения, которые вы вносите в него, не повлияют на исходный объект списка фруктов.
Итак, Java всегда передает параметры по значению. Однако мы должны быть осторожны при передаче ссылок на объекты.
Вышеприведенная концепция очень важна для правильного решения ваших задач.
Например, рассмотрим удаление узла в односвязном списке.
Удаление узла в связанном списке
Это решение работает во всех случаях, кроме одного — когда вы удаляете первый узел ( Position = 1 ). Основываясь на ранее описанной концепции, видите ли вы в чем здесь проблема? Возможно, поможет следующая диаграмма.
Удаление первого узла односвязного списка
Для исправления алгоритма необходимо сделать следующее:
В этой статье мы обсудили одну небольшую, но важную концепцию Java: передачу параметров.
Подробнее о курсе и программе обучения можно узнать на бесплатном вебинаре, который пройдет 15 апреля.
Источник
Управление данными и параметрами подпрограмм
Передача параметров
Внешние данные в подпрограмме могут использоваться, если они являются глобальными объектами для данной подпрограммы или переданы ей в качестве параметров. В описании подпрограммы указываются формальные параметры, а в точке вызова подпрограммы задаются фактические параметры. Формальный параметр определяет тип передаваемого фактического параметра. Фактический параметр представляет собой выражение соответствующего типа.
Различаются следующие способы передачи параметров: по ссылке, по имени, по значению, по значению-результату, по результату, по значению-константе. Набор допустимых способов передачи параметров зависит от конкретного языка программирования.
При передаче параметров по ссылке в записи активации, создаваемой при выполнении подпрограммы, ассоциация для фактического параметра может формироваться в нелокальной среде ссылок (в зависимости от реализации компилятора). Так, при вызове подпрограммы для параметров, передаваемых по ссылке, формируются указатели, доступные как из вызывающей, так и из вызываемой подпрограммы. Таким образом, при изменении в вызываемой подпрограмме значения фактического параметра, переданного по ссылке, в вызывающей программе объект, соответствующий фактическому параметру, также будет изменен.
При передаче параметров по имени в вызываемой подпрограмме до ее выполнения происходит замена формальных параметров на фактические. При этом значения фактических параметров вычисляются внутри вызываемой подпрограммы.
При передаче параметров по значению в вызываемой подпрограмме создается псевдоним фактического параметра (копия фактического параметра), значение которого присваивается формальному параметру подпрограммы. При таком способе передачи параметров изменения, произведенные в вызванной процедуре над значением фактического параметра, будут не видны далее в вызывающей подпрограмме.
При передаче параметров по значению-результату измененное значение фактического параметра возвращается вызывающей подпрограмме. Однако, в отличие от передачи параметров по ссылке, при данном способе сначала в момент вызова подпрограммы значение фактического параметра присваивается соответствующему формальному параметру вызываемой подпрограммы, и все изменения выполняются над формальным параметром, а не над ссылкой на фактический параметр. При завершении вызываемой подпрограммы текущее значение формального параметра присваивается обратно фактическому параметру. Такой тип передачи параметров был применен в языке ALGOL-W.
При передаче параметров по результату текущее значение формального параметра присваивается обратно фактическому параметру при завершении вызываемой подпрограммы, но первоначальное значение фактического параметра вызываемой подпрограмме не передается. Формальный параметр подпрограммы должен быть инициирован подпрограммой (реализация может позволять инициализацию по умолчанию в соответствии с типом данных параметра).
При передаче параметров по значению-константе значение фактического параметра не может быть изменено. Такой способ передачи параметров может быть реализован и как частный случай передачи параметра по значению, и как передача параметра по ссылке на константное выражение, что однозначно гарантирует неизменность фактического параметра вызывающей подпрограммы.
В большинстве случаев языки программирования используют один или два способа передачи параметров. Так, язык программирования С позволяет только передачу параметров по значению (ссылка реализуется как значение указателя). В языке программирования Pascal допускается два способа передачи параметров: по значению и по ссылке.
В следующей таблице приведены фрагменты кода, иллюстрирующие способы передачи параметров в языках программирования С и Pascal.
Источник
