What's wrong with the following assignment?

[arunikgp]

int main()
{
	int *x;
	
	x= malloc(sizeof(char));
	
	*x=500000000;
	printf("\n%d, %d, %d, size-char=%d, size-int=%d\n",*x, x, x+1, sizeof(char), sizeof(int));

}

malloc should allocate only 1 byte of memory and hence we shouldnt be able to store an integer in it..but my program works..how?

[laserlight]

malloc should allocate only 1 byte of memory and hence we shouldnt be able to store an integer in it..but my program works..how?

Undefined behaviour. You are probably overwriting adjacent memory, and may have to pay for your crimes when it is least convenient.

[gardhr]

malloc should allocate only 1 byte of memory and hence we shouldnt be able to store an integer in it..but my program works..how?

C doesn't have any built-in bounds-checking facilities. For better or for worse, it just assumes you know what you're doing, even when it's blatantly obvious that you don't.

[CommonTater]

int main()
{
	int *x;
	
	x= malloc(sizeof(char));
	
	*x=500000000;
	printf("\n%d, %d, %d, size-char=%d, size-int=%d\n",*x, x, x+1, sizeof(char), sizeof(int));

}

malloc should allocate only 1 byte of memory and hence we shouldnt be able to store an integer in it..but my program works..how?

Pure dumb luck... As laserlight points out you are playing with undefined behaviour. The only reason it appears to work is that an int is 4 bytes, your number will fit in 4 bytes, memory alligns to int boundaries and there are no other variables defined. If you did something like this...

int main (void)
  {
    char a;
    unsigned int b = 0xFFFFFFFF; 

    char a = "This is a test";

    printf ("%X",b);
    return 0; 
}

It is very likely you would see that the value of b was changed by what you put at the address allocated to a.

As gardhr points out C has no facilities for bounds checking --and in fact has almost no run time checking of any kind-- that is up to you as a programmer...
But, the good news is that you now know this and can govern yourself accordingly.

[gardhr]

It is very likely you would see that the value of b was changed by what you put at the address allocated to a.

In that case, the address of the literal would simply be truncated before being copied into a single byte value. No overflow possible there, so no harm done...

[AndrewHunter]

int main()
{
	int *x;
	
	x= malloc(sizeof(char));
	
	*x=500000000;
	printf("\n%d, %d, %d, size-char=%d, size-int=%d\n",*x, x, x+1, sizeof(char), sizeof(int));

}

malloc should allocate only 1 byte of memory and hence we shouldnt be able to store an integer in it..but my program works..how?

Pure dumb luck... As laserlight points out you are playing with undefined behaviour. The only reason it appears to work is that an int is 4 bytes, your number will fit in 4 bytes, memory alligns to int boundaries and there are no other variables defined. If you did something like this...

int main (void)
  {
    char a;
    unsigned int b = 0xFFFFFFFF; 

    char a = "This is a test";

    printf ("%X",b);
    return 0; 
}

An additional note is to take a look at how Tater defined main and the return value he gave. This is how to properly write a C program.

[_Mike]

An additional note is to take a look at how Tater defined main and the return value he gave. This is how to properly write a C program.

Aren't these two exactly the same for function definitions?

int main()
int main(void)

I was taught that the empty parameter list = unknown/any arguments only applies to declarations.

[AndrewHunter]

This is a big argument for C; per the standard both are currently acceptable however only for main(). For any other function an empty parameter list means that the function could take an unknown number of arguments (for the declarations as you pointed out). You could consider the main definition for parameters as a personal preference.

[laserlight]

Aren't these two exactly the same for function definitions?

Other than spelling, yes. The bad part is that the former is regarded in the grammar as part of the old identifier list syntax, so it is technically obsolescent although due to adoption by C++ I doubt it will ever be removed from C.

This is a big argument for C; per the standard both are currently acceptable however only for main(). For any other function an empty parameter list means that the function could take an unknown number of arguments (for the declarations as you pointed out).

There is no special case for main here.

[_Mike]

@Andrew: Thank you. I wasn't sure if I remembered it correctly and your post made me a bit more unsure.

And speaking of the standard.. I was trying to find where this behavior was mentioned and I found some sections which seem to be conflicting. (But I'm pretty sure they actually aren't, and I'm just misunderstanding them)

An identifier list declares only the identifiers of the parameters of the function. An empty list in a function declarator that is part of a definition of that function specifies that the function has no parameters. The empty list in a function declarator that is not part of a definition of that function specifies that no information about the number or types of the parameters is supplied.

But then we have

An identifier list in a function declarator that is not part of a definition of that function shall be empty.

So now a function declaration has to have an empty identifier list? Doesn't that imply that all functions where the declaration isn't part of the definition should be able to accept a variable number of arguments?

@Laserlight:
You posted while I was writing this so I didn't see it until now. Since you mentioned "the old identifier list syntax" (emphasis mine) I guess that identifier lists are not the argument lists I think they are?

[AndrewHunter]

Other than spelling, yes. The bad part is that the former is regarded in the grammar as part of the old identifier list syntax, so it is technically obsolescent although due to adoption by C++ I doubt it will ever be removed from C.

I don't think this is necessarily a "bad part". <Enter style argument..>

There is no special case for main here.

So where do you declare main before you define it? We had this argument before and you, yourself have decided that just sticking with the "old way" was the best. I like you Laser but let's be consistent

[laserlight]

So now a function declaration has to have an empty identifier list?

Hmm... looks like it. This compiles perfectly fine for me:

#include <stdio.h>

void foo();

int main(void)
{
    foo(1, 2.5);
    return 0;
}

void foo(x, y)
int x; double y;
{
    printf("%d %f\n", x, y);
}

But when I change the declaration to:

void foo(x, y);

gcc 4.4.4 warns me that it detected "parameter names (without types) in function declaration". Of course, if you provide the types it then becomes a parameter list instead of an identifier list.

I don't think this is necessarily a "bad part".

It is, because it means that for practical reasons the identifier list form cannot be removed from C without making yet another exception to the rule.

So where do you declare main before you define it?

As far as I can tell, a declaration of main that is not a definition is allowed, so if you wanted to do that you could. That said, my statement was with reference to your claim that "both are currently acceptable however only for main()". In other words, you claim that for functions other than main, only one form is acceptable.

We had this argument before and you, yourself have decided that just sticking with the "old way" was the best. I like you Laser but let's be consistent

I have not made any suggestion of which form to choose. I like you, AndrewHunter, but let's be honest.

[_Mike]

gcc 4.4.4 warns me that it detected "parameter names (without types) in function declaration". Of course, if you provide the types it then becomes a parameter list instead of an identifier list.

I see, so that was the main source of my confusion. I thought identifier lists and parameter lists were the same thing.
I had actually never seen the identifier list version of declarations before now