В си все подпрограммы являются функциями: Функции в языке Си : вызов функции, возвращаемое значение

функций и подпрограмм

функций и подпрограмм

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

Существует несколько видов подпрограмм.

---

Подпрограммы

Синтаксис подпрограммы выглядит следующим образом:

 Имя подпрограммы (список формальных аргументов)
          Неявный
          ! объявить каждый формальный аргумент как переменную
          ! возможно также объявить некоторые локальные переменные
          ! исполняемый код
          Имя конечной подпрограммы 

Когда мы используем подпрограмму, мы используем инструкцию Вызов в основной программе вот так:

 Имя вызова (список фактических аргументов) 

Здесь есть терминология:

• Имя — это имя подпрограммы, обычный идентификатор FORTRAN.
• Формальные аргументы — это переменные в подпрограмме, представляющие фрагменты информации, передаваемые тем или иным образом.
• Локальные переменные — это переменные, существующие только в подпрограмме. Основная программа о них не знает.
• Фактические аргументы — это значения в основной программе, которые передается подпрограмме для ее использования. Это могут быть переменные, выражения или константы.

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

Вот пример:

 Замена подпрограммы (A, B)
          Неявный
          Целое :: А, В
          Целое :: Темп
          Температура = А
          А = В
          В = температура
          Завершить замену подпрограммы 

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

Здесь A и B — фактические аргументы, а Temp — локальная переменная.

Когда мы используем подпрограмму Swap, мы можем сказать:

 Обмен вызовами (X, Y) 

Чтобы это имело смысл, X и Y должны быть объявлены в основной программе как целочисленные переменные.

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

Вот еще один (довольно глупый) пример:

 Подпрограмма FindSum(A, B, Sum)
          Неявный
          Действительный :: A, B, Сумма
          Сумма = А + В
          Завершить подпрограмму FindSum 

Здесь A и B используются для ввода, а Sum для вывода. Мы могли бы позвонить эту подпрограмму несколькими разными способами, не все из которых будут работать:

 FindSum(23,5, 78,9, Итого)
          FindSum(X, Y, Z+2. 0) 

Здесь первый вызов будет успешным (мы можем изменить значение Total), но второй вызов завершится ошибкой (мы не можем изменить значение Z+2.0). Даже хуже того, второй вызов завершится ошибкой во время выполнения; компилятор не будет лови проблему.

Это можно обойти: см. раздел ниже о Intent пункт.

---

Функции

Функция – это разновидность подпрограммы, характеризующаяся тем, что она вычисляет значение для нас. (Он может делать и другие вещи.) синтаксис для него выглядит так:

 Тип Имя функции (список формальных аргументов)
          Неявный
          ! объявить каждый формальный аргумент как переменную
          ! возможно также объявить некоторые локальные переменные
          ! исполняемый код, включая «Имя = что-то»
          Имя конечной функции 

Здесь Имя используется в качестве аргумента (только для вывода). Он имеет тип, определяется типом в первой строке как Real, Integer и т. д.

Значение, вычисленное функцией, предоставляется путем присвоения значения назвать. У нас могут быть операторы If и циклы, но что бы ни случилось, Имени должно быть присвоено значение.

Другой способ записи:

 Имя функции (список формальных аргументов)
          Неявный
          ! объявить каждый формальный аргумент и имя как переменную
          ! возможно также объявить некоторые локальные переменные
          ! исполняемый код, включая «Имя = что-то»
          Имя конечной функции 

