Why can’t I define a function inside another function?

by

It is not obvious why one is not allowed; nested functions were proposed a long time ago in N0295 which says:

We discuss the introduction of nested functions into C++. Nested
functions are well understood and their introduction requires little
effort from either compiler vendors, programmers, or the committee.
Nested functions offer significant advantages, […]

Obviously this proposal was rejected, but since we don’t have meeting minutes available online for 1993 we don’t have a possible source for the rationale for this rejection.

In fact this proposal is noted in Lambda expressions and closures for C
++ as a possible alternative:

One article [Bre88] and proposal N0295 to the C
++ committee [SH93] suggest adding nested functions to C
++ . Nested functions are similar to lambda expressions, but are defined as statements within a function body, and the resulting
closure cannot be used unless that function is active. These proposals
also do not include adding a new type for each lambda expression, but
instead implementing them more like normal functions, including
allowing a special kind of function pointer to refer to them. Both of
these proposals predate the addition of templates to C
++ , and so do not mention the use of nested functions in combination with generic algorithms. Also, these proposals have no way to copy
local variables into a closure, and so the nested functions they
produce are completely unusable outside their enclosing function

Considering we do now have lambdas we are unlikely to see nested functions since, as the paper outlines, they are alternatives for the same problem and nested functions have several limitations relative to lambdas.

As for this part of your question:

// This is legal, but why would I want this?
int two(int bar);

There are cases where this would be a useful way to call the function you want. The draft C++ standard section 3.4.1 [basic.lookup.unqual] gives us one interesting example:

namespace NS {
    class T { };
    void f(T);
    void g(T, int);
}

NS::T parm;
void g(NS::T, float);

int main() {
    f(parm); // OK: calls NS::f
    extern void g(NS::T, float);
    g(parm, 1); // OK: calls g(NS::T, float)
}

More Related Contents:

  1. What are C++ functors and their uses?
  2. Function passed as template argument
  3. Why override operator()?
  4. How do I get the argument types of a function pointer in a variadic template class?
  5. demote boost::function to a plain function pointer
  6. Why use functors over functions?
  7. Why do functions need to be declared before they are used?
  8. passing functor as function pointer
  9. How to create an object in a form like this: ifstream in();
  10. How to use sort() in C++ with custom sort member function?
  11. How can it be useful to overload the “function call” operator?
  12. When to use functors over lambdas
  13. Char* combining [closed]
  14. Why does dividing two int not yield the right value when assigned to double?
  15. How can I use cout
  16. static_assert dependent on non-type template parameter (different behavior on gcc and clang)
  17. Division in C++ not working as expected
  18. Good input validation loop using cin – C++
  19. make shared_ptr not use delete
  20. C++ high precision time measurement in Windows
  21. Why should I avoid std::enable_if in function signatures
  22. Why are memcpy() and memmove() faster than pointer increments?
  23. What is std::decay and when it should be used?
  24. Does “undefined behaviour” extend to compile-time?
  25. Preventing a MEX file from crashing in MATLAB
  26. Is there any case where a return of a RValue Reference (&&) is useful?
  27. C++ : Creating an array with a size entered by the user
  28. Who defines C operator precedence and associativity?
  29. What is Linux’s native GUI API?
  30. How to use the priority queue STL for objects?

Leave a Comment