Question

From the wikipedia article about Lambda functions and expressions:

users will often wish to define predicate functions near the place
where they make the algorithm function call. The language has only one
mechanism for this: the ability to define a class inside of a
function. … classes defined in functions do not permit them to be used in templates

Does this mean that use of nested structure inside function is silently deprecated after C++0x lambda are in place ?

Additionally, what is the meaning of last line in above paragraph ? I know that nested classes cannot be template; but that line doesn’t mean that.

Answer 1

Is there any use case for class inside function after introduction of lambda ?

Definitely. Having a class inside a function is about:

• localising it as a private implementation detail of the code intending to use it,
• preventing other code using and becoming dependent on it,
• being independent of the outer namespace.

Obviously there’s a threshold where having a large class inside a function harms readability and obfuscates the flow of the function itself – for most developers and situations, that threshold is very low. With a large class, even though only one function is intended to use it, it may be cleaner to put both into a separate source file. But, it’s all just tuning to taste.

You can think of this as the inverse of having private functions in a class: in that situation, the outer API is the class’s public interface, with the function kept private. In this situation, the function is using a class as a private implementation detail, and the latter is also kept private. C++ is a multi-paradigm language, and appropriately gives such flexibility in modelling the hierarchy of program organisation and API exposure.

Examples:

• a function deals with some external data (think file, network, shared memory…) and wishes to use a class to represent the binary data layout during I/O; it may decide to make that class local if it only has a few fields and is of no use to other functions
• a function wants to group a few items and allocate an array of them in support of the internal calculations it does to derive its return value; it may create a simple struct to wrap them up.
• a class is given a nasty bitwise enum, or perhaps wants to reinterpret a float or double for access to the mantisa/exponent/sign, and decides internally to model the value using a struct with suitable-width bitfields for convenience (note: implementation defined behaviours)

classes defined in functions do not permit them to be used in templates

I think you commented that someone else’s answer had explained this, but anyway…

void f()
{
    struct X { };
    std::vector<X> xs;  // NOPE, X is local
}