15

What's everybody's opinion on using lambdas to do nested functions in C++? For example, instead of this:

static void prepare_eggs()
{
   ...
}

static void prepare_ham()
{
   ...
}

static void prepare_cheese()
{
   ...
}

static fry_ingredients()
{
   ...
}

void make_omlette()
{
    prepare_eggs();
    prepare_ham();
    prepare_cheese();
    fry_ingredients();
}

You do this:

void make_omlette()
{
    auto prepare_eggs = [&]()
    {
       ...
    };

    auto prepare_ham = [&]()
    {
       ...
    };

    auto prepare_cheese = [&]()
    {
       ...
    };

    auto fry_ingredients = [&]()
    {
       ...
    };


    prepare_eggs();
    prepare_ham();
    prepare_cheese();
    fry_ingredients();
}

Having come from the generation that learned how to code by using Pascal, nested functions make perfect sense to me. However, this usage seemed to confuse some of the less experienced developers in my group at work during a code review where I made use of lambdas in this way.

Improve this question
13
  • 8
    Why?? Why on earth do you need this? Commented Feb 24, 2012 at 22:20
  • 4
    While Arcadio is an awesome name, I'm afraid it doesn't really make this use of lambdas any less pointless. If those functions are not used anywhere else, there's no point in putting them into a lambda, and you should just write the code in the function normally. Commented Feb 24, 2012 at 22:21
  • 1
    @VladLazarenko presumably to limit static scope. But I'd never do this for this reason. There are reasons for using lambdas. This isn't (IMO) not one of them. Commented Feb 24, 2012 at 22:22
  • 2
    It makes sense to declare a function local lambda if you intend to use the function in multiple calls to template functions or if the lambda is getting exceedingly ugly to format inside a function argument list. Commented Feb 24, 2012 at 22:29
  • 1
    Or simply new local blocks. void foo () { int x; { int y; } /*no more y*/ } Commented Feb 24, 2012 at 22:32

5 Answers 5

Reset to default
16

I don't see anything wrong with nested functions per se. I use lambdas for nested functions, but only if it meets some conditions:

  • It is called in more than once place. (otherwise just write the code directly if it's not too long)
  • It is really an internal function, so that that calling it in any other context would not make sense.
  • It's short enough (maybe 10 lines max).

So in your example I would not use lambdas for reason number one.

Conceptually nested functions can be useful for the same reason why private methods in classes are useful. They enforce encapsulation and they make it easier to see the structure of the program. If a function is an implementation detail to some other function then why not make it explicitly so?

The biggest problem I see is with readability; it's more difficult to read code that has a lot of nesting and indenting. Also, people are not very comfortable with lambdas yet so resistance is expected.

Improve this answer
Sign up to request clarification or add additional context in comments.

1 Comment

Another reason for local functions is if you are using a local type.
9

For any given piece of code, make it as visible as necessary and as hidden as possible:

  • If the piece of code is used in only one place, write it there.
  • If it is used in multiple places inside the same function, emulate nested functions through lambdas.
  • If it is used by multiple functions, put it in a proper function.
Improve this answer

Comments

2

You can already guess that you're doing something unorthodox by the comments you received. This is one of the reasons C++ has bad reputation, people never stop abusing it. Lambdas are mainly used as inline function objects for standard library algorithms and places that require some kind of callback mechanism. I think this covers 99% of use-cases, and it should stay that way!

As Bjarne said in one of his lectures: "Not everything should be a template, and not everything should be an object."

And not everything should be a lambda :) there is nothing wrong with a free standing function.

Improve this answer

4 Comments

They are also a great alternative to std::bind
@pmr: Yes, but why are you binding something? To use as a function argument to a callback/algorithm. It doesn't change the use case, simply the different pattern of use.
I think the question doesn't really give enough info about the context to assume that it is abuse. After all, sometimes you need function-local types or functions. It can be useful. The question isn't precise enough for me to agree with your answer. (but I didn't -1)
A free standing function violates the locality principle when you only need the function within the body of another function. Lambdas are not an abuse just because they confuse programmers who are only use to imperative programming or are not used to nested functions.
1

It's a very limited use case. For starters, the functionality present in the local function must be needed at several spots inside the enclosing function such that the resulting local refactoring will be a win in readability. Otherwise I will write the functionality inline, perhaps putting it in a block if that helps.

But at the same time, the functionality must be local or specific enough that I don't have an incentive to refactor the functionality outside of the (not so) enclosing function, where I could perhaps reuse it entirely in another function at some point. It must also be short: otherwise I'm just going to move it out, perhaps putting it in an anonymous namespace (or namespace detail in a header) or some such. It doesn't take much for me to trade locality off in favour of compactness (long functions are a pain to review).

Note that the above is strictly language agnostic. I don't think C++ spins a particular spin on that. If there is one particular C++ advice I have to give on the topic however, it's that I would proscribe using a default by-reference capture ([&]). There'd be no way to tell if that particular lambda expression describe a closure or a local function without carefully reviewing the whole body. Which wouldn't be that bad (it's not that closures are 'scary') if not for the fact that that by-reference captures ([&], [&foo]) allow mutations even if the lambda is not marked mutable, and by-value captures ([=], [foo]) can make an undesirable copy, or even attempt an impossible copy for move-only types. All in all I'd rather not capture anything at all if it's possible (that's what parameters are for!), and use individual captures when needed. It's especially problematic

To sum up:

// foo is expensive to copy, but ubiquitous enough
// that capturing it rather than passing it as a parameter
// is acceptable
auto const& foo_view = foo;
auto do_quux = [&foo_view](arg_type0 arg0, arg_type1 arg1) -> quux_type
{
    auto b = baz(foo_view, arg0, arg1);
    b.frobnicate;
    return foo_view.quux(b);
};

// use do_quux several times later
Improve this answer

Comments

-1

In my opinion it's useless, but you can accomplish that using only C++03

void foo() {
  struct {
    void operator()() {}
  } bar;
  bar();
}

But once again, IMHO it's useless.

Improve this answer

6 Comments

I don't think you can have a static operator() operator definition.
While this works, I'd opt for struct bar { bar() { /* ... */ } }; bar(); instead if I were to use something like this.
@hvd unfortunately it will not be a function object anymore. But actually bar being a function object is only of very little use in C++03 because you couldn't pass it as a parameter to templates anyway. Such a pity. In C++11 you can, but in C++11 you don't need this workaround in the first place :)
@JohannesSchaub-litb If you mean it still has some use as a function object, could you elaborate? I'm not sure what use that would be.
@hvd constructors can't return anything.
|

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.