Why difference in Solaris and Linux

Question

Hi,
The following program is giving results diferently when I am executing using g++ compiler in Solaris and Linux.
Why it is so.
here is the code:
#include <stdio.h>
#include <string.h>
#include <malloc.h>
#include <stdlib.h>
int main( void )
size_t size;
char *buf;
if ( ( buf = (char *)malloc(10 *sizeof(char))) == NULL)
exit (1);
size = sizeof( buf );
strcpy(buf, "HelloWorld");
printf("\n Address is : %u String is : %s size : %d ", buf, buf,size);
if (( buf = (char *) realloc(buf, sizeof(20))) == NULL)
exit ( 1);
*(buf+10) = 'A'; *(buf+11) = 'B'; *(buf+12) = '\0';
printf("\n Address is : %u String is : %s\n", buf, buf);
free( buf);
exit( 0 );
Solaris:
Address is : 134160 String is : HelloWorld size : 4
Address is : 135704 String is : HelloWor
Linux:
Address is : 134518824 String is : HelloWorld size : 4
Address is : 134518824 String is : HelloWorldAB
Thanks
Venkat

Answer 1

Hi,
The following program is giving results diferently
when I am executing using g++ compiler in Solaris
and Linux.
Why it is so.
here is the code:
#include <stdio.h>
#include <string.h>
#include <malloc.h>
#include <stdlib.h>
int main( void )
size_t size;
char *buf;
if ( ( buf = (char *)malloc(10 *sizeof(char))) == NULL)
exit (1);
size = sizeof( buf );The size you get here is the size of buf, which is the size of a pointer, not the size of what buf points to. sizeof(*buf) would give you size of a char, the type (not the object) that buf points to.
There is no portable way to find out the number of bytes allocated on the heap if you are give only a pointer to the memory. You have to remember the size some other way..
strcpy(buf, "HelloWorld");A literal string consists of the characters in the string plus a terminating null, all of which are copied by strcpy. You allocated 10 chars for buf, but are writing 11 chars into it. At this point, the program has undefined behavior. Literally anything at all could happen, because you can't predict the effect of writing outside the bounds of allocated memory.
printf("\n Address is : %u String is : %s size :
e : %d ", buf, buf,size);
if (( buf = (char *) realloc(buf, sizeof(20))) == NULL)The "sizeof" operator in this case is returning the size of the type of a literal 20, which is an int. If you want to allocate 20 bytes, you write 20, not sizeof(20).
exit ( 1);
*(buf+10) = 'A'; *(buf+11) = 'B'; *(buf+12) == '\0';SInce you can't count on buf having more than 4 bytes at this time, you are writing into unallocated memory, with undefined results.
printf("\n Address is : %u String is : %s\n", buf, buf);
free( buf);
exit( 0 );
Instead of asking why you get different results on different platforms, you should be asking why the program doesn't crash on all platforms. :-)
You can avoid these problems with keeping track of allocating memory by using the C++ standard library instead of trying to manage low-level details yourself as in C code.
The standard string class, for example, extends itself as needed, and ensures that heap memory is freed when the string object is deleted or goes out of scope. You don't need pointers, malloc, free, or sizeof to use C++ strings.