sizeof() O/P

R

raghu

i'm surprised at the output of the following code. compiled in turbo C

void main()
{
printf("%d",sizeof(printf());
}
the output was : 2
how come the output is 2? actually what is the property of sizeof()
and printf()?are there any return types for the two functions? hoping
for the positive responses.. thanks a lot in advance.
 
C

Chris Hills

i'm surprised at the output of the following code. compiled in turbo C

void main()
{
printf("%d",sizeof(printf());
}
the output was : 2
how come the output is 2? actually what is the property of sizeof()
and printf()?are there any return types for the two functions? hoping
for the positive responses.. thanks a lot in advance.

Ignoring that it should have been

#include <stdio.h>
int main(void)
{
printf("%d",sizeof(printf());
return 0;
}

Who set this home work?
 
R

Richard Heathfield

raghu said:
i'm surprised at the output of the following code. compiled in turbo C

void main()

Don't be. Any program which gives the wrong return type for main() exhibits
undefined behaviour, so any behaviour, surprising or not, is permissible as
far as the C language is concerned.
{
printf("%d",sizeof(printf());

Calling printf without a correct prototype in scope invokes undefined
behaviour. Calling printf without any arguments invokes undefined
behaviour.

Start your program like this:

#include <stdio.h>

int main(void)

....and then try your program again, first fixing any diagnostics issued by
your compiler.
 
R

Richard Heathfield

Chris Hills said:
Ignoring that it should have been

#include <stdio.h>
int main(void)
{
printf("%d",sizeof(printf());

No, %d doesn't match size_t.
 
R

Richard Heathfield

Richard Heathfield said:
raghu said:


Calling printf without a correct prototype in scope invokes undefined
behaviour. Calling printf without any arguments invokes undefined
behaviour.

Except, of course, that the code doesn't actually call printf without any
arguments! Sorry about that. But the rest of my reply stands.
 
E

Eric Sosman

raghu said:
i'm surprised at the output of the following code. compiled in turbo C

void main()
{
printf("%d",sizeof(printf());
}
the output was : 2
how come the output is 2? actually what is the property of sizeof()
and printf()?are there any return types for the two functions? hoping
for the positive responses.. thanks a lot in advance.

There should be no cause for surprise, no matter what
output is or is not produced. You should not be surprised
if the code makes demons fly out of your nose, because it
invokes undefined behavior not once, not twice, but thrice:

- The main() function is not `void'

- It is U.B. to call a variadic function like printf()
without a prototype in scope

- It is U.B. to pass a non-`int' to the "%d" specifier
(On some "exotic" systems where `size_t' is narrower
than `int' this might be all right, so I really should
say that whether the behavior is defined or undefined
is implementation-defined.)

.... and on top of all that, the fate of a newline-less "line"
at the end of a stream of output is implementation-defined.

(Three instances of U.B. and one of I.D.B., or possibly
two U.B. and two I.D.B. -- all in just four lines, two of
which consist only of braces. Is this density of errors --
a density of densness, one might say -- a candidate for the
Guinness Book? Sadly, I fear not.)

Here's a cleaned-up version:

#include <stdio.h> /* for printf() prototype */
int main(void) {
printf ("%d\n", /* note newline */
(int)sizeof printf()); /* note type coercion */
return 0; /* required in C90, optional in C99 */
}

Now, you may still be puzzled about the output of the
cleaned-up version of your bletcherous code. Much will become
clearer if you ponder two questions:

- What does the `sizeof' operator do with its argument?

- What type does the printf() function return?

Answer these, Grasshopper, and you will be on the path
to enlightenment -- but if you keep on writing code like the
sample you provided here, it means you're on the right path
but walking in the wrong direction.
 
E

Emmanuel Delahaye

raghu a écrit :
i'm surprised at the output of the following code. compiled in turbo C

void main()
{
printf("%d",sizeof(printf());
}

This code invokes an undefined behaviour

- The type returned by main() is int.
- An explicit valid value must be returned.
"%d" expects an int and the sizeof operator returns a size_t.
the output was : 2

Supposing the code was fixed, this 2 is the size of the type returned by
printf (actually int) on your machine.
how come the output is 2? actually what is the property of sizeof()

Like your C-book said, the sizeof operator return the size of an object
or of a type (with parens) in number of bytes. The type of the returned
value is size_t.
and printf()?

printf() is a function returning int. Details belong to your C-book.
are there any return types for the two functions?

sizeof is not a function but a C-unary-operator
 
C

Chris Hills

Richard said:
raghu said:


Don't be. Any program which gives the wrong return type for main() exhibits
undefined behaviour, so any behaviour, surprising or not, is permissible as
far as the C language is concerned.

void main (void) *may* be permissible with turbo C as I think it could
turn out code that would run with out an OS. Somewhere I have a ROM
kit for Turbo-C.

In general (ie unless explicitly specified as self hosted) it MUST be
int main ([args])
 
G

Giannis Papadopoulos

Eric said:
...
> ...
Here's a cleaned-up version:

#include <stdio.h> /* for printf() prototype */
int main(void) {
printf ("%d\n", /* note newline */
(int)sizeof printf()); /* note type coercion */
return 0; /* required in C90, optional in C99 */
}

Well, this does not compile on gcc given -ansi -pedantic.
Perhaps printf("") instead of printf() would be better?
 
M

Martin Ambuhl

raghu said:
i'm surprised at the output of the following code. compiled in turbo C

void main()
{
printf("%d",sizeof(printf());
}
the output was : 2
how come the output is 2?

Since you define main to have an invalid return type (main returns an
int) and leave out the declaration of printf (corrected by including
<stdio.h>), and fail to terminate the last line of output with an
end-of-line character, any action this program performs is completely
random.
 
E

Eric Sosman

Giannis said:
Well, this does not compile on gcc given -ansi -pedantic.
Perhaps printf("") instead of printf() would be better?

Interesting. The constraint of 6.5.2.2/2 requires that
the number and type of the provided function arguments agree
with those of the function prototype, so it seems a diagnostic
is required. On the other hand, the erroneous call produces
no executable code and cannot possibly cause harm (and the
compiler knows this). The question comes down to whether
6.5.2.2/2 applies to function calls that appear in the code
(even if only in a formal sense) or should be taken as applying
to function calls that are executed at run-time.

Full employment for language lawyers, I guess. In any
case, good catch. By my count, the O.P.'s code contains five
known (now) errors in just four lines, only two non-trivial.
Maybe the Guinness people should be alerted after all.

--
 
P

pemo

raghu said:
i'm surprised at the output of the following code. compiled in turbo C

void main()
{
printf("%d",sizeof(printf());
}
the output was : 2
how come the output is 2? actually what is the property of sizeof()
and printf()?are there any return types for the two functions? hoping
for the positive responses.. thanks a lot in advance.

This reminds me of an 'incident' [a very long time ago now!] when a fellow
lecturer of mine [who's now a *very* highly respected prof. of electrical
engineering] said to me ... "you know what, there's a major bug in the
compiler! A student of mine had the following [see below] and the damn
compiler said it was ok!!!!

Boy, it took me ages to find out what was *wrong*.

I should report it as a major bug!!!"

===

Here's the line of code

void someFunc(void)
{
}

int main(void)
{
...
...
/* error - damn s**t compiler [his implicit annotation] */
someFunc;
...
...
return you_know_what;
}
 
J

Jordan Abel

raghu said:
i'm surprised at the output of the following code. compiled in turbo C

void main()
{
printf("%d",sizeof(printf());
}
the output was : 2
how come the output is 2? actually what is the property of sizeof()
and printf()?are there any return types for the two functions? hoping
for the positive responses.. thanks a lot in advance.

This reminds me of an 'incident' [a very long time ago now!] when a fellow
lecturer of mine [who's now a *very* highly respected prof. of electrical
engineering] said to me ... "you know what, there's a major bug in the
compiler! A student of mine had the following [see below] and the damn
compiler said it was ok!!!!

Boy, it took me ages to find out what was *wrong*.

I should report it as a major bug!!!"

===

Here's the line of code

void someFunc(void)
{
}

int main(void)
{
...
...
/* error - damn s**t compiler [his implicit annotation] */
someFunc;
...
...
return you_know_what;
}

What's wrong with that? It evaluates the address of the function and
then throws it away. [of course, if the compiler makes it _call_ the
function, that's a problem]
 
K

Keith Thompson

Eric Sosman said:
Interesting. The constraint of 6.5.2.2/2 requires that
the number and type of the provided function arguments agree
with those of the function prototype, so it seems a diagnostic
is required. On the other hand, the erroneous call produces
no executable code and cannot possibly cause harm (and the
compiler knows this). The question comes down to whether
6.5.2.2/2 applies to function calls that appear in the code
(even if only in a formal sense) or should be taken as applying
to function calls that are executed at run-time.

It's a constraint, requiring a compile-time diagnostic. Of course it
applies at compilation time.

All three printf calls in the following violate the same constraint:

#include <stdio.h>
#include <time.h>
int main(void)
{
sizeof printf();
if (0) {
printf();
}
if (time(NULL) < 1135455446) {
printf();
}
}

In all three cases, the compiler can potentially determine that the
call is never executed (for the last, it would have to take advantage
of its knowledge about the representation of time_t and assume that
the system clock is correct). This doesn't relieve the compiler of
its obligation to generate a diagnostic, any more than it could omit a
diagnostic for a conditional syntax error:

if (0) {
printf("hello, world\n) /* missing semicolon */
}
 
K

Keith Thompson

Emmanuel Delahaye said:
raghu a écrit :

This code invokes an undefined behaviour

- The type returned by main() is int.
- An explicit valid value must be returned.
"%d" expects an int and the sizeof operator returns a size_t.

But printf is never actually called, and without a visible prototype
the compiler (at least for C90) assumes that printf() is a function
taking unknown arguments and returning int.

In fact, the following returns sizeof(int) to the calling environment:

int main(void)
{
return sizeof unknown_function();
}

On the system where I just tried it, since unknown_function() isn't
actually called, the implementation doesn't attempt to link it into
the executable. I'm not sure whether this is allowed (and it's too
bizarre for me to care very much).
 
S

Skarmander

pemo said:
i'm surprised at the output of the following code. compiled in turbo C

void main()
{
printf("%d",sizeof(printf());
}
the output was : 2
how come the output is 2? actually what is the property of sizeof()
and printf()?are there any return types for the two functions? hoping
for the positive responses.. thanks a lot in advance.


This reminds me of an 'incident' [a very long time ago now!] when a fellow
lecturer of mine [who's now a *very* highly respected prof. of electrical
engineering] said to me ... "you know what, there's a major bug in the
compiler! A student of mine had the following [see below] and the damn
compiler said it was ok!!!!

Boy, it took me ages to find out what was *wrong*.

I should report it as a major bug!!!"

===

Here's the line of code

void someFunc(void)
{
}

int main(void)
{
...
...
/* error - damn s**t compiler [his implicit annotation] */
someFunc;

Almost all compilers I've seen have an option for issuing a warning when a
statement has no effect, typically enabled with a host of other useful
warnings you wouldn't want to do without. Aside from a better grasp of the
language, a better understanding of the compiler wouldn't hurt either.

S.
 
M

Mark McIntyre

On the system where I just tried it, since unknown_function() isn't
actually called, the implementation doesn't attempt to link it into
the executable. I'm not sure whether this is allowed

I suspect the 'as if' rule would apply. Since the code behaves as if
the function didn't do anything other than return an unspecified int,
the compiler is allowed to completely optimise it out and replace it
by an unspecified int. OTOH I'd expect some sort of complaint.
 
P

pemo

Jordan Abel said:
raghu said:
i'm surprised at the output of the following code. compiled in turbo C

void main()
{
printf("%d",sizeof(printf());
}
the output was : 2
how come the output is 2? actually what is the property of sizeof()
and printf()?are there any return types for the two functions? hoping
for the positive responses.. thanks a lot in advance.

This reminds me of an 'incident' [a very long time ago now!] when a
fellow
lecturer of mine [who's now a *very* highly respected prof. of electrical
engineering] said to me ... "you know what, there's a major bug in the
compiler! A student of mine had the following [see below] and the damn
compiler said it was ok!!!!

Boy, it took me ages to find out what was *wrong*.

I should report it as a major bug!!!"

===

Here's the line of code

void someFunc(void)
{
}

int main(void)
{
...
...
/* error - damn s**t compiler [his implicit annotation] */
someFunc;
...
...
return you_know_what;
}

What's wrong with that? It evaluates the address of the function and
then throws it away. [of course, if the compiler makes it _call_ the
function, that's a problem]

Um, yes, I know!
 
J

Jan Engelhardt

i'm surprised at the output of the following code. compiled in turbo C
void main()
{
printf("%d",sizeof(printf());
}
the output was : 2

how come the output is 2? actually what is the property of sizeof()

Try again on a modern compiler and you should get 4.



Jan Engelhardt
--
 

Ask a Question

Want to reply to this thread or ask your own question?

You'll need to choose a username for the site, which only take a couple of moments. After that, you can post your question and our members will help you out.

Ask a Question

Members online

No members online now.

Forum statistics

Threads
473,769
Messages
2,569,579
Members
45,053
Latest member
BrodieSola

Latest Threads

Top