6

well why would,

#include <iostream> using namespace std; int afunction () {return 0;}; int anotherfunction () {return 0;}; int main () { cout << &afunction << endl; }

give this,

1

  1. why is every functions address true?
  2. and how then can a function pointer work if all functions share (so it seems) the same addresss?
Improve this question
2
  • 2
    I suspect the stream operator to interpet it wrong. Try (void*)&afunction, perhaps with a hex manipulator before it. Commented May 16, 2011 at 20:23
  • (void*)&afunction Works! you dont need the manipulator. Commented May 16, 2011 at 20:58

7 Answers 7

Reset to default
15

The function address isn't "true". There is no overload for an ostream that accepts an arbitrary function pointer. But there is one for a boolean, and function pointers are implicitly convertable to bool. So the compiler converts afunction from whatever its value actually is to true or false. Since you can't have a function at address 0, the value printed is always true, which cout displays as 1.

This illustrates why implicit conversions are usually frowned upon. If the conversion to bool were explicit, you would have had a compile error instead of silently doing the wrong thing.

Improve this answer
Sign up to request clarification or add additional context in comments.

4 Comments

+1, same as I said but quicker. "There is no overload for an ostream that accepts a function pointer". At least, there isn't one that accepts every function pointer. There are three (templates) that accept particular kinds of function pointer, for stream manipulators, but they don't print the address anyway.
I thought the type of all pointers was numeric. I would ask why they aren't but I get that's a whole other SO question. thanks @Steve jessop and @Dennis Zickefoose.
@code shogan: function pointers and object pointers aren't the same thing (because functions aren't objects). There's an operator<< for void*, but not for int(*)(void).
@Steve my first mistake was assuming everything is an object since C++ was OO. kind of like the language *eating it's own dogfood" e.g. In Python everything is an object.
3

The function pointer type is not supported by std::ostream out of the box. Your pointers are converted to only possible compatible type - bool - and verything that is not zero is true thanks to backward compatibility to C.

Improve this answer

Comments

2

There's no overload of operator<< for function pointers (except stream manipulators), but there is one for bool, so the function pointer is converted to that type before display.

The addresses aren't equal, but they're both non-null, and hence they both covert to true.

Improve this answer

Comments

1

There is no overloaded function: operator<<(ostream&, int(*)()), so your function pointer is converted into the only type that works, bool. Then operator<<(ostream&, bool) is printing the converted value: 1.

You may be able to print the function address like so:

cout << (void*)&afunction << endl;
Improve this answer

6 Comments

yeah Christian Rau pointed that out. Maybe it's my background in Python, but I assumed pointers share a type (aka. inheritance)... but now I'm thinking in C++ things like pointers are the type.
@code - Pointers to objects sort of share an inheritance. Any pointer to an object can be converted to void*. Pointers to functions are not convertible to void*.
@Rob aha now i get how the above example works: we aren't converting pointers but actually just creating a void pointer instead. It all finally makes sense. +1
@code note that (void&)&func is a gcc extension. The C++ standard makes no guarantee that this will work.
Err, I meant "(void*)&func is a gcc extension"
|
0

All addresses in C++ are non-zero, because zero is the NULL pointer and is a reserved value. Any non-zero value is considered true.

Improve this answer

3 Comments

Doesn't touch on why the value is always 1 (rather than 0x400110 or something).
@cHao, I didn't think I needed to explain that; judging by the question title, I assumed the asker knew that True was equal to 1.
Going just by the title, you're right. Part 2 of the actual question, though, indicates that the expected almost certainly isn't true or 1, but the function's address. The confusion isn't about the value of a boolean, so much as it's about function pointers mysteriously becoming bools in the first place.
0

There cannot be an overload for function pointers for the iostream << operator, as there are an infinite number of possible function pointer types. So the function pointer gets a conversion applied, in this case to bool. Try:

cout << (void *) afunction << endl;

Which will give you the address in hex - for me the result was:

0x401344
Improve this answer

Comments

-1

Did you check anotherfunction() as well?

Anyway, C++ pointer addresses, like C pointer addresses, are usually virtual on most platforms and don't correspond directly to memory locations. Hence the value may be very small or unusual.

Also, they will always be true, as 0 is NULL, an invalid pointer, and anything that is over 0 is true

Improve this answer

1 Comment

Doesn't touch on why the value is always 1 (rather than 0x400110 or something).

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.