blocks|key|2068191|text|首先想到的是代码生成器的使用。您是否愿意使用提供函数式编程的不同语言进行编程，然后从中生成C代码？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2068192|如果这不是一个有吸引力的选择，那么您可以滥用CPP来实现部分目标。宏系统应该允许您模拟一些函数式编程思想。我听说过gcc是这样实现的，但我从来没有检查过。|2068193|C当然可以使用函数指针来传递函数，主要的问题是缺少闭包和类型系统倾向于阻碍。您可以探索比CPP更强大的宏系统，比如M4。我想，最终，我的建议是，真正的C语言不能很好地完成任务，但你可以扩展C语言，使其能够完成任务。如果您使用CPP，那么这个扩展看起来最像C，或者您可以转到另一端，从其他语言生成C代码。|2068194|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

The main thing that comes to mind is the use of code generators. Would you be willing to program in a different language that provided the functional programming and then generate the C code from that?

If that's not an attractive option, then you could abuse CPP to get part of the way there. The macro system should let you emulate some functional programming ideas. I've heard tell that gcc is implemented this way but I've never checked.

C can of course pass functions around using function pointers, the main problems are lack of closures and the type system tends to get in the way. You could explore more powerful macro systems than CPP such as M4. I guess ultimately, what I'm suggesting is that true C isn't up to the task without great effort but you could extend C to make it be up to the task. That extension would look the most like C if you use CPP or you could go to the other end of the spectrum and generate C code from some other language.

blocks|key|2068252|text|相当多的编程语言是用C编写的，其中一些支持函数作为一等公民，在那个领域的语言是ecl+(嵌入式公共lisp+)，Gnu+Smalltalk+(gst)+(Smalltalk有块)，然后有“闭包”的库，例如在glib2+http://library.gnome.org/devel/gobject/unstable/chapter-signal.html#closure中，至少接近于函数式编程。因此，也许使用其中的一些实现来进行函数式编程可能是一种选择。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2068253|或者你可以去学习Ocaml，Haskell，Mozart/Oz或类似的;-)|2068254|问候|2068255|entityMap|0|LINK|mutability|MUTABLE|url|http://library.gnome.org/devel/gobject/unstable/chapter-signal.html#closure^0|31|23|0|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]]|C|$]]|$1|D|3|E|5|6|7|T|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|U|8|@]|9|@]|C|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|I|$J|$5|K|L|M|C|$N|O]]]]

Well quite a few programming languages are written in C. And some of them support functions as first class citizens, languages in that area are ecl (embbedabble common lisp IIRC), Gnu Smalltalk (gst) (Smalltalk has blocks), then there are libraries for "closures" e.g in glib2 <a href="http://library.gnome.org/devel/gobject/unstable/chapter-signal.html#closure" rel="nofollow noreferrer">http://library.gnome.org/devel/gobject/unstable/chapter-signal.html#closure</a> 
which at least got near functional programming. So maybe using some of those implementations to do functional programming may be an option. 

Well or you can go learning Ocaml, Haskell, Mozart/Oz or the like ;-)

Regards

blocks|key|1854391|text|你想让C成为函数式的是什么，语法还是语义？函数式编程的语义当然可以添加到C编译器中，但当您完成时，您实际上已经拥有了与现有函数式语言之一等效的语言，如Scheme、Haskell等。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1854392|学习那些直接支持这些语义的语言的语法会更好地利用时间。|1854393|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

What is it about C that you want to make functional, the syntax or the semantics? The semantics of functional programming could certainly be added to the C compiler, but by the time you were done, you'd essentially have the equivalent of one of the existing functional languages, such as Scheme, Haskell, etc.

It would be a better use of time to just learn the syntax of those languages which directly support those semantics.

blocks|key|1854478|text|FFCALL允许您用C构建闭包--+callback+=+alloc_callback(&function,+data)返回一个函数指针，这样callback(arg1,+...)就等同于调用function(data,+arg1,+...)。不过，您必须手动处理垃圾收集。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1854479|与此相关的是，blocks已经被添加到苹果的GCC分支中；它们不是函数指针，但它们允许您传递lambda，同时避免手动构建和释放捕获变量的存储(实际上，一些复制和引用计数会发生，隐藏在一些语法糖和运行时库后面)。|1854480|entityMap|0|LINK|mutability|MUTABLE|url|http://www.haible.de/bruno/packages-ffcall.html|1|http://lists.cs.uiuc.edu/pipermail/cfe-dev/2008-August/002670.html^0|I|16|1Z|J|2O|P|0|6|0|0|7|6|1|0^^$0|@$1|2|3|4|5|6|7|R|8|@$9|S|A|T|B|C]|$9|U|A|V|B|C]|$9|W|A|X|B|C]]|D|@$9|Y|A|Z|1|10]]|E|$]]|$1|F|3|G|5|6|7|11|8|@]|D|@$9|12|A|13|1|14]]|E|$]]|$1|H|3|-4|5|6|7|15|8|@]|D|@]|E|$]]]|I|$J|$5|K|L|M|E|$N|O]]|P|$5|K|L|M|E|$N|Q]]]]

