Указатели функции, Закрытия и Лямбда

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

Основное различие является результатом отсутствия лексического обзора в C.

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

закрытие А, OTOH, имеет свое собственное состояние в форме 'внешних переменных' или 'upvalues'. они могут быть столь частными или общими, как Вы хотите, с помощью лексического обзора. Можно создать много закрытий с тем же функциональным кодом, но различные экземпляры переменных.

Несколько закрытий могут совместно использовать некоторые переменные, и так могут быть интерфейсом объекта (в смысле ООП). для создания этого в C, необходимо связать структуру с таблицей указателей функции (это - то, что C++ делает с vtable классом).

короче говоря, закрытие является указателем функции ПЛЮС некоторое состояние. это - высокоуровневая конструкция

Большинство ответов указывает, что закрытия требуют указателей функции, возможно к анонимным функциям, но как Mark записал , закрытия могут существовать с именованными функциями. Вот пример в Perl:

{
    my $count;
    sub increment { return $count++ }
}

закрытие является средой, которая определяет $count переменная. Это только доступно increment подпрограмма и сохраняется между вызовами.

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

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

я не удобная лямбда приравнивания с закрытием, потому что я не уверен, что лямбды на всех языках являются закрытиями, время от времени я думаю, что лямбды только что были локально определенными анонимными функциями без привязки переменных (Python пред 2,1?).

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

, Какой объект указатель к вложенной функции? Это не может только быть адрес кода, потому что при вызове его как это получает доступ к переменным внешней функции? (Помните, что из-за рекурсии, может быть несколько различных вызовов внешней функции, активной когда-то.) Это называют funarg проблема , и существует две подпроблемы: нисходящая funargs проблема и вверх funargs проблема.

вниз funargs проблема, т.е. отправка указателя функции "вниз стек" как аргумент функции Вы звоните, на самом деле весьма совместимо с C и поддержками GCC вложенные функции как нисходящий funargs. В GCC при создании указателя на вложенную функцию Вы действительно получаете указатель на батут , динамично созданная часть кода, который настраивает статический указатель ссылки и затем вызывает реальную функцию, которая использует статический указатель ссылки для доступа к переменным внешней функции.

вверх funargs проблема является более трудным. GCC не препятствует тому, чтобы Вы позволили указателю батута существовать после того, как внешняя функция больше не активна (не имеет никакой записи на стеке вызовов), и затем статический указатель ссылки мог указать на мусор. Записи активации больше не могут выделяться на стеке. Обычное решение состоит в том, чтобы выделить их на "куче" и позволить функциональному объекту, представляющему вложенную функцию, просто указывают на запись активации внешней функции. Такой объект называют закрытие . Тогда язык должен будет обычно поддерживать сборка "мусора" так, чтобы записи могли быть освобождены, как только больше нет указателей, указывающих на них.

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

Закрытие = логика + среда.

, Например, рассмотрите этот метод C# 3:

public Person FindPerson(IEnumerable<Person> people, string name)
{
    return people.Where(person => person.Name == name);
}

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

Для больше на этом, взгляните на мой статья о закрытиях , который берет Вас через C# 1, 2 и 3, показывая, как закрытия делают вещи легче.

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

Простым языком, указатели функции не имеют никакого объема, связанного с ними (если Вы не считаете глобальную область видимости), тогда как закрытия включают объем метода, это определяет их. С лямбдами можно записать метод, который пишет метод. Закрытия позволяют Вам связывать "некоторые аргументы функции и получению функции более низкой арности в результате". (взятый из комментария Thomas). Вы не можете сделать этого в C.

РЕДАКТИРОВАНИЕ: Добавление примера (я собираюсь использовать причину синтаксиса Actionscript-выхода, это - то, что находится на моем уме прямо сейчас):

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

function runLater(f:Function):Void {
  sleep(100);
  f();
}

Теперь говорят, что Вы хотите пользователю runLater () задержать некоторую обработку объекта:

function objectProcessor(o:Object):Void {
  /* Do something cool with the object! */
}

function process(o:Object):Void {
  runLater(function() { objectProcessor(o); });
}

функция Вы являетесь передающими для обработки (), больше не некоторая статически определенная функция. Это динамично сгенерировано и в состоянии включать ссылки на переменные, которые были в объеме, когда метод был определен. Так, это может получить доступ к 'o' и 'objectProcessor', даже при том, что те не находятся в глобальной области видимости.

я надеюсь тот имевший смысл.

Поскольку кто-то, кто записал компиляторы для языков и с и без 'реальных' закрытий, я почтительно, не соглашается с некоторыми ответами выше. Lisp, Схема, ML или закрытие Haskell не создают новую функцию динамично . Вместо этого это повторные использования существующая функция , но делает так с [1 119] новые свободные переменные . Набор свободных переменных часто называют среда , по крайней мере, теоретики языка программирования.