Nested functions in C++

[A]

Hi,

How do you make use of nested functions in C++? I realize in C++ that
everything must be declared first in a header file before implementation in
a .cpp file. I tried to nest a method prototype in another prototype but
seems pointless. Can someone please write a short, simple, and concise
skeleton code of how to use nested functions?

class Foo
{
private:
int a;
int b;

public:
void funcA();
void funcB(); // seems pointless
}

void Foo:: funcA()
{
this->funcB;
void Foo::funcB()
{...}
}
//error: local method problem

any help appreciated.

Regards
reuytrt

 

[Dave Theese]

Hi,

How do you make use of nested functions in C++? I realize in C++ that
everything must be declared first in a header file before implementation in
a .cpp file. I tried to nest a method prototype in another prototype but
seems pointless. Can someone please write a short, simple, and concise
skeleton code of how to use nested functions?

class Foo
{
private:
int a;
int b;

public:
void funcA();
void funcB(); // seems pointless
}

void Foo:: funcA()
{
this->funcB;
void Foo::funcB()
{...}
}
//error: local method problem

any help appreciated.

Regards
reuytrt

Functions may not be nested in C++. Nor is it *required* that declarations
appear in a header file, but good design generally dictates that interface
and implementation be separated.

Hope this helps!

 

[John Tsiombikas (Nuclear / the Lab)]

Hi,

How do you make use of nested functions in C++?

you can't...

-- Nuclear / the Lab --

 

[Alf P. Steinbach]

How do you make use of nested functions in C++?

Before you can use them you must have them.

C++ does not support nested function à la Pascal, but does support a
limited form of local classes (nested in functions).

You can use local classes to achieve logical nesting, but a member
function of a local class doesn't have access to the arguments and
local variables of the enclosing function unless you provide such
access yourself, e.g. via reference constructor arguments.

I realize in C++ that everything must be declared first in a header
file before implementation in a .cpp file.

That is incorrect; the C++ standard does not even mention files.

I tried to nest a method prototype in another prototype but
seems pointless. Can someone please write a short, simple, and concise
skeleton code of how to use nested functions?

class Foo
{
private:
int a;
int b;

public:
void funcA();
void funcB(); // seems pointless
}

It is, indentation is not equal to logical nesting.

void Foo:: funcA()
{
this->funcB;
void Foo::funcB()
{...}
}
//error: local method problem

any help appreciated.

The best you can do is forget it, then investigate the issue anew
in a few years time.

 

[Ying Yang]

Functions may not be nested in C++. Nor is it *required* that declarations
appear in a header file, but good design generally dictates that interface
and implementation be separated.

Hope this helps!

Surely there must be a solution to this problem. The reason i wanted to do
this is because i want to be able to group related functions together. For
example a function that calls another related function to solve a problem
(this can be seen in indirect recursion calls).


Regards
ewrewrwer

 

[Bronek Kozicki]

Surely there must be a solution to this problem. The reason i wanted to do
this is because i want to be able to group related functions together. For

This is exactly why C++ was invented - to group functions together into
classes. Look at following (incorrect) code:

int f(int i)
{
int j = i + 1;
int a() // local function is invalid!
{
return j * i;
};

return a() + i;
}

it won't work, but you can use class instead:

class f {
const int& i; // variables shared between all ...
int j; // ... functions grouped into class
int ret; // return value
int a() // "internal" function
{
return j * i;
}
public:
f(const int& arg_i) : i(arg_i), j(i + 1)
{
ret = a() + i;
}

operator int() {return ret;}
// bonus: alternate return type from function object
operator std::string() {return "hi!";}
};

You may call your function object simply creating it:
int r = f(3);

you may also retrieve its "alternate" return value:
std::string q = f(4);

regards


B.

 

[Sektor van Skijlen]

# Look at following (incorrect) code:

# int f(int i)
# {
# int j = i + 1;
# int a() // local function is invalid!
# {
# return j * i;
# };
#
# return a() + i;
# }

# it won't work, but you can use class instead:

Maybe, but this will not replace the local (or nested, as you like) functions.
It just tries to help with the problem they deal with.

Local functions have an access to the local environment of the parent function.
You cannot achieve this in C++. To have local functions you would like also
to have a mechanism of closures, as it is done for example in boost:hoenix.

# You may call your function object simply creating it:
# int r = f(3);

# you may also retrieve its "alternate" return value:
# std::string q = f(4);

Fine, but you still have to pass arguments to such a "functionate".
You have declared a local function in this (incorrect) code before,
which does not need to be passed an argument; it takes the value from
the local environment from the parent function. You cannot simulate
this anyhow in C++ (unless you directly pass a "closure" as an argument .

Regards,


--
1 6 1 7 4 4 2 548 g4bc7a4 66z 3xt7w v1y z9p1 120 32
(( Michal "Sektor" Malecki w4 66 64 73 7564 24 5 v 34 4
)) ektor van Skijlen 1 5 5 1 844 a v r z 4
Software engineer, Motorola GSG Poland 1 2 2a 1 4
WARNING: Opinions presented by me on usenet groups are my personal opinions
ONLY and are not connected to the employer.

 

[michael.george.hart]

Here is your nested function/functor

If you really want nested function, functor will do just a well, and the compiler can probably can do better optimization with them. Best of all you get to play friendship relationship.

#include <iostream>
int main(int argc, char **argv)
{

struct Function1
{

double operator()(double y)
{

return 3 * y;
​

}
​

};

struct Function2
{

struct Nested
{

double operator()(int x)
{

return x + 1;
​

}
​

};

double operator()(int y)
{

Nested nested;
return 2 * nested(y);
​

};
​

};


Function1 _1_level_nesting;

Function2 _2_level_nesting;

std::cout

<< "Hello, world!" << std::endl
<< "here is 1 levels nesting relative to main: " << _1_level_nesting(85) << std::endl
<< "here is 2 levels nesting relative to main: " << _2_level_nesting(10) << std::endl
​

;

return 0;
​

}