Closures and memory allocation

[Anonymouse]

I'm looking into why my thing does so many memory allocations. 
Profiling with kcachegrind shows _d_allocmemory being called upon 
entering a certain function, lots and lots of times.

It's a function that receives concurrency messages, so it 
contains nested functions that close over local variables. Think 
receiveTimeout(0.seconds, &nested1, &nested2, &nested3, ...) with 
13 pointers to nested functions passed.

When entering the following function, does it allocate:

1. 0 times, because while there are closures defined, none is 
ever called?
2. 2 times, because there are closures over two variables?
3. 20 times, because there are 20 unique closures?

void foo()
{
     int i;
     long l;

     void foo01(bool b_) { i += 1; }
     void foo02(string s) { i += 2; }
     void foo03(int n) { i += 3; }
     void foo04(float f) { i += 4; }
     void foo05(double d) { i += 5; }
     void foo06() { i += 6; }
     void foo07() { i += 7; }
     void foo08() { i += 8; }
     void foo09() { i += 9; }
     void foo10() { i += 10; }
     void foo11() { l += 11; }
     void foo12() { l += 12; }
     void foo13() { l += 13; }
     void foo14() { l += 14; }
     void foo15() { l += 15; }
     void foo16() { l += 16; }
     void foo17() { l += 17; }
     void foo18() { l += 18; }
     void foo19() { l += 19; }
     void foo20() { l += 20; }

     auto f01 = &foo01;
     auto f02 = &foo02;
     auto f03 = &foo03;
     auto f04 = &foo04;
     auto f05 = &foo05;
     auto f06 = &foo06;
     auto f07 = &foo07;
     auto f08 = &foo08;
     auto f09 = &foo09;
     auto f10 = &foo10;
     auto f11 = &foo11;
     auto f12 = &foo12;
     auto f13 = &foo13;
     auto f14 = &foo14;
     auto f15 = &foo15;
     auto f16 = &foo16;
     auto f17 = &foo17;
     auto f18 = &foo18;
     auto f19 = &foo19;
     auto f20 = &foo20;
}