Des pointeurs de fonction, les Fermetures, et Lambda

Un lambda (ou fermeture) encapsule le pointeur de fonction et les variables. C'est pourquoi, en C#, vous pouvez le faire:

int lessThan = 100;
Func<int, bool> lessThanTest = delegate(int i) {
   return i < lessThan;
};

J'ai utilisé un délégué anonyme il y a comme une fermeture (c'est la syntaxe est un peu plus clair et plus proche de C que le lambda équivalent), qui a capturé lessThan (une pile variable) dans la fermeture. Lorsque la fermeture est évaluée, lessThan (dont la trame de pile peuvent avoir été détruites) continuera à être référencé. Si je change lessThan, puis-je changer la comparaison:

int lessThan = 100;
Func<int, bool> lessThanTest = delegate(int i) {
   return i < lessThan;
};

lessThanTest(99); //returns true
lessThan = 10;
lessThanTest(99); //returns false

En C, ce serait illégal:

BOOL (*lessThanTest)(int);
int lessThan = 100;

lessThanTest = &LessThan;

BOOL LessThan(int i) {
   return i < lessThan; //compile error - lessThan is not in scope
}

même si j'ai pu définir un pointeur de fonction qui prend 2 arguments:

int lessThan = 100;
BOOL (*lessThanTest)(int, int);

lessThanTest = &LessThan;
lessThanTest(99, lessThan); //returns true
lessThan = 10;
lessThanTest(100, lessThan); //returns false

BOOL LessThan(int i, int lessThan) {
   return i < lessThan;
}

Mais, maintenant, je dois passer les 2 arguments quand je l'évaluer. Si je souhaite passer ce pointeur de fonction à une autre fonction où lessThan n'était pas dans le champ d'application, je voudrais soit manuellement la garder vivante en la passant à chaque fonction dans la chaîne, ou en en faisant la promotion d'un mondial.

Bien que la plupart des principaux langages qui prennent en charge les fermetures d'utiliser des fonctions anonymes, il n'est pas nécessaire pour cela. Vous pouvez avoir des fermetures sans les fonctions anonymes et les fonctions anonymes sans fermetures.

Résumé: une fermeture est une combinaison de pointeur de fonction + capturé variables.

En C, vous ne pouvez pas définir la fonction inline, donc on ne peut pas vraiment créer une fermeture. Tout ce que vous faites est de passer d'une référence à certaines pré-défini de méthode. Dans les langues qui prennent en charge les méthodes anonymes et les fermetures, la définition de méthodes sont beaucoup plus souples.

Dans les termes les plus simples, des pointeurs de fonction ont pas de portée associés avec eux (sauf si vous comptez la portée mondiale), alors que les fermetures d'inclure le champ d'application de la méthode de définition. Avec les lambdas, vous pouvez écrire une méthode qui écrit une méthode. Fermetures vous permettent de lier "des arguments à une fonction et d'obtenir un bas-arité de la fonction en tant que résultat." (prises de Thomas dans son commentaire). Vous ne pouvez pas le faire en C.

EDIT: Ajout d'un exemple (je vais utiliser Actionscript-ish syntaxe parce que c'est ce qui est sur mon esprit en ce moment):

Dire que vous avez une méthode qui prend une autre méthode comme argument, mais ne fournit pas un moyen de passer des paramètres à la méthode, lorsqu'elle est appelée? Comme, par exemple, une méthode qui provoque un retard avant l'exécution de la méthode que vous avez passé (exemple stupide, mais je tiens à garder les choses simples).

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

Disent maintenant que vous souhaitez l'utilisateur runLater() pour retarder le traitement de l'objet:

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

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

La fonction vous êtes de passage à traiter() n'est pas un staticly fonction définie plus. Il est généré de façon dynamique, et est en mesure d'inclure des références à des variables dans la portée lorsque la méthode a été définie. Donc, il peut accéder 'o' et 'objectProcessor', même si ceux-ci ne sont pas dans la portée globale.

J'espère que cela avait un sens.

En C, les pointeurs de fonction peuvent être passés comme arguments des fonctions et de les retourner comme des valeurs de fonctions, mais les fonctions n'existent qu'au niveau haut: vous ne pouvez pas imbriquer des définitions de fonction au sein de chaque d'autres. Pensez à ce qu'il faudrait pour C pour soutenir les fonctions imbriquées qui peut accéder aux variables de la fonction externe, tout en étant capable d'envoyer des pointeurs de fonction en haut et en bas de la pile d'appel. (À suivre cette explication, vous devez connaître les bases de la façon dont les appels de fonction sont mis en œuvre en C et la plupart des langues similaires: parcourir par le biais de la la pile des appels entrée sur Wikipedia.)