<a href="http://www.haible.de/bruno/packages-ffcall.html" rel="noreferrer">FFCALL</a> lets you build closures in C -- <code>callback = alloc_callback(&amp;function, data)</code> returns a function pointer such that <code>callback(arg1, ...)</code> is equivalent to calling <code>function(data, arg1, ...)</code>. You will have to handle garbage collection manually, though.

Relatedly, <a href="http://lists.cs.uiuc.edu/pipermail/cfe-dev/2008-August/002670.html" rel="noreferrer">blocks</a> have been added to Apple's fork of GCC; they're not function pointers, but they let you pass around lambdas while avoiding the need to build and free storage for captured variables by hand (effectively, some copying and reference counting happens, hidden behind some syntactic sugar and runtime libraries).

blocks|key|1854497|text|看看Hartel+&Muller的书，Functional+C|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1854498|http://www.ub.utwente.nl/webdocs/ctit/1/00000084.pdf+|offset|length|1854499|http://www.cs.bris.ac.uk/~henkm/f2c/index.html+|1854500|entityMap|0|LINK|mutability|MUTABLE|url|http://www.ub.utwente.nl/webdocs/ctit/1/00000084.pdf|1|http://www.cs.bris.ac.uk/~henkm/f2c/index.html^0|0|0|1H|0|0|0|1B|1|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@]|9|@$D|T|E|U|1|V]]|A|$]]|$1|F|3|G|5|6|7|W|8|@]|9|@$D|X|E|Y|1|Z]]|A|$]]|$1|H|3|-4|5|6|7|10|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]|P|$5|K|L|M|A|$N|Q]]]]

Look at Hartel &amp; Muller's book, Functional C

<a href="http://www.ub.utwente.nl/webdocs/ctit/1/00000084.pdf" rel="nofollow noreferrer">http://www.ub.utwente.nl/webdocs/ctit/1/00000084.pdf </a> 
<a href="http://www.cs.bris.ac.uk/~henkm/f2c/index.html" rel="nofollow noreferrer">http://www.cs.bris.ac.uk/~henkm/f2c/index.html </a>

blocks|key|1854540|text|如果你想实现闭包，你必须熟悉汇编语言和堆栈交换/管理。不是建议反对，只是说这是你必须要做的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1854541|不确定如何在C中处理匿名函数。在von+Neumann机器上，您可以在asm中处理匿名函数。|1854542|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

If you want to implement closures, you'll have to get groady with assembly language and stack swapping/management. Not recommending against it, just saying that's what you'll have to do.

Not sure how you'll handle anonymous functions in C. On a von Neumann machine, you could do anonymous functions in asm, though.

blocks|key|1854654|text|不知道C。虽然Objective-C中有一些函数式特性，但OSX上的GCC也支持一些特性，不过我还是建议开始使用函数式语言，上面提到的还有很多。我个人是从方案开始的，有一些优秀的书可以帮助你做到这一点，比如《小阴谋者》。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1854655|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Dont Know about C. There are some functional features in Objective-C though, GCC on the OSX also supports some features, however I would again recommend to start using a functional language, there are plenty mentioned above. I personally started off with scheme, there are some excellent books such as The Little Schemer that can help you do so.

blocks|key|2068813|text|你可以使用GCC的嵌套函数来模拟lambda表达式，实际上，我有一个宏来做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2068814|#define+lambda(return_type,+function_body)+\
++({+\
++++return_type+anon_func_name_+function_body+\
++++anon_func_name_;+\
++})|code-block|syntax|javascript|2068815|像这样使用：|2068816|int+(*max)(int,+int)+=+lambda+(int,+(int+x,+int+y)+{+return+x+>+y+?+x+:+y;+});|2068817|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

You can use GCC's nested functions to simulate lambda expressions, in fact, I have a macro to do it for me:

<pre><code>#define lambda(return_type, function_body) \
 ({ \
 return_type anon_func_name_ function_body \
 anon_func_name_; \
 })
</code></pre>

Use like this:

<pre><code>int (*max)(int, int) = lambda (int, (int x, int y) { return x &gt; y ? x : y; });
</code></pre>

