function prototype in code block

[anoncoholic]

Just found out that this is legal (news to me):

int myfunc( int a )
{
int i = 0;
i = i * a;
int blah( float aa ); // <- huh?
return i;
}

You can declare a function inside another function?? How long has this
been possible? Note, i'm not talking about gcc's extension that supports
nested functions. Just talking about the prototype.

[Eric Sosman]

anoncoholic wrote:

Just found out that this is legal (news to me):

int myfunc( int a )
{
int i = 0;
i = i * a;
int blah( float aa ); // <- huh?
return i;
}

You can declare a function inside another function?? How long has this
been possible? Note, i'm not talking about gcc's extension that supports
nested functions. Just talking about the prototype.

It's been possible to *declare* a function inside a
function for as long as I can remember, even back to the
pre-Standard decades. Personally, I've never thought it
a particularly splendid idea, but it may come in handy
in some situations involving macro expansions:

#define LOGMESSAGE(mesg) do { \
void logger(const char*, int, const char*); \
logger(__FILE__, __LINE__, (mesg)); \
} while(0)

Even so, my preference would be to declare logger() in
the same header file that defines LOGMESSAGE, and dispense
with the foolery. Maybe someone else can come up with a
more convincing use case.

--
Er*********@sun.com

[Andrey Tarasevich]

anoncoholic wrote:

Just found out that this is legal (news to me):

int myfunc( int a )
{
int i = 0;
i = i * a;
int blah( float aa ); // <- huh?
return i;
}

You can declare a function inside another function?? How long has this
been possible? Note, i'm not talking about gcc's extension that supports
nested functions. Just talking about the prototype.

Declare (as opposed to "define")? This has been possible... well,
essentially always. Except that in C89/90 all declarations are supposed
to be grouped at the very beginning of the block. Your code above is
legal in C99, but not in C89/90 for that reason.

--
Best regards,
Andrey Tarasevich

[lawrence.jones]

anoncoholic <[e-mail]:

Just found out that this is legal (news to me):

int myfunc( int a )
{
int i = 0;
i = i * a;
int blah( float aa ); // <- huh?
return i;
}

You can declare a function inside another function?? How long has this
been possible?

"Forever", although the ability to have a declaration after an executable
statement as in the above example was new in C99. It would be clearer
with an explicit "extern", but that's the default for functions, even
inside a block.

-Larry Jones

Hey! What's the matter? Can't you take a joke?! It was a JOKE! -- Calvin

[Ian Collins]

Eric Sosman wrote:

anoncoholic wrote:

>Just found out that this is legal (news to me):

int myfunc( int a )
{
int i = 0;
i = i * a;
int blah( float aa ); // <- huh?
return i;
}

You can declare a function inside another function?? How long has this
been possible? Note, i'm not talking about gcc's extension that
supports nested functions. Just talking about the prototype.

Even so, my preference would be to declare logger() in
the same header file that defines LOGMESSAGE, and dispense
with the foolery. Maybe someone else can come up with a
more convincing use case.

One that springs to mind is proving a local wrapper for logger() by
restricting the scope of the declaration, possibly adding specific
content to the log messages.

--
Ian Collins.

[anoncoholic]

Ian Collins wrote:

Eric Sosman wrote:

>anoncoholic wrote:

>>Just found out that this is legal (news to me):

int myfunc( int a )
{
int i = 0;
i = i * a;
int blah( float aa ); // <- huh?
return i;
}

You can declare a function inside another function?? How long has this
been possible? Note, i'm not talking about gcc's extension that
supports nested functions. Just talking about the prototype.

Even so, my preference would be to declare logger() in
the same header file that defines LOGMESSAGE, and dispense
with the foolery. Maybe someone else can come up with a
more convincing use case.

One that springs to mind is proving a local wrapper for logger() by
restricting the scope of the declaration, possibly adding specific
content to the log messages.