De quel type d'objet est un pointeur vers une fonction imbriquée? Il ne peut pas être simplement l'adresse du code, parce que si vous l'appelez, comment est-il accéder aux variables de la fonction externe? (Rappelez-vous qu'à cause de la récursivité, il peut y avoir plusieurs appels de l'extérieur de la fonction active à la fois.) Ceci est appelé la funarg problème, et il y a deux sous-problèmes: la tendance à la baisse funargs problème et vers le haut funargs problème.

À la baisse funargs problème, c'est à dire, l'envoi d'un pointeur de fonction "en bas de la pile" comme argument à une fonction que vous appelez n'est pas incompatible avec C, et GCC prend en charge fonctions imbriquées comme à la baisse funargs. Dans GCC, lorsque vous créez un pointeur vers une fonction imbriquée, vous avez vraiment obtenir un pointeur vers un trampoline, un construit dynamiquement morceau de code qui met en place le lien statique pointeur, puis appelle la fonction réelle, qui utilise le lien statique pointeur pour accéder aux variables de la fonction externe.

La hausse funargs problème est plus difficile. GCC ne vous empêche pas de laisser un trampoline pointeur exister après la fonction externe n'est plus actif (n'a pas de dossier sur la pile d'appel), puis le lien statique pointeur peut pointer vers des ordures. L'Activation des dossiers ne peuvent plus être attribués sur la pile. La solution habituelle est d'allouer sur le tas, et de laisser un objet de fonction représentant une fonction imbriquée juste à point pour l'activation de l'enregistrement de la fonction externe. Un tel objet est appelé un fermeture. Puis la langue généralement à l'appui la collecte des ordures afin que les enregistrements peuvent être libérés une fois il n'y a plus de pointeurs pointant vers eux.

Lambdas (les fonctions anonymes) sont vraiment d'une question distincte, mais le plus souvent un langage qui permet de définir des fonctions anonymes à la volée vous permettra aussi de rendre les valeurs de la fonction, de sorte qu'ils finissent par être fermetures.

Fermetures implique certaines variables du point de définition de la fonction est liée avec la logique de la fonction, comme le fait de pouvoir déclarer un mini-objet à la volée.

Un problème important avec des C et des fermetures de variables est alloué sur la pile sera détruit en quittant le champ d'application actuel, indépendamment de si la fermeture a été pointant vers eux. Cela conduirait à la genre de bugs gens quand ils négligemment retour des pointeurs vers des variables locales. Fermetures essentiellement impliquent toutes les variables pertinentes sont soit réf comptés ou des déchets-éléments recueillis sur un segment.

Je ne suis pas à l'aise en assimilant lambda avec fermeture parce que je ne suis pas sûr que les lambdas dans toutes les langues sont des fermetures, des fois je pense que les lambdas ont simplement été définis localement des fonctions anonymes sans la liaison de variables (Python pré 2.1?).

La fermeture capture la variables libres dans un environnement. L'environnement continuera d'exister, même si le code environnant peut plus être active.

Un exemple en Common Lisp, où MAKE-ADDER retourne une nouvelle fermeture.

CL-USER 53 > (defun make-adder (start delta) (lambda () (incf start delta)))
MAKE-ADDER

CL-USER 54 > (compile *)
MAKE-ADDER
NIL
NIL

À l'aide de la fonction ci-dessus:

CL-USER 55 > (let ((adder1 (make-adder 0 10))
                   (adder2 (make-adder 17 20)))
               (print (funcall adder1))
               (print (funcall adder1))
               (print (funcall adder1))
               (print (funcall adder1))
               (print (funcall adder2))
               (print (funcall adder2))
               (print (funcall adder2))
               (print (funcall adder1))
               (print (funcall adder1))
               (describe adder1)
               (describe adder2)
               (values))

10 
20 
30 
40 
37 
57 
77 
50 
60 
#<Closure 1 subfunction of MAKE-ADDER 4060001ED4> is a CLOSURE
Function         #<Function 1 subfunction of MAKE-ADDER 4060001CAC>
Environment      #(60 10)
#<Closure 1 subfunction of MAKE-ADDER 4060001EFC> is a CLOSURE
Function         #<Function 1 subfunction of MAKE-ADDER 4060001CAC>
Environment      #(77 20)

Noter que le DESCRIBE fonction montre que la fonction des objets pour les deux fermetures sont les mêmes, mais la environnement est différent.

Common Lisp rend les fermetures et les purs objets de fonction (sans environnement), afin d'être fonctions et l'on peut appeler de la même manière, ici à l'aide de FUNCALL.

La plupart des réponses indiquent que les fermetures d'exiger des pointeurs de fonction, peut-être pour des fonctions anonymes, mais comme Mark a écrit, les fermetures peuvent exister avec des fonctions nommées. Voici un exemple en Perl:

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

La fermeture, c'est l'environnement qui définit la $count variable. Il est uniquement disponible pour les increment sous-routine et persiste entre les appels.