blocks|key|2068847|text|Felix+language将编译为C%2B%2B。如果你不介意C%2B%2B的话，也许这是一块踏脚石。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2068848|entityMap|0|LINK|mutability|MUTABLE|url|http://www.felix-lang.org/^0|0|E|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

The <a href="http://www.felix-lang.org/" rel="nofollow">Felix language</a> compiles to C++. Maybe that could be a step stone, if you don't mind C++.

blocks|key|2068907|text|Hartel+&Muller的书，Functional+C，如今(2012-01-02)可以在http://eprints.eemcs.utwente.nl/1077/上找到(有一个到PDF版本的链接)。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2068908|entityMap|0|LINK|mutability|MUTABLE|url|http://eprints.eemcs.utwente.nl/1077/^0|1B|11|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

Hartel &amp; Muller's book, Functional C, can nowadays (2012-01-02) be found at: <a href="http://eprints.eemcs.utwente.nl/1077/" rel="noreferrer">http://eprints.eemcs.utwente.nl/1077/</a> (there is a link to PDF version).

blocks|key|2069267|text|我开始用C语言进行函数式编程的方法是用C语言编写一个函数式语言解释器。我将它命名为Fexl，它是"Function+EXpression+language“的缩写。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2069268|解释器非常小，在我启用了-O3的系统上编译到68K。它也不是玩具--我把它用在我为我的企业写的所有新的生产代码中(投资伙伴关系的基于网络的会计)。|2069269|现在我写C代码只是为了(1)添加一个调用系统例程(例如fork、exec、setrlimit等)的内置函数，或者(2)优化一个原本可以用Fexl编写的函数(例如搜索子字符串)。|2069270|模块机制基于“上下文”的概念。上下文是一个函数(用Fexl编写)，它将一个符号映射到它的定义。当您读取Fexl文件时，您可以使用您喜欢的任何上下文来解析它。这允许您创建自定义环境，或者在受限的“沙箱”中运行代码。|2069271|http://fexl.com|offset|length|2069272|entityMap|0|LINK|mutability|MUTABLE|url|http://fexl.com/^0|0|0|0|0|0|F|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|U|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|V|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|W|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|X|8|@]|9|@$J|Y|K|Z|1|10]]|A|$]]|$1|L|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|M|$N|$5|O|P|Q|A|$R|S]]]]

The way I went about doing functional programming in C was to write a functional language interpreter in C. I named it Fexl, which is short for "Function EXpression Language."

The interpreter is very small, compiling down to 68K on my system with -O3 enabled. It's not a toy either - I'm using it for all the new production code I write for my business (web-based accounting for investment partnerships.)

Now I write C code only to (1) add a built-in function that calls a system routine (e.g. fork, exec, setrlimit, etc.), or (2) optimize a function that could otherwise be written in Fexl (e.g. search for a substring).

The module mechanism is based on the concept of a "context". A context is a function (written in Fexl) which maps a symbol to its definition. When you read a Fexl file, you can resolve it with any context you like. This allows you to create custom environments, or run code in a restricted "sandbox."

<a href="http://fexl.com" rel="nofollow noreferrer">http://fexl.com</a>

I've been thinking a lot lately about how to go about doing functional programming in C (not C++). Obviously, C is a procedural language and doesn't really support functional programming natively.

Are there any compiler/language extensions that add some functional programming constructs to the language? GCC provides <a href="http://gcc.gnu.org/onlinedocs/gcc/Nested-Functions.html" rel="noreferrer">nested functions</a> as a language extension; nested functions can access variables from the parent stack frame, but this is still a long way away from mature closures.

For example, one thing that I think could be really useful in C is that anywhere where a function pointer is expected, you could be able to pass a lambda expression, creating a closure which decays into a function pointer. C++0x is going to include lambda expressions (which I think is awesome); however, I'm looking for tools applicable to straight C.

[Edit] To clarify, I'm not trying to solve a particular problem in C that would be more suited to functional programming; I'm merely curious about what tools are out there if I wanted to do so.

What tools are there for functional programming in C?

Objective-C

编译器

解释器

最近我一直在思考如何用C(而不是C++)进行函数式编程。显然，C是一种过程化语言，本身并不真正支持函数式编程。是否有任何编译器/语言扩展将一些函数式编程构造添加到语言中？GCC提供了作为语言扩展；嵌套函数可以访问父堆栈帧中的变量，但这离成熟的闭包还有很长的路要走。例如，我认为在C中真正有用的一件事是，在任何需要函数指针...

问在C中有哪些函数式编程的工具？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在C中有哪些函数式编程的工具？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在C中有哪些函数式编程的工具？
EN