I see. Thanks for all the replies. I never knew that. It became an issue
recently with some c++ code. I was trying to declare an instance of an
object, on the stack, and call its default constructor. But the compiler
kept acting weird because it thought I was declaring a function with no
parameters that returns an object. Yep, I found the solution. Omit the
parenthesis and the default ctor will be called.

[CBFalconer]

anoncoholic wrote:

Ian Collins wrote:

>Eric Sosman wrote:

>>anoncoholic wrote:

Just found out that this is legal (news to me):

int myfunc( int a ) {
int i = 0;
i = i * a;
int blah( float aa ); // <- huh?
return i;
}

You can declare a function inside another function?? How long
has this been possible? Note, i'm not talking about gcc's
extension that supports nested functions. Just talking about
the prototype.

Even so, my preference would be to declare logger() in
the same header file that defines LOGMESSAGE, and dispense
with the foolery. Maybe someone else can come up with a
more convincing use case.

One that springs to mind is proving a local wrapper for logger()
by restricting the scope of the declaration, possibly adding
specific content to the log messages.

I see. Thanks for all the replies. I never knew that. It became
an issue recently with some c++ code. I was trying to declare an
instance of an object, on the stack, and call its default
constructor. But the compiler kept acting weird because it
thought I was declaring a function with no parameters that
returns an object. Yep, I found the solution. Omit the
parenthesis and the default ctor will be called.

You are thoroughly confused. There are no constructors in the C
language. If you carefully examine the name of this group you will
find that it ends in c, with absolutely no ++ following.

You need to either get your compilers and languages straight, or
move to comp.lang.c++.

--
[mail]: Chuck F (cbfalconer at maineline dot net)
[page]: <http://cbfalconer.home.att.net>
Try the download section.
** Posted from http://www.teranews.com **

[Ian Collins]

CBFalconer wrote:

anoncoholic wrote:

>Ian Collins wrote:

>>Eric Sosman wrote:
anoncoholic wrote:

Just found out that this is legal (news to me):
>
int myfunc( int a ) {
int i = 0;
i = i * a;
int blah( float aa ); // <- huh?
return i;
}
>
You can declare a function inside another function?? How long
has this been possible? Note, i'm not talking about gcc's
extension that supports nested functions. Just talking about
the prototype.
Even so, my preference would be to declare logger() in
the same header file that defines LOGMESSAGE, and dispense
with the foolery. Maybe someone else can come up with a
more convincing use case.

One that springs to mind is proving a local wrapper for logger()
by restricting the scope of the declaration, possibly adding
specific content to the log messages.

I see. Thanks for all the replies. I never knew that. It became
an issue recently with some c++ code. I was trying to declare an
instance of an object, on the stack, and call its default
constructor. But the compiler kept acting weird because it
thought I was declaring a function with no parameters that
returns an object. Yep, I found the solution. Omit the
parenthesis and the default ctor will be called.

You are thoroughly confused.

Don't be an arse, I'm sure the OP knows the difference. The question
was perfectly OK for this group.

--
Ian Collins.

[Richard]

Ian Collins <ia******@hotmail.comwrites:

CBFalconer wrote:

>anoncoholic wrote:

>>Ian Collins wrote:
Eric Sosman wrote:
anoncoholic wrote:
>
>Just found out that this is legal (news to me):
>>
>int myfunc( int a ) {
> int i = 0;
> i = i * a;
> int blah( float aa ); // <- huh?
> return i;
>}
>>
>You can declare a function inside another function?? How long
>has this been possible? Note, i'm not talking about gcc's
>extension that supports nested functions. Just talking about
>the prototype.
Even so, my preference would be to declare logger() in
the same header file that defines LOGMESSAGE, and dispense
with the foolery. Maybe someone else can come up with a
more convincing use case.
>
One that springs to mind is proving a local wrapper for logger()
by restricting the scope of the declaration, possibly adding
specific content to the log messages.
I see. Thanks for all the replies. I never knew that. It became
an issue recently with some c++ code. I was trying to declare an
instance of an object, on the stack, and call its default
constructor. But the compiler kept acting weird because it
thought I was declaring a function with no parameters that
returns an object. Yep, I found the solution. Omit the
parenthesis and the default ctor will be called.