Вот пример, похожий на одну из неявных функций:

 Настоящая функция Abs(X)
          Реальный :: X
          Если (Х
 
 Мы могли бы использовать это несколькими способами:
 
 
 Z = Abx(X + 3,9)
          Печать *, Абс (C - D) 
  Операторные функции 
 Функция-оператор — это простая идея. Это в основном просто
 формула для расчета, все в одном заявлении. Синтаксис выглядит
 как это:
 Имя(список формальных аргументов) = выражение 
 Здесь выражение использует формальные аргументы. Имя и
 все формальные аргументы должны быть объявлены как обычно. Выражение
 может использовать другие функции, но не может содержать операторы If или
 петли; при необходимости его можно было бы продолжить на несколько строк.
  
 Определение функции оператора должно быть включено в
 верхняя часть программы перед любым исполняемым оператором.
 Чтобы использовать операторную функцию, мы используем ее так же, как
 обычная функция.
 Вот пример:
 CylVol(R, H) = 3,1415926 * R**2 * H 
 Мы могли бы использовать это в операторах присваивания и т. д.
 Операторные функции — это старая функция FORTRAN, которая, возможно,
 исчезнуть в какой-то будущей версии языка.
  Пункт о намерениях 
 Как упоминалось выше, в подпрограмме могут использоваться некоторые формальные аргументы.
 только для ввода или только для вывода. Мы можем указать это компилятору
 если мы захотим, и если мы это сделаем, он попытается отловить программные ошибки для
 нас.
 
  (Нет никаких гарантий.)
 Вот пример:
 Real Function BoxArea(H, W, L)
          Неявный
          Реальный, Намерение(В) :: H
          Настоящее, намерение(In) :: W
          Реальный, Намерение(В) :: L
          BoxArea = 2 * (В * Ш + Ш * Д + Д * В)
          Конечная функция BoxArea 
 Здесь предложение Intent(In) сообщает компилятору, что H, W и L
 использоваться только для ввода. Если мы застряли в очереди где-то, например,
 Н = 2,5 
 компилятор будет жаловаться на это.
 Точно так же у нас может быть Intent(Out) для параметров, которые должны использоваться
 только для вывода, или мы могли бы использовать Intent(InOut) для указания параметра
 должен использоваться в обоих направлениях. В подпрограмме Swap A и B могут быть
 объявлено с намерением (InOut). В примере FindSum сумма может быть
 объявлено с намерением (Out).
  
 Предложение Intent имеет смысл только для формальных аргументов; не может быть
 используется для обычных переменных.
  Оператор сохранения 
 При нормальных обстоятельствах локальные переменные реально не существуют.
 чем при выполнении подпрограммы. Если я использую подпрограмму и
 локальная переменная PDQ инициализируется значением 13 и в конечном итоге
 учитывая значение 42, новое значение не будет запомнено в следующий раз, когда я
 используйте подпрограмму, и PDQ снова запустится со значением 13.
 Иногда это неудобно. Бывают случаи, когда было бы
 имеет смысл иметь локальную переменную, и мы хотим, чтобы ее значение было
 вспоминается от одного раза к другому.
 Здесь нам нужен оператор Save.
 Вот пример печати заголовка страницы.
 Подпрограмма PageHead(LineCount)
          Неявный
          Целое :: LineCount
          Целое :: PageCount = 1
          Сохранить количество страниц
      Формат 100 (////, A, T62, A4, 1X, I2)
          Print 100, 'Это заголовок моей страницы', 'Страница, количество страниц
          Количество строк = 1
          Количество страниц = Количество страниц + 1
          Завершить подпрограмму PageHead 
 
 Мы могли бы использовать это следующим образом:
 Если (LCount > 50) Вызов PageHead(LCount) 
 Здесь LCount — целочисленная переменная в основной программе, которая подсчитывает
 строк на странице. Нам нужно не более 50 строк на странице, поэтому мы вызываем
 эту подпрограмму по мере необходимости. (Здесь //// используется как способ пропустить несколько
 строки, указывающие на то, что требуется новая страница. В некоторых FORTRAN мы могли
 используйте для этого символ управления кареткой '1'.)
  
 Локальная переменная PageCount используется для помещения номера страницы в
 заголовок. Он больше нигде не нужен, поэтому имеет смысл как
 локальная переменная. PageCount инициализируется равным 1, а затем увеличивается
 на 1 при каждом вызове подпрограммы.
 Оператор Save вызывает сохранение значения PageCount между
 звонки. Если бы его не было в подпрограмме, каждая страница была бы
 отмечен как страница 1.
 Если бы у нас не было оператора Save, мы могли бы обойтись
 без него (в данном случае), объявив PageCount как переменную в
 основную программу и передать ее в качестве второго аргумента PageHead.
 

Excel VBA хранит функции или подпрограммы в массиве

Да, но я не рекомендую это делать. VBA на самом деле не создан для этого. Вы пометили этот вопрос с помощью Excel, поэтому я опишу, как это делается для этого продукта Office. Общая концепция применима к большинству пакетов Office, но каждый отдельный продукт имеет различный синтаксис для

Приложение. Выполнить метод .

Во-первых, важно понимать два разных метода динамического вызова процедуры (подпрограммы/функции) и когда их использовать.

Application.Run либо запустит подпрограмму, либо вызовет функцию, хранящуюся в стандартном модуле *.bas .

Первый параметр — это имя процедуры (передается в виде строки). После этого вы можете передать до 30 аргументов. (Если ваша процедура требует большего, рефакторинг из любви к коду. )

В отношении Application.Run следует отметить еще два важных момента .

1. Нельзя использовать именованные аргументы. Аргументы должны передаваться по положению.

2. Объекты, переданные в качестве аргументов, преобразуются в значения. Это означает, что вы можете столкнуться с непредвиденными проблемами, если попытаетесь запустить процедуру, требующую объектов со свойствами по умолчанию в качестве аргументов.

    Общедоступный подтест1()
       Application.Run "VBAProject.Module1.SomeFunction"
   Конец сабвуфера
    

Вывод:

Используйте Application.Run при работе со стандартным модулем.

CallByName выполняет метод объекта или устанавливает/получает свойство объекта.

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

 Публичный подтест2()
    Dim anObj As SomeObject
    Тусклый результат Как логическое значение
    результат = CallByName(anObj, "IsValid")
Конец сабвуфера
 

Вывод:

Используйте CallByName , когда вы хотите вызвать метод класса.

Как видите, ни один из этих методов не использует настоящие указатели (по крайней мере, внешне).