[newbie] de-reference function

[Tony Winslow]

Hi,

I'm wondering why the following code works just fine:

#include <stdio.h>

int main()
{
(******printf)("Hello!\n");

return 0;
}

best regards,
Tony Winslow

[red floyd]

Tony Winslow wrote:

Hi,

I'm wondering why the following code works just fine:

#include <stdio.h>

int main()
{
(******printf)("Hello!\n");

return 0;
}

I'm not sure. Gcc took it with -ansi -Wall -pedantic
Comeau took it in strict mode.

That looks really wierd to me.

[Christian Hackl]

red floyd wrote:

Tony Winslow wrote:

>Hi,

I'm wondering why the following code works just fine:

#include <stdio.h>

int main()
{
(******printf)("Hello!\n");

return 0;
}

I'm not sure. Gcc took it with -ansi -Wall -pedantic
Comeau took it in strict mode.

That looks really wierd to me.

I could be mistaken, but doesn't dereferencing a function pointer yield
the very same function pointer, which explains why the code works?

Here's another example:
void f() {}

int main()
{
void (*ptr)();

ptr = f;
ptr = *f;
ptr = **f;
}
--
Christian Hackl

[Victor Bazarov]

red floyd wrote:

Tony Winslow wrote:

>Hi,

I'm wondering why the following code works just fine:

#include <stdio.h>

int main()
{
(******printf)("Hello!\n");

return 0;
}

I'm not sure. Gcc took it with -ansi -Wall -pedantic
Comeau took it in strict mode.

That looks really wierd to me.

What's so weird? Since the * associate from right to left, you get

*(*(*(*(*(*(printf))))))

The 'printf' expression yields a pointer to function, right?
Dereference it, and you will get... a an lvalue of the function type,
right? So, the first expression

*(printf)

Gives you an lvalue of function type int(char const*,...). There is no
doubt about that, is there? Now, the compiler sees the next dereference
operator. What will it try to do? The dereference operator needs a
pointer as its argument, right? Now, can an lvalue of function type be
converted to some pointer?

According to 4.3, if an lvalue of function type T can be converted to an
rvalue of type pointer-to-T, the result is a pointer to function. So,
the expression

(*printf)

is converted to a pointer to function. The next dereference yields
another lvalue, and so on.

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[Victor Bazarov]

Christian Hackl wrote:

red floyd wrote:

>Tony Winslow wrote:

>>Hi,

I'm wondering why the following code works just fine:

#include <stdio.h>

int main()
{
(******printf)("Hello!\n");

return 0;
}

I'm not sure. Gcc took it with -ansi -Wall -pedantic
Comeau took it in strict mode.

That looks really wierd to me.

I could be mistaken, but doesn't dereferencing a function pointer yield
the very same function pointer, which explains why the code works?

Here's another example:
void f() {}

int main()
{
void (*ptr)();

ptr = f;
ptr = *f;
ptr = **f;
}

Actually, it would be funnier if you did

ptr = f;

ptr = *ptr; // dereference and assign again
ptr = *ptr; // and again
ptr = ******************************ptr; // and more...

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[red floyd]

Victor Bazarov wrote:

red floyd wrote:

>Tony Winslow wrote:

>>Hi,

I'm wondering why the following code works just fine:

#include <stdio.h>

int main()
{
(******printf)("Hello!\n");

return 0;
}

I'm not sure. Gcc took it with -ansi -Wall -pedantic
Comeau took it in strict mode.

That looks really wierd to me.

What's so weird? Since the * associate from right to left, you get

*(*(*(*(*(*(printf))))))

The 'printf' expression yields a pointer to function, right? Dereference
it, and you will get... a an lvalue of the function type, right? So,
the first expression

*(printf)

Gives you an lvalue of function type int(char const*,...). There is no
doubt about that, is there? Now, the compiler sees the next dereference
operator. What will it try to do? The dereference operator needs a
pointer as its argument, right? Now, can an lvalue of function type be
converted to some pointer?

According to 4.3, if an lvalue of function type T can be converted to an
rvalue of type pointer-to-T, the result is a pointer to function. So,
the expression

(*printf)

is converted to a pointer to function. The next dereference yields
another lvalue, and so on.

I figured it was something like that, but it's still pretty weird looking.

[tony_in_da_uk]

On Sep 7, 11:15*pm, Tony Winslow <[e-mail]:

Hi,

I'm wondering why the following code works just fine:

#include <stdio.h>

int main()
{
* * * * (******printf)("Hello!\n");

* * * * return 0;

}

best regards,
Tony Winslow

That's so cool... I'm going to use it to rate how important my
function calls are now... 5 stars is really mega-important... 1 is
kind-of "who cares"...

Cheers,

Tony

[Tony Winslow]

Victor Bazarov wrote:

red floyd wrote:

>Tony Winslow wrote:

>>Hi,

I'm wondering why the following code works just fine:

#include <stdio.h>

int main()
{
(******printf)("Hello!\n");

return 0;
}

I'm not sure. Gcc took it with -ansi -Wall -pedantic
Comeau took it in strict mode.

That looks really wierd to me.

What's so weird? Since the * associate from right to left, you get

*(*(*(*(*(*(printf))))))

The 'printf' expression yields a pointer to function, right? Dereference
it, and you will get... a an lvalue of the function type, right? So,
the first expression

*(printf)

Gives you an lvalue of function type int(char const*,...). There is no
doubt about that, is there? Now, the compiler sees the next dereference
operator. What will it try to do? The dereference operator needs a
pointer as its argument, right? Now, can an lvalue of function type be
converted to some pointer?

According to 4.3, if an lvalue of function type T can be converted to an
rvalue of type pointer-to-T, the result is a pointer to function. So,
the expression

(*printf)

is converted to a pointer to function. The next dereference yields
another lvalue, and so on.

V

Wow, I understand it now.
Thanks for your analysis!

Best regards,
Tony Winslow

[Andrey Tarasevich]

to***********@yahoo.co.uk wrote:

>I'm wondering why the following code works just fine:

#include <stdio.h>

int main()
{
(******printf)("Hello!\n");

return 0;

}

best regards,
Tony Winslow

That's so cool... I'm going to use it to rate how important my
function calls are now... 5 stars is really mega-important... 1 is
kind-of "who cares"...
...

Except that if won't work with overloaded functions. Those will have to
remain "unrated"...