You are thoroughly confused.

Don't be an arse, I'm sure the OP knows the difference. The question
was perfectly OK for this group.

You have the patience of Job. But well done for not allowing "Chuck" to
continue his poison and incompetence out without reproach. He is a core
cancer in this group.

[anoncoholic]

Ian Collins wrote:

Eric Sosman wrote:

>anoncoholic wrote:

>>Just found out that this is legal (news to me):

int myfunc( int a )
{
int i = 0;
i = i * a;
int blah( float aa ); // <- huh?
return i;
}

You can declare a function inside another function?? How long has this
been possible? Note, i'm not talking about gcc's extension that
supports nested functions. Just talking about the prototype.

Even so, my preference would be to declare logger() in
the same header file that defines LOGMESSAGE, and dispense
with the foolery. Maybe someone else can come up with a
more convincing use case.

One that springs to mind is proving a local wrapper for logger() by
restricting the scope of the declaration, possibly adding specific
content to the log messages.

I see. Thanks for all the replies. I never knew that. It became an issue
recently with some c++ code. I was trying to declare an instance of an
object, on the stack, and call its default constructor. But the compiler
kept acting weird because it thought I was declaring a function with no
parameters that returns an object. Yep, I found the solution. Omit the
parenthesis and the default ctor will be called.

[CBFalconer]

anoncoholic wrote:

Ian Collins wrote:

.... snip ...

>>
One that springs to mind is proving a local wrapper for logger()
by restricting the scope of the declaration, possibly adding
specific content to the log messages.

I see. Thanks for all the replies. I never knew that. It became
an issue recently with some c++ code. I was trying to declare an
instance of an object, on the stack, and call its default
constructor. But the compiler kept acting weird because it
thought I was declaring a function with no parameters that
returns an object. Yep, I found the solution. Omit the
parenthesis and the default ctor will be called.

You are confused. C has no constructors. This is comp.lang.c. I
suspect you really want comp.lang.c++. C++ is an entirely
different language from C.

--
[mail]: Chuck F (cbfalconer at maineline dot net)
[page]: <http://cbfalconer.home.att.net>
Try the download section.

** Posted from http://www.teranews.com **

[Richard Heathfield]

CBFalconer said:

<snip>

C has no constructors.

Not in the C++ sense. Nevertheless, it's quite normal to use the term
"constructor" to describe an object-building C function. Whilst I don't
habitually use foos in production code, you'll often see the following
pattern in my code:

struct foo_
{
int bar;
double baz;
};

typedef struct foo_ foo;

foo *foo_create(int bar, double baz)
{
foo *new = malloc(sizeof *new);
if(new != NULL)
{
new->bar = bar;
new->baz = baz;
}
return new;
}

I am accustomed to using the term "constructor" refer to functions that do
this kind of job.

--
Richard Heathfield <http://www.cpax.org.uk>
Email: -http://www. +rjh@
Google users: <http://www.cpax.org.uk/prg/writings/googly.php>
"Usenet is a strange place" - dmr 29 July 1999

[anoncoholic]

CBFalconer wrote:

anoncoholic wrote:

>Ian Collins wrote:

... snip ...

>>One that springs to mind is proving a local wrapper for logger()
by restricting the scope of the declaration, possibly adding
specific content to the log messages.

I see. Thanks for all the replies. I never knew that. It became
an issue recently with some c++ code. I was trying to declare an
instance of an object, on the stack, and call its default
constructor. But the compiler kept acting weird because it
thought I was declaring a function with no parameters that
returns an object. Yep, I found the solution. Omit the
parenthesis and the default ctor will be called.

You are confused. C has no constructors. This is comp.lang.c. I
suspect you really want comp.lang.c++. C++ is an entirely
different language from C.

Yes, guys... I understand. Please lower the pitch forks. ;) I think you
missed part of the thread. It was in fact a question about C.