mikeash.com: Friday Q&A 2011-06-03: Objective-C Blocks vs. C++0x Lambdas: Fight!
Friday Q&A 2011-06-03: Objective-C Blocks vs. C++0x Lambdas: Fight!
Blocks are perhaps the most significant new language feature introduced by Apple in
years, and I've written a lot about them before. The new C++ standard, C++0x,
introduces lambdas, a similar feature. Today, I want to discuss the two features and
how they are alike and how they differ, a topic suggested by David Dunham.
ブロックはおそらく、ここ数年のうちに Appleによって導入された最も significant な新しい言語
機能です。これについては以前に多くのことを書いています。C++ の新標準 C++0x では類似の機能
である lambad を導入しました。今日は、これら二つの機能であるとかどれだけ似たものであるのか
あるいはどれだけかけ離れたものであるのかについて論じます。
トピックは David Dunham が提案したものです。
Terminology
用語
I will refer to Apple's blocks extension as "Objective-C blocks" even though
this is not entirely correct. They are actually an addition to C (and can even be used
in C++), with some extra behaviors to make them more useful in Objective-C. However,
they are deeply intertwined with Objective-C in their implementation, and "C
blocks" is vague, so I think that "Objective-C blocks" is the best way
to refer to them here.
正確ではない部分もありますが、ここでは Apple のブロック拡張を“Objective-C のブロック”と見な
します。実際にはこれは Objective-C において自身を一層有用にさせるちょっとした追加機能 (some
extra behaviors) を持っている C に対する (C++でも使用可能な) 追加です。
しかし、その実装においてブロックは Objective-C と深く結びついているので、
“C のブロック”というのは vague (あいまい、ぼんやりとした) です。
ですからわたしは、ここでは "Objective-C のブロック" とするのがブロックを表す
最善のやり方であろうと考えたのです。
C++0x lambdas are part of C++ only and can't be used from C. Presumably they can be
used in Objective-C++ if the compiler supports C++0x.
C++0x の lambda は C++ のみの一部であり、C から使うことはできません。
Presumably they can be used in Objective-C++ if the compiler supports C++0x.
For a generic term to refer to both Objective-C blocks and C++0x lambdas, I will use
"anonymous function".
Objective-C のブロックとC++0xのlambda を指す一般的な用語として、
“無名関数”("anonymous function") を使うことにします。
Syntax
構文
Both Objective-C blocks and C++0x lambdas have the same basic goal: to allow writing
anonymous inline functions. Called closures, blocks, lambdas, or just anonymous
functions, these are a common feature in higher level languages. They are extremely
useful for building convenient, succint libraries for things like array iteration,
multithreading, delayed computation, and many others.
Objective-C のブロック、C++0xのlambdaの両方とも同一の basic goal を持っています:
無名のインライン関数 (anonymous inline functions)を書くことを可能にする
クロージャ、ブロック、ラムダ、あるいは単に無名関数と呼ばれるそれは、
より高水準の言語 (higher level languages) においては一般的な機能です。
As lower level languages, C and C++ had no concept of anonymous functions. To add them,
new syntax had to be created. Because of this, Objective-C blocks and C++0x lambdas
ended up with somewhat different syntax. An empty Objective-C block looks like this:
比較的低水準の言語である C や C++ は無名関数というコンセプトを持っていませんでした。
この無名関数を追加するためには新しい構文を作り出さねばなりませんでした。
このために、Objective-C のブロックと C++0x の lambda は異なる構文となってしまいました。
空の Objective-C ブロックは次のような外見です:
^{}
Whereas an empty C++0x lambda looks like this:
[]{}
So far not much different. They both use the standard C {} symbols to separate a block
of code, with a special symbol to indicate that this is a block or lambda, not a
normal C block. In both cases, the {} section takes normal code.
それほど違いはありません。両者ともコードのブロックを分けるために標準の C の {} シンボ
ルを使っていて、さらに通常のブロックではなくブロックや lambda であることを示す特殊なシ
ンボルを伴っています。そしてどちらの場合も {} セクションは通常のコードを取ります。
The anonymous function can take arguments by writing them in parentheses, in the style
of function arguments, after the leading bit:
leading bit の後に関数形式でカッコの中に引数を書くことにより無名関数は引数を取れます:
^(int x, NSString *y){} // ObjC, take int and NSString*
[](int x, std::string y){} // C++, take int and std::string
In both languages, a value can be returned, and the return type can be inferred from
the return statement:
どちらの言語でも一つの値を返すことが可能で、さらに
その戻り値の型は return 文から推測可能です:
^{ return 42; } // ObjC, returns int
[]{ return 42; } // C++, returns int
Here, the two features begin to diverge. With C++0x lambdas, the return type can only
be inferred if the lambda contains a single statement, and that statement is a return
statement. So while the above is valid, this is not:
ここから二つの機能の diverge が始まります。
C++0x の lambda ではそれがただ一つの文からなっているときにのみ
戻り値の型の推測が可能で、さらにその文は return 文でなければなりません。
ですから、上の例は vaild なものですが、次の例は違います:
[]{ if(something) return 42; else return 43; }
In a more complicated lambda with an inferred return type, the return type is always
inferred to be void. The code above will therefore produce an error, because it's
invalid to return 42 from something with a return type of void.
inferred return type を持ったもっと複雑な lambda ではその戻り値の型は常に void である
と推測されます。戻り値の型が void であるなにかが 42 を返すことは invalid なので上記の
例ではエラーが発生します。
In contrast, Objective-C blocks do return type inference no matter how complicated the
code is inside of the block. If no return statements are present, the type is inferred
as void. Otherwise, it examines all of the return statements in the block. If they all
return the same type, then the return type of the block is inferred to be that same
type. If they conflict, an error is generated. Thus, the equivalent Objective-C
example to the invalid C++0x lambda example works fine:
対照的に、Objective-C のブロックはその内部にあるコードがどれほど複雑であるかは関係なく
戻り値型の推測を行います。もし return 文がブロックになければ、そのブロックの型は void
であると推測されます。そうでなければ、ブロックの中にあるすべてのreturn文を検査します。
すべてのreturn文が同一の型を返していれば、ブロックの戻り値の型はその型と同じものである
と推測されます。衝突があった場合にはエラーが発生します。したがって、先の C++0x lambda
の invalid な例と等価な Objective-C での例は正しく動作します:
^{ if(something) return 42; else return 43; }
Both features also allow the explicit declaration of a return type. This is essential
with C++0x lambdas, where it's the only way to have a complicated lambda return a
value. It's merely a convenience in Objective-C, but often useful to avoid having to
cast in return statements.
どちらの機能も戻り値の型の explicit な宣言が可能です。これは C++0x lambda の essential
で、ある値を返す複雑な lambda を持つための唯一の方法です。これは Objective-C では単に
covenience にすぎませんが、return 文の cast を取り除くのにしばしば有用です。
With Objective-C blocks, the return type is declared immediately after the ^. In C++0x,
the return type is declared by placing ->type after the lambda's argument list.
Here are those two examples with explicit return types, which allows it to work in
both languages:
Objective-C のブロックでは戻り値の型は ^ の直後で宣言されます。
C++0x では lambda の引数リストの直後に -> を置くことで戻り値の型が宣言されます。
ここで、それぞれの言語で動作する explicit な return typeを持った
二つの例を挙げます:
[]()->int { if(something) return 42; else return 43; }
^int { if(something) return 42; else return 43; }
Note that an arguments declaration is required for C++0x lambdas, although it can be
empty, if an explicit return type is declared. Objective-C blocks can declare either a
return type or an argument list separately, or have both together. For completeness,
here is the same example with an argument list:
戻り値の型を explicit に宣言している場合には、引数がなかったとしても引数宣言が必須であること
に注意してください。Objective-C のブロックでは戻り値の型や引数リストを分割してもまとめても宣
言できます。
For completeness, 引数リストを持った例を挙げます:
^int (void) { if(something) return 42; else return 43; }
Finally, both Objective-C blocks and C++0x lambdas are called in the same way: use the
standard () operator on an expression of the appropriate type. Pass arguments if they
are required. This calls the anonymous function.
Finally,
Objective-C のブロックと C++0x の lambda はどちらも same way で呼び出されます:
適切な型の式に対して標準の () 演算子を使います。
要求されていれば引数を渡します。
これは無名関数を呼び出します。
Type
型
Objective-C blocks introduce a new class of language-level types to represent block
types. They match the standard (but tricky) syntax for C function pointer types, but
with a ^ in place of the *:
Objective-C のブロックではブロック型を表現するために言語レベルの型として新しいクラスを導入しました。
それは (トリッキーではあるものの) C の関数ポインター型を表す標準の構文とマッチするものですが、
* が ^ で置き換っています:
void (*)(int) // function pointer taking int and returning void
void (^)(int) // block taking int and returning void
These types can be used for function/method parameters, return types, local variables,
instance variables, etc.
これらの型は、関数やメソッドのパラメーター、戻り値の型、ローカル変数、
インスタンス変数等々で使用できます。
C++0x takes a completely different approach. Lambdas have a unique anonymous type
which implements operator(). In other words, you can call it, but otherwise you don't
have an accessible type the way Objective-C blocks do. In order to store them in
variables, pass them to functions, or return them from functions, C++ templates or the
C++0x auto keyword (which infers the type of a variable from the type of its
initializer) must be used.
C++0x は全く異なるアプローチを採用しました。
lambda は operator() を実装している unique な無名型を持ちます。
言い換えると、呼び出すことは可能なのですがそれ以外では、
Objective-C のブロックのような accessible type をあなたは持っていません。
lambda を変数に格納したり、関数に渡したり、あるいは関数から返すためには
C++ のテンプレートもしくは C++0x の予約語 auto
(変数の型をその initializer の型から推測します)
を使わなければなりません。
Captured Variables
捕獲変数
One of the most significant features of these anonymous functions is the ability to
capture variables from the enclosing scope. For example:
これら無名関数の最も significant な機能の一つが
無名関数を囲むスコープにある変数を捕獲する能力 (ability) です。
例をあげましょう:
int x = 42;
void (^block)(void) = ^{ printf("%d\n", x); };
block(); // prints 42
The two constructs handle variable capture significantly differently, so I'll take
them one at a time.
二つの constructs の handle variable capture は
significantly differently なので、一つずつ説明します。
Objective-C blocks can capture variables from the enclosing scope by simply referring
to them within the block, as seen above. By default, all captured variables are copied
at the point where the block is created and cannot be modified from within the block.
これまで見てきたように、Objective-C のブロックはそのブロックを囲むスコープの中で
単に参照することで変数の捕獲ができます。
デフォルトでは、ブロックが生成された時点で捕獲されたすべての変数はコピーされ、
そしてブロックの中から変更することはできません。
If a block captures another block variable, that block's memory is automatically
managed. It's copied and released as necessary. Objective-C object pointers are also
automatically managed by retaining and releasing them as necessary. This deep,
implicit integration with Objective-C memory management makes a lot of tasks
significantly easier, because most of the time blocks automatically do the right thing
with the variables they capture.
あるブロックが別のブロックの変数を capture したときそのブロックのメモリーは自動的に管理されます。
Objective-C のオブジェクトポインターもまた、必要に応じて retain と release をすることで
自動的に管理されます。この deep な implicit integration with Objective-C のメモリ管理は
多くのタスクを significantly に簡単にします。
それは、ほとんどの場合でブロックは捕獲した変数を使って自動的に正しいことを行うからです
For cases where the block needs to be able to modify a captured variable, the variable
must be declared with the special__block qualifier to mark it as being mutable:
ブロックが捕獲した変数を変更できるようにする必要があるケースでは、
その変数が mutableであることを示すために
特別な __block qualifier をつけて宣言しなければなりません
__block int x = 42;
void (^block)(void) = ^{ x = 43; };
block(); // x is now 43
It is important to note that the automatic memory management of block and object
pointers does not occur for variables qualified with __block, so the programmer needs
to make sure that everything is built to tolerate that. For primitives like x above,
there is no concern.
ブロックやオブジェクトポインターの自動メモリ管理は __block で修飾された変数に対しては行われない
ことに注意を払うことは重要で、プログラマーはすべてが built to tolerate that であることを
make sure する必要があります。
上記の例の x のようなプリミティブに対しては concern はありません。
It should come as no surprise that C++0x lambdas offer considerably greater
flexibility but also considerably greater complication in this area. The overall
philosophy of C++ appears to be to give the programmer as many tools and choices as
possible, which has its pros and cons.
C++0x の lambda が consideably greater flexibility だけではなく
considerably greater complication in this area も offer していることは should come as no surprise。
(長所も短所も含めて) 可能な限り多くのツールと選択肢をプログラマーに与えるために
The overall philosophy of C++ は appears しています。
The initial [] which begins a C++0x lambda controls how local variables are captured.
If it's left empty like that, then no variables can be captured at all. In order to
capture variables, it's necessary to tell the compiler what you want to do.
C++0x の lambda の頭にある [] はローカル変数がどのように捕獲されるのかを control します。
[] が空のままであれば捕獲できる変数はありません。
変数を捕獲するためには、コンパイラーに自分が何をしたいのかを伝える必要があります。
The most explicit way to do this is to list the variables to be captured inside the [].
Any variable listed directly by name is captured by value. Any variable listed with a
leading & is captured by reference. For example:
これを行う最も explicitなやり方は []の内側に捕獲する変数を列挙することです。by name で
列挙されたすべての変数は by value で捕獲されますが、& が前置された変数は by reference
で捕獲されます。例をあげましょう:
int x = 42;
int y = 99;
auto lambda = [x, &y]{ y = 100; };
lambda(); // y is now 100
It's not possible to modify x in this case, as a lambda's operator() is const by
default. However, this can be overridden by declaring it to be mutable:
この場合 x を変更することはできません。
lambda の operator() がデフォルトで const であるので
しかし、mutalbe であると宣言することでこれを上書きできます:
int x = 42;
int y = 99;
auto lambda = [x, &y]() mutable {
x++, y++;
printf("%d, %d\n", x, y);
};
lambda(); // prints 43, 100
printf("%d, %d\n", x, y); // prints 42, 100
lambda(); // prints 44, 101!
Because x is captured by value, changes made from within the lambda are not seen
outside of it. There are essentially two copies of x at this point, and neither one
affects the other.
x は by value で捕獲されているので、lambda の内側でなされた変更は lambda の外側には及びません。
本質的にはこの時点で x の実体が二つ存在していて、
それぞれは他方に影響することはありません。
It can be inconvenient to list every variable to be captured, so it is possible to
specify a default capture behavior by putting either = or & within the []. For
example:
捕獲するためにすべての変数を列挙するのは不便ですが、[] の中に = か &を置くことに
よってデフォルトの捕獲動作を指定できます。
例を挙げましょう:
int x = 42;
int y = 99;
auto lambda = [&] {
x++, y++;
};
lambda(); // x, y are now 43, 100
It's even possible to combine the two, to have a default capture with exceptions:
デフォルトの捕獲に例外を置くためにこれら二つを組み合わせることも可能です:
int x = 42;
int y = 99;
int z = 1001;
auto lambda = [=, &z] {
// can't modify x or y here, but we can read them
// ここでは x と y は変更できない。読むことはできる。
z++;
printf("%d, %d, %d\n", x, y, z);
};
lambda(); // prints 42, 99, 1002
// z is now 1002
By allowing each lambda to specify how it captures things, the C++0x system allows
more flexibility. With Objective-C blocks, a given variable is either __block or it's
not. Every block which captures that variable must capture it in the same way. C++0x
lambdas allow each lambda to make its own choice on how to capture. The mutable
keyword even allows them to capture by value but retain the ability to change the
copied value internally. The downside is considerably increased complexity.
それぞれの lambda でどのように捕獲を行うかを指定できるようにすることで、C++0x のシステ
ムはより柔軟性を持ったものになります。Objective-C のブロックでは、与えられた変数は
__block かそうでないかのいずれかです。そのような変数を捕獲しているすべてのブロックは同
様のやり方でもって該当する変数を捕獲しなければなりません。C++0x の lambda では各
lambda がそれぞれ自分がどのように捕獲するかを選択できるようにしています。予約語
mutable は by value での捕獲を可能にしますが、内部的にコピーした値を変更する能力
(ability) を retain します。この downside は considerably に複雑さを増加させます。
ます。
Memory Management
メモリー管理
Both Objective-C blocks and C++0x lambdas start their lives as stack objects. After
that point, however, they diverge significantly.
Objective-C のブロックとC++0xの lambda の両方ともスタックオブジェクトとしてその生涯が
始まります。しかしある時点で、それらは significantly に diverge します。
Objective-C blocks are also Objective-C objects. Like all Objective-C objects, they
are stored by reference, never by value. When a block literal is written, the block
object is created on the stack, and the literal expression evaluates to the address of
that block.
Objective-C のブロックは Objective-C のオブジェクトでもあります。すべての Objective-C
オブジェクトと同様にブロックは by reference で格納され、by value で格納されることは決
してありません。ブロックリテラルが書かれたとき、ブロックオブジェクトはスタック上に生成
されます。そしてリテラル式は
evaluates to the address of that block.
In order for a block to outlive its slot on the stack, it must be copied. Because the
value is just a reference, simply assigning it with = is not enough:
あるブロックが outlive its slot on the stack するためにはコピーされなければなりません。
スタック上に置かれているのは単なる reference なので、
= を使った単純な代入では不十分です:
void (^block)(void);
{
block = ^{ printf("hello world"); };
}
block(); // bad!
Instead, it must be copied, either by using the Objective-C copy method, or the C
Block_copy function:
単純な代入ではなしに、Objective-C の copy メソッドか C の Block_copy 関数を使うかして
コピーしなければなりません:
void (^block)(void);
{
block = ^{ printf("hello world"); };
block = [block copy];
}
block(); // good!
Blocks follow standard Objective-C reference counting semantics. Each copy must be
balanced with a release or autorelease, and each Block_copy must be balanced with a
Block_release. The first copy gets the block onto the heap, subsequent ones simply
increment the reference count. When the last live reference is released, the block is
destroyed, and any captured objects or blocks are released.
ブロックは Objecive-C の標準である参照カウント方式のセマンティクスに従います。それぞれ
のコピーは release か autorelease を使ってバランスさせなければいけませんし、Block_copy
はそれぞれが Block_relase とバランスしていなければなりません。最初のコピーはブロックを
ヒープに得ますが、後続のコピーは単純にヒープに置かれたものの参照カウントを増やすだけで
す。最後まで生きていた参照がリリースされたときにそのブロックは破棄されて、すべての捕獲
オブジェクトおよび捕獲ブロックはリリースされます。
C++0x lambdas are stored by value, not by reference. They can be copied onto the heap
if needed, but the process is entirely manual. All captured variables are stored as
member variables within the anonymous lambda object, so when the lambda is copied,
those get copied as well, firing the appropriate constructors and destructors.
C++0x の lambda は by reference ではなく by value で格納されます。必要があればヒープに
コピーできますが、そのための手続きは完全に手作業です。すべての捕獲変数は無名 lambda オ
ブジェクト内にメンバー変数として格納されます。そのため、lambda がコピーされたときには
捕獲変数も同様にコピーされて、適切なコンストラクターやデストラクタ―が実行されます。
One extremely important aspect of this behavior is that variables which are captured
by reference are stored as references within the lambda object. They get no special
treatment in this respect. This means that a lambda which accesses one of those
variables after the original enclosing scope has been destroyed is engaging in
undefined behavior and will likely crash. Compare this to __block variables, where the
storage is transparently moved to the heap and is guaranteed to live at least as long
as the block does.
この動作のひとつの extremely important な aspect は、by reference で捕獲された変数が
lambda オブジェクトの中で reference として格納されるということです。それらの変数は
this respect において 特別な扱いを受けません。これはつまり、original enclosing scope
が破棄された後でそういった変数のどれか一つにでもアクセスする lambda は未定義動作を
engaging してたぶんクラッシュするだろうということです。これを __block 変数と比較すると、
storage の場所がヒープへと transparently に move し、少なくともブロックと同じ長さの寿
命が gurantee されます。
On the other hand, as long as nothing is captured by reference, a C++0x lambda can be
returned without any extra work. The return will copy it and the copy will continue to
function. With Objective-C blocks, they must be explicitly copied before returning,
otherwise they become immediately invalid.
その一方で、 by reference で捕獲されていないので C++0x の lambda は一切 extra work
をすることなく return できます。
The return will copy it and the copy will continue to function.
Objective-C のブロックの場合は return する前に explicitly にコピーしなければならず、
さもなければ即座に invalid なものになってしまいます。
Performance
性能
Objective-C blocks are objects which contain an embedded function pointer. A block
call translates to a call to that function pointer, passing the block as an implicit
parameter:
Objective-C のブロックは埋め込まれた関数ポインターを持っているオブジェクトです。
あるブロックの呼び出しは、暗黙の引数としてそのブロックを渡す
(ブロックに)埋め込まれた関数ポインターを使った呼び出しへと変換されます。
block();
// equivalent to:
block->impl(block);
The cost of calling a block is therefore about the same as the cost of calling a C
function. It's slightly higher due to the need to look up the implementation pointer
first, but just slightly.
ブロック呼び出しのコストはしたがって、 C の関数呼び出しのコストと概ね同じものです。
最初に implementation pointer の look up が必要である分、
ブロック呼び出しの方がわずかに高価なのは確かですが、本当にわずかなものです。
Opportunities for optimization are rare in most use cases. For example, this code
calls a method to iterate over an array with a block:
ほとんどの場合、最適化の機会はほぼありません。
例として、次のようなブロック中にある配列を iterate over するメソッドを呼び出すコードを挙げます:
[array do: ^(id obj) {
NSLog(@"Obj is %@", obj);
}];
The implementation of -do: can't know anything about the block which is passed to it
here, so it must perform the full dereference and call for each iteration of the loop.
この例の -do: の実装は渡されたブロックについて何も知ることができないので、
ループの iteration ごとに full dereference と呼び出しを行わなければなりません。
The cases where blocks can be optimized are mostly cases where they're not needed in
the first place, for example where they are defined and then called in the same scope.
One place where useful optimizations could be made are inline functions which take
block parameters, since the optimizer is able to improve the inlined code based on the
calling code. However, as far as I know, no current blocks-capable compilers perform
any of these optimizations, although I haven't investigated it thoroughly.
ブロックが最適化可能であるようなケースは、たいていはそのブロックが in the first place
で必要とされていないケース、例えば同じスコープで定義と呼び出しがされているといったもの
です。useful な最適化が可能であるかもしれない場所の一つがブロックパラメーターを引数に
とるインライン関数です。それは、オプティマイザーが calling code に基づいてinline され
たコードを改良できるからです。しかしながらわたしの知る限りでは、
although I haven't investigated it thoroughly.
このような最適化の何かを行う block-capable なコンパイラーは現状でありません。
C++0x lambdas are objects with a operator(). There is no dynamic dispatch involved, so
calling the lambda works out to be a simple function call, with no dereferencing ahead
of time.
C++0x のlambda は operator() を持ったオブジェクトです。
これは動的ディスパッチが involve されないので、lambda の呼び出しは単純な関数呼び出しとして
dereferene の ahead of time もなく works out します
Because passing a lambda to another function involves templates, there are further
opportunities for optimization. Consider this code to iterate over a vector:
別の関数に lambda を渡すことによって template を invlove するので、
最適化のための更なる機会があります。
あるベクターを iterate する次のコードで考えてみましょう:
for_each(v.begin(), v.end(), [](int x) {
printf("x is %d\n", x);
});
for_each is a template function, which means that it gets specialized for this
particular type. This makes it an excellent candidate for inlining, and it's likely
that an optimizing compiler will end up generating code for the above which would be
just as good as the equivalent for loop.
この for_each は特定の型に対して特殊化されたテンプレート関数です。
This makes it an excellent candidate for inlining,
インライン展開の excellent candidate にする
and it's likely
that an optimizing compiler will end up generating code for the above
which would be just as good as the equivalent for loop.
最適化コンパイラーが最終的に for ループと同程度に優れているであろうコードを生成する
This is a typical tradeoff between C++ and Objective-C. C++ often favors the fastest
possible generated code at the level of individual functions, sacrificing ease and
speed of compilation and sometimes ease of programming to get it. Objective-C more
often favors implementations which are simpler to create, compile, and use, at the
cost of additional runtime overhead.
これは C++ と Objecive-C との間にある典型的なトレードオフです。
C++ はしばしば ease and speed of compilation だとか、
ときには ease of programming to get it まで犠牲にしても
可能な限り高速な生成コードを favor します。
Objective-C は additional runtime overhead のコストの点で、
作成やコンパイル、あるいは使うのがシンプルである実装をより一層 favor します
Conclusion
結論
Objective-C blocks and C++0x lambdas are similar language features with similar goals
but considerably different approaches. Objective-C blocks are somewhat simpler to
write and to use, especially in the case of using them for asynchronous or background
tasks where the block has to be copied and kept alive beyond the lifetime of the scope
where it was created. C++0x lambdas ultimately provide more flexibility and potential
speed, but at the cost of considerable added complexity. In comparing the two, I
believe that Apple ultimately made the better set of tradeoffs, at least for the cases
where I am likely to use blocks in my own programming.
Objectice-C のブロックと C++0x の lambda は、似通った目標を持っているけれども異なるア
プローチを採用している類似の言語機能です。Objective-C のブロックは書いたり使ったりする
のが簡単な、somewhat で、特にブロックがコピーされなければならなかったり、また、作られ
たスコープの lifetime を越えて keep alive されなければならない非同期なタスクやバックグ
ラウンドタスクに使うようなケースで使われるものです。C++0x の lambda は
more flexibility と potential speed を ultimately に provide しますが、
cost of considerable な complexity を付加します。
これら二つを比較したとき、
少なくともわたし自身がプログラミングするときにブロックを使いたくなるような状況で
Apple は、最終的に better set of tradeoff を made するとわたしは確信していします。
That wraps things up for this week. Come back in another 14 days for the next baffling
edition. As I say every time, Friday Q&A is driven by reader ideas. If you have a
topic that you would like to see covered here, please send it in. Did you enjoy this
article? I'm selling a whole book full of them. It's available for iBooks and Kindle,
plus a direct download in PDF and ePub format. It's also available in paper for the
old-fashioned. Click here for more information.
When not writing these blog posts, I put this stuff into action over at Rogue Amoeba,
where we create great audio software for the Mac.
