#include <iostream>

int main()
{
   std::cout << []{ return 0; } << '\n';
}

#include <iostream>
#include <iomanip>

int main()
{
   std::cout << std::boolalpha << []{ return 0; } << '\n';
}

PMT>#include <iostream>

PMT>int main()
PMT>{
PMT>   std::cout << []{ return 0; } << '\n';
PMT>}
PMT>

#include <iostream>

int main()
{
   int x = 0;
   auto lm = [x] { return x; };
      
   std::cout << lm << std::endl;
}

#include <iostream>

int main()
{
   int ( *fn )( void ) = [] { return 0; };
   std::cout << fn << std::endl;
}

basic_ostream<charT,traits>& operator<<(const void* p);

basic_ostream<charT,traits>& operator<<(const void* p);

A prvalue of arithmetic, unscoped enumeration, pointer, or pointer to member type can be converted to a prvalue of type bool.

An lvalue of function type T can be converted to a prvalue of type “pointer to T.” The result is a pointer to the function.

A prvalue of type “pointer to cv T,” where T is an object type, can be converted to a prvalue of type “pointer to cv void”.

An object is a region of storage. [ Note: A function is not an object, regardless of whether or not it occupies storage in the way that objects do. —end note ]

basic_ostream<charT,traits>& operator<<(const void* p);

#include <iostream>

int f() { return 0; }

int main()
{
   std::cout << f;
}

The semantics of initializers are as follows. The destination type is the type of the object or reference being initialized and the source type is the type of the initializer expression. If the initializer is not a single (possibly parenthesized) expression, the source type is not defined.

— If the initializer is a (non-parenthesized) braced-init-list, the object or reference is list-initialized (8.5.4).
— If the destination type is a reference type, see 8.5.3.
— If the destination type is an array of characters, an array of char16_t, an array of char32_t, or an array of wchar_t, and the initializer is a string literal, see 8.5.2.
— If the initializer is (), the object is value-initialized.
— Otherwise, if the destination type is an array, the program is ill-formed.
— If the destination type is a (possibly cv-qualified) class type:
[...]
— Otherwise, if the source type is a (possibly cv-qualified) class type, conversion functions are considered. The applicable conversion functions are enumerated (13.3.1.5), and the best one is chosen through overload resolution (13.3). The user-defined conversion so selected is called to convert the initializer expression into the object being initialized. If the conversion cannot be done or is ambiguous, the initialization is ill-formed.[/b]
[...]

Under the conditions specified in 8.5, as part of an initialization of an object of nonclass type, a conversion function can be invoked to convert an initializer expression of class type to the type of the object being initialized. Overload resolution is used to select the conversion function to be invoked. Assuming that “cv1 T” is the type of the object being initialized, and “cv S” is the type of the initializer expression, with S a class type, the candidate functions are selected as follows:

— The conversion functions of S and its base classes are considered. Those non-explicit conversion functions that are not hidden within S and yield type T or a type that can be converted to type T via a standard conversion sequence (13.3.3.1.1) are candidate functions. For direct-initialization, those explicit conversion functions that are not hidden within S and yield type T or a type that can be converted to type T with a qualification conversion (4.4) are also candidate functions. Conversion functions that return a cv-qualified type are considered to yield the cv-unqualified version of that type for this process of selecting candidate functions. Conversion functions that return “reference to cv2 X” return lvalues or xvalues, depending on the type of reference, of type “cv2 X” and are therefore considered to yield X for this process of selecting candidate functions.

int main()
{
    struct A {} a;
    if ( a );
}

int main()
{
    struct A { operator bool () const { return ( true ); } } a;
    if ( a );
}

С>#include <iostream>

С>int main()
С>{
С>   int ( *fn )( void ) = [] { return 0; };
С>   std::cout << fn << std::endl;
С>}
С>

#include <iostream>
#include <iomanip>

int main()
{
   int ( *fn )( void ) = [] { return 0; };
   std::cout << std::boolalpha << fn << '\n' << reinterpret_cast<const void*>(fn) << std::endl;
}

Compilation output:
source.cpp: In function 'int main()':
source.cpp:7:81: warning: ISO C++ forbids casting between pointer-to-function and pointer-to-object [enabled by default]

Execution output:
true
0x8048b16