C++ does not support nested function. Say I have function a and b, I want to guarantee that only a can call b, and nobody else can, is there a way of doing so?
4 Answers
There are multiple ways of doing this (none are 100% bulletproof, someone can always edit your source files), but one way would
Put the function inside a class, make it private, and make the functions that you want to have the ability to call it "friends."
Assuming you want function
ato be callable by functionbbut no one else, another way would be to putaandbin their own source file together and makeastatic. This way,awould only be visible to entities in the same source file, butbwould be visible to everyone who had it's signature.
Or 3. If you can use lambdas (i.e. your compiler supports this feature of C++11):
void a() { auto f = []() { /* do stuff */ } f(); } 
4 Comments
Andrew Marshall
Note that lambdas are C++11 only. (Perhaps that's why someone downvoted?)
Seth Carnegie
@AndrewMarshall I don't know why though, I said "If you can use lambdas"
John Yang
I don't know who downvoted it (I upvoted it), but I like Branko's method most. It seems that your methods are kind of exotic.
Seth Carnegie
@JohnYang I guess I'm just an exotic kind of a guy.
int main() { class a { public: static void foo(){} }; a::foo(); } It compiles fine for me, so you can have "nested functions" in C++
Comments
The passkey idiom.
class KeyForB{ // private ctor KeyForB(){} friend void a(); }; void a(){ b(KeyForB()); } void b(KeyForB /*unused*/){ } 
Comments
No, but you can always create a function-level class. For example:
void MyFunction() { class InnerClass { public: static void InnerFunction() { } }; InnerClass::InnerFunction(); InnerClass::InnerFunction(); // ... }; answered Oct 30, 2011 at 16:26
Branko Dimitrijevic
52.3k12 gold badges103 silver badges174 bronze badges
3 Comments
John Yang
I don't why other people don't like your solution (can anyone comment?), it seems to me is the easiest and most practical way of doing the job.
Quuxplusone
I didn't downvote, but FWIW, (1) this won't work if
InnerFunction is a template; (2) anytime this would work, you can/should just use a lambda instead; (3) typically you break code up into functions so that you can move it out of line. Answerers/voters here naturally assume that you want to limit the callers of an ordinary out-of-line function, not (as here) simply take that function and in-line it into the scope where it's used. (This also means this approach fails if there are two callers.)
Branko Dimitrijevic
I wrote this answer before lambdas were widely supported in C++. The asker himself wrote: "C++ does not support nested function." which suggests they were not looking for "out-of-line" function. And finally,
MyFunction itself can be made a template and then the template parameter used inside InnerFunction, which may or may not be enough in a specific situation.