return -1 of main but get exit code is 255? why? pls advise.
 

I learn C++ reading the <C++ primer 4th>, question1.2 let me test if return -1 how the compiler handle this exit code.
and in gcc (GCC) 4.1.1 20070105 (Red Hat 4.1.1-52), I get this show:

[youxi600@Arthas C++ Primer]$ cat q1_2.cpp
int main()
{
return -1;
}
[youxi600@Arthas C++ Primer]$ gcc q1_2.cpp -o q1_2
[youxi600@Arthas C++ Primer]$ ./q1_2
[youxi600@Arthas C++ Primer]$ echo $?
255
[youxi600@Arthas C++ Primer]$
anyone can give me an advise? Many thanks!

Because 255 == 0xff == -1 for an 8-bit signed value :)

Yes, the exit status is effectively an unsigned char. The relevant definition in /usr/include/bits/waitstatus.h is:

But my main function return type is "int" not an 8-bit signed. Confused!

why? I have assume it's return type to "int".

So I will defer to paulsm4 for the C / C++ side as he is very experienced in these matters, but I think maybe you might be mixing apples and oranges.
Irrelevant of what is occurring within your code, the exit status in the shell can ONLY be between 0 and 255. So if you create a one line bash script:
This will give you the same result when looking at the exit code using $?. For that matter if you change it to -2 it will be 254 as it treats it like
a loop once past zero.

I am sure there is official information that others can give, but I just wanted to point out that the shell is the one here doing the translation and not your program
(even though it may be as well)

Contrary to appearances, 'int' is not really a basic type; more accurately 'int' defaults to come combination of 8, 16, 32, 64 (or larger multiples of 2) bit, signed or unsigned.
Check your compiler manual & eg http://www.dummies.com/how-to/conten...bers-in-c.html

Thanks.
I think I can get your means. No matter which type the main returned, the "echo $?" shell command just ONLY get a unsigned 8-bit exit code.
And I find one book may be help explain this viewpoint.

The New Kornshell Command and Programming Language by Morris Bolsky and David Korn says:
Quote:
0 Normal exit.
1-125 Failure.
126 A command was found but cannot be executed.
127 A command could not be found.
128-255 Failure.
256 and above A command has exited because of reciept of a signal.
Version: With the 11/16/88 version of ksh, 129-160 indicated that a command had exited because of a signal....A command that could not be found or could not execute had a return value of 1.

Thanks. I will check it.

Actually, the unsigned 8-bit exit code limitation is part of the kernel, not the shell.

The only access to that "int" from main() is the value that is returned when the parent performs a wait() system call, which returns a 16-bit quantity with two 8-bit fields. One field is the low-order 8 bits of the exit status; the other field is the terminating signal. That's all that is available to any program.

Does that mean that my above post is wrong?

Does the other field with the terminating signal have anything to do with main()'s return value?

I believe it's a bit of both.
Inside C, 'int' could be almost anything (see my post #7) if its setup to do so, but once you pass the value back to the shell, it can only represent/present an 8 bit value. Not sure if that's the shell or the kernel.
If it was the kernel, in theory it should be able to use anything up to the bit size of the kernel eg 32 or 64.
I suspect( and could be wrong) that it's a shell limit.

Answers on a postcard pls ... :)

No, it's just a signal number, and would be zero for a process that exited normally.It appears that the kernel might actually store the whole integer within the task_struct structure. It's just that the wait() system call returns only the low-order 8 bits of the exit code plus an 8-bit signal number all packed into the low order 16 bits of an integer. The macros for testing and extracting those fields are described in the wait(2) manpage and defined in /usr/include/bits/waitstatus.h.

Looking at that manpage, I see a slightly newer system call, waitid(), that looks like it might return the entire integer in the si_status member of the siginfo_t structure. For a C (or C++) program, it might be worth taking a look at that if you really need to see more than those low 8 bits of the exit status. I've never used waitid(2), so I'm not sure what is really returned.