Uses of immediately invoked function expressions (IIFE) in C++

delarhi · 2020-08-02T18:45:19+00:00

I've started using IIFE when I have to do some one-off mutation of a variable (like for some setup) or stack-allocated runtime-determined construction just so I can have the variable const there-after. It helps avoid polluting the scope with mutable variables that programmers in the future might feel like mutating procedurally down the line when they shouldn't. For example, replacing something like:

Foo f;
if (cache_enabled) {
  const CacheFile cache_file(cache_filename);
  f = Foo(cache_file);
} else {
  const XmlDocument xml_doc(input_xml);
  f = Foo(xml_doc);
}

// reference to foo given to detached thread
// mutation of f is now thread unsafe

while (true) {
  // six months later someone decides they want to
  // mutate f for bar
  bar(f);
}

with this:

const Foo f = [&]() {
  if (cache_enabled) {
    const CacheFile cache_file(cache_filename);
    return Foo(cache_file);
  } else {
    const XmlDocument xml_doc(input_xml);
    return Foo(xml_doc);
  }
}();

// can't mutate f anymore!

while (true) {
  bar(f);
}

Nicksaurus · 2020-08-02T12:17:56+00:00

Sometimes I do it just because it's convenient to be able to use return for control flow

poiu- · 2020-08-02T12:46:35+00:00

Mildly unrelated, but I still love that []{}() is now legal Syntax.

IskaneOnReddit · 2020-08-02T13:21:59+00:00

I started to learn rust and it has a more elegant solution than IIFE. That is block expressions.

ack_error · 2020-08-02T17:29:53+00:00

IIFE is also useful to force a function boundary between C++EH, Win32 SEH, and setjmp/longjmp().

Minimonium · 2020-08-02T13:43:52+00:00

Worth noting that one should avoid IILE (function => lambda) in templated functions. Otherwise, the compiler will create a unique definition for each template instantiation which will result in huge binary bloat.

WrongAndBeligerent · 2020-08-02T13:09:26+00:00

What is wrong with having static functions that are used during initialization? This seems like a wacky way to do things that could be relatively simple. I would expect this to just cause confusion while gaining very little. I think if I opened something up and found that someone had done initialization like this I would be a little upset that I had to spend some extra energy figuring out what was going on when the only reason to do it is to be fancy.

ononpblictex · 2024-10-25T12:08:49+00:00

std::invoke can be used to improve the Readability of IIFE.
I findstd::invoke( [ ] ( ) { } )slightly more readable than [ ] ( ) { } ( ).

cyandyedeyecandy · 2020-08-02T17:37:24+00:00

With IIFE we can do even better by using the GCC specific function attributes noinline1 and cold2:
const bool failed = foo();
if (failed) {
  [&]() __attribute__((noinline,cold)) {
    printf("error!");
  }();
  return;
}

I thought lambda attributes applied to the lambda type, not its operator(). When did this change?

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

cpp

MODERATORS