How do Clang 'blocks' work?

Question

http://clang.llvm.org/docs/BlockLanguageSpec.txt

Looks really cool.

However,

1. I don't understand it.
2. I don't see examples it.
3. I don't see examples of ideas hard to express in C++ as is, but trivial to express in blocks.

Can anyone enlighten me on this?

Lengel

See this question: #1367455 – Solorio

Answer 1

Blocks are, essentially, a way to pass code and scope around as data. They're known in some other languages as closures and anonymous functions.

Here's an article with more details and code examples.

Frontwards

BTW the next version of C++ has closures as well, via lambda syntax. – Micronutrient

BTW the current version of C++ has closures as well, via lambda syntax. – Evasion

BTW the previous version of C++ had closures as well, via lambda syntax. – Persson

Answer 2

NanoTech already linked to an explanation of blocks. As for how this relates to C++ let me state my personal opinion: This extension is not useful in C++. Here's why:

Regarding the block reference type: We already have "polymorphic functions" which can carry some state around, see boost::function, tr1::function. C++ will include a polished version of this in its next standard library. The advantage over "C Blocks" is that you don't need to mess with things like Block_copy and Block_release. These polymorphic functions objects are smart enough to do their own memory managing.

Regarding the block literal syntax: It's a nice syntax that allows you to put the code where it "belongs" without the need for much boilerplate code. But the same applies to its C++ counter part: C++0x lambdas. But C++0x lambda feature also allows you to use lambda objects in tight inner loops without high performance costs of function calls due to possible inlining.

Since C++0x lambdas can be also used in situations where performance is an issue and std::function is easier to handle w.r.t. memory management the addition of "C Blocks" to C++ seems redundant. "C blocks" seem to be more tailored to languages that don't support templates or destructors.

Mating

I'm not sure you mean what you think you mean when you say “polymorphic”. – Dessert

@Jonathan: I didn't invent the term. See the current C++ standard draft (N3092.pdf), section 20.8.15, "Polymorphic function wrappers". They are polymorphic in the sense that you can wrap any function object in there as long as the signatures are compatible. The exact type of the wrapped object is hidden ("erased"). This is achieved via "classic OOP polymorphism" (or something equivalent). – Mating

Answer 3

For more on blocks and how they work, you can refer to the following:

• Introducing Blocks and Grand Central Dispatch
• Blocks Programming Topics
• Cocoa for Scientists (Part XXVII): Getting Closure with Objective-C
• Cocoa for Scientists (XXXI): All Aboard Grand Central
• Concurrency Programming Guide: Implementing Tasks Using Blocks
• Cocoa Core Competencies: Block Object

Belicia

Answer 4

They're basically just Apple's term for closures/anonymous functions. As Nikolai notes, they're how you use Grand Central Dispatch to run multiple functions in parallel (thus using more than 1 core) without having to worry about threading and locking.

Forta

Not Apple's terminology. The terminology comes from Smalltalk. Objective-C can be seen as a hybrid of C and Smalltalk. An earlier non-Apple/non-Next Objective-C compiler (called PoC) had added blocks many years ago and used the Smalltalk terminology. So it's only natural that Smalltalk terminology was used for Apple's implementation, too. – Collegian

I didn't intend to imply that Apple had invented it, just that that's the term they chose to use for Objective-C 2.0 (and, by extension, that of the clang project funded by Apple). – Forta

I think Objective-C was quite heavily influenced by Smalltalk and took on quite a bit of the terminology. Objective-C has been around for quite a while (IIRC it's actually older than C++) and at the time Smalltalk was the gold standard for this sort of thing. – Instructive

Answer 5

As far as I understand this extension is for Apple's Grand Central Dispatch framework. Blocks are tiny schedulable/queue-able entities to be potentially run in parallel.

Alternant

Jesus. GCD is one API that uses blocks. But to say that they are an extension for that framework is ludicrous; they add closures to the language. Nothing more, nothing less. The existence of a framework that uses them to great effect does not have any implication on their purpose or origin. – Dessert