我现在正在学习函数指针。当我阅读K&R关于这个主题的章节时，第一件让我印象深刻的是，“嘿，这有点像闭包。”但我知道这种假设在根本上是错误的，经过在线搜索后，我并没有找到真正比较这两者的分析。
那么为什么C风格的函数指针与闭包或lambda表达式有根本性的不同呢？据我所知，这与函数指针仍然指向已定义（命名）的函数有关，而不是匿名定义函数的实践。
为什么在第二种情况下将一个函数传递给另一个函数被视为更强大，其中它是未命名的，而在第一种情况下只是普通的、日常的函数被传递了呢？
请告诉我我为什么错误地如此密切地将这两者进行比较。
一个lambda（或闭包）封装了函数指针和变量。这就是为什么在C#中你可以这样做：
int lessThan = 100;
Func<int, bool> lessThanTest = delegate(int i) {
return i < lessThan;
};
我在那里使用了一个匿名委托作为闭包（它的语法比lambda更清晰，更接近于C），它将lessThan（一个堆栈变量）捕获到闭包中。当计算闭包时，lessThan（其堆栈帧可能已被销毁）将继续被引用。如果我改变lessThan，那么我就改变了比较：
int lessThan = 100;
Func<int, bool> lessThanTest = delegate(int i) {
return i < lessThan;
};
lessThanTest(99); // returns true
lessThan = 10;
lessThanTest(99); // returns false
BOOL (*lessThanTest)(int);
int lessThan = 100;
lessThanTest = &LessThan;
BOOL LessThan(int i) {
return i < lessThan; // compile error - lessThan is not in scope
}
虽然我可以定义一个接受两个参数的函数指针：
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;
}
但是，现在我评估它时必须传递2个参数。如果我希望将这个函数指针传递给另一个没有lessThan作用域的函数，我要么必须通过将其传递给链中的每个函数来手动保持它的活性，要么通过将其提升为全局来保持它的活性。
虽然大多数支持闭包的主流语言使用匿名函数，但并非必须如此。你可以有没有匿名函数的闭包，也可以有没有闭包的匿名函数。
总结：闭包是函数指针和捕获变量的组合。
闭包只是一个包含函数和环境的聚合体。在新泽西标准ML编译器中，我们将其表示为记录；一个字段包含指向代码的指针，另一个字段包含自由变量的值。编译器通过分配一个包含指向相同代码的指针的新记录，并为自由变量赋予不同的值，动态创建一个新闭包（而不是函数）。
您可以在C中模拟所有这些内容，但这真的很麻烦。常用的两种技术：
传递函数（代码）的指针和单独的自由变量指针，以便将闭包拆分成两个C变量。
传递结构的指针，其中结构包含自由变量的值以及指向代码的指针。
技术#1在您尝试在C中模拟某种多态性并且不想公开环境类型时是理想的——使用void*指针表示环境。有关示例，请查看Dave Hanson的C接口和实现。更接近原生代码编译器的函数语言的实现，还类似于另一种熟悉的技术……具有虚拟成员函数的C++对象。这些实现几乎相同。
这个观察结果为Henry Baker带来了一个俏皮话：
Algol/Fortran界的人们多年来一直抱怨不了解函数闭包在未来高效编程中可能有什么用处。然后，“面向对象编程”革命发生了，现在每个人都使用函数闭包编程，只是他们仍然拒绝将其称为函数闭包。
function runLater(f:Function):Void {
sleep(100);
f();
}
function objectProcessor(o:Object):Void {
/* Do something cool with the object! */
}
function process(o:Object):Void {
runLater(function() { objectProcessor(o); });
}
您传递给process()的函数不再是预先定义的静态函数。它是动态生成的，可以包含对在定义该方法时范围内的变量的引用。因此，它可以访问'o'和'objectProcessor'，即使它们不在全局范围内。
希望这样说得清楚了。
闭包 = 逻辑 + 环境。
比如，考虑这个 C# 3 方法：
public Person FindPerson(IEnumerable<Person> people, string name)
{
return people.Where(person => person.Name == name);
}
一个lambda是一个匿名、动态定义的函数。在C语言中是不能使用它的......至于闭包（或两者的组合），典型的Lisp示例可能看起来像这样：
(defun get-counter (n-start +-number)
"Returns a function that returns a number incremented
by +-number every time it is called"
(lambda () (setf n-start (+ +-number n-start))))
用C语言的术语来说，你可以这样说：匿名函数捕获了get-counter的词法环境（栈），并在内部进行修改，如下例所示：
[1]> (defun get-counter (n-start +-number)
"Returns a function that returns a number incremented
by +-number every time it is called"
(lambda () (setf n-start (+ +-number n-start))))
GET-COUNTER
[2]> (defvar x (get-counter 2 3))
X
[3]> (funcall x)
5
[4]> (funcall x)
8
[5]> (funcall x)
11
[6]> (funcall x)
14
[7]> (funcall x)
17
[8]> (funcall x)
20
[9]>
#define lambda(l_ret_type, l_arguments, l_body) \
({ \
l_ret_type l_anonymous_functions_name l_arguments \
l_body \
&l_anonymous_functions_name; \
})
以下为来源示例：
qsort (array, sizeof (array) / sizeof (array[0]), sizeof (array[0]),
lambda (int, (const void *a, const void *b),
{
dump ();
printf ("Comparison %d: %d and %d\n",
++ comparison, *(const int *) a, *(const int *) b);
return *(const int *) a - *(const int *) b;
}));
使用这种技术会使您的应用程序无法与其他编译器配合使用，而且显然是"未定义"的行为，所以效果可能因人而异。
闭包会捕获所在的环境中的自由变量。即使周围的代码可能不再活动，该环境仍将存在。
在Common Lisp中的一个示例，在此示例中，MAKE-ADDER返回一个新的闭包。
CL-USER 53 > (defun make-adder (start delta) (lambda () (incf start delta)))
MAKE-ADDER
CL-USER 54 > (compile *)
MAKE-ADDER
NIL
NIL
使用以上的函数：
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)
DESCRIBE函数显示两个闭包的函数对象相同，但环境不同。FUNCALL以相同的方式调用它们。
int lessThan是全局变量，不是吗？那么为什么会是非法的呢？ - Will Ness