Clang++ generates executable that leaks memory, about std::function and lambda

Question

Clang++ 3.2 on ArchLinux (i686) is used to build the following C++11 codes

#include <iostream>
#include <functional>

typedef std::function<void ()> Action;
typedef std::function<int ()> Generator;

Action act(Generator const& gen)
{
    return [=]()
    {
        std::cout << gen() << std::endl;
    };
}

int main()
{
    static Generator const gen([]() { return 0; });
    act(gen);
    return 0;
}

With clang++ test.cpp -std=c++0x && valgrind --leak-check=full --log-file=tmp.log.memcheck ./a.out then I get

==600== HEAP SUMMARY:
==600==     in use at exit: 1 bytes in 1 blocks
==600==   total heap usage: 3 allocs, 2 frees, 18 bytes allocated
==600== 
==600== 1 bytes in 1 blocks are definitely lost in loss record 1 of 1
==600==    at 0x402B124: operator new(unsigned int) (in /usr/lib/valgrind/vgpreload_memcheck-x86-linux.so)
==600==    by 0x8048D4F: std::_Function_base::_Base_manager<main::$_1>::_M_clone(std::_Any_data&, std::_Any_data const&, std::integral_constant<bool, false>) (in /home/neuront/a.out)
==600==    by 0x8048C21: std::_Function_base::_Base_manager<main::$_1>::_M_manager(std::_Any_data&, std::_Any_data const&, std::_Manager_operation) (in /home/neuront/a.out)
==600==    by 0x8049455: std::function<int ()>::function(std::function<int ()> const&) (in /home/neuront/a.out)
==600==    by 0x8049283: std::function<int ()>::function(std::function<int ()> const&) (in /home/neuront/a.out)
==600==    by 0x80489B1: act(std::function<int ()> const&) (in /home/neuront/a.out)
==600==    by 0x8048A6C: main (in /home/neuront/a.out)
==600== 
==600== LEAK SUMMARY:
==600==    definitely lost: 1 bytes in 1 blocks
==600==    indirectly lost: 0 bytes in 0 blocks
==600==      possibly lost: 0 bytes in 0 blocks
==600==    still reachable: 0 bytes in 0 blocks
==600==         suppressed: 0 bytes in 0 blocks
==600== 
==600== For counts of detected and suppressed errors, rerun with: -v
==600== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)

I'm not sure whether there's any problem with that code (and causes just ONE byte leak), but there will be no memory leak if using g++ 4.7 to compile. Any suggestion about that?

Answer 1

The allocation is happening here:

    return [=]()

Which says "Capture everything that's not a parameter by value", including "std::cout" etc, which means making copies of them.

The following code passes the same compile & valgrind check without the errors, but with the caveat that the programmer is responsible for ensuring the lifetime of act's "gen" parameter is longer than the lifetime of the lambda.

#include <iostream>
#include <functional>

typedef std::function<void ()> Action;
typedef std::function<int ()> Generator;

Action act(Generator const& gen)
{
    return [&gen]()
    {
        std::cout << gen() << std::endl;
    };
}

int main()
{
    static Generator const gen([]() { return 0; });
    act(gen);
    return 0;
}

See also http://en.cppreference.com/w/cpp/language/lambda