----- Original Message ----- 
From: "b_bharat_shetty" 
To: 
Sent: Monday, April 05, 2004 9:58 AM
Subject: [C-Guru] C !

> Hi friends, 
> I came across these questions and seem baffled by these
> Can anyone tell me answers to this?
> 
> This code may have bugs!. If any suggest remedy 
> to this else give output!
> 
> #1.c
> #include

You should include  for malloc.

> main()
> {
> void *pointer;
> void *vector;
> void *address;
> void *location;
> 

The prototype of malloc is:

    void *malloc ( size_t );

where, 
    size_t is an unsigned integer typedefe in .

> pointer=malloc(-1);

Read: http://www.geocities.com/vijoeyz/faq/c/unsigned2.txt
to know about how a negative integer is assigned to an unsigned
int.

> vector=malloc(0);

Each compiler is free to define the behaviour of malloc () when
the size is 0.  Usually, the compiler documents how it does.
Two possibilies are:

    When the requested size is zero
        * return a NULL pointer.
        * Assume some non-zero size 

In either case, using the return value malloc() can cause undefined
behaviour.

> address=malloc(1);

This is OK.

> location=NULL;
> 
> free(pointer);
> free(vector);
> free(address);

If the corresponding mallocs were successful, then this is OK.

> free(location);

This is also legal, but no action occurs for free ( NULL ).

> }
> -----------------------------
> #2.c
> #include
> main(int argc)
> {

There are two valid definitions of main ().  In either case,
it returns an int.

    int main ( void ) { /* .. */ }
or 
    int main ( int argc, char *argv[] ) { /* .. */ }

> staticint _main=10;

At least, one white character must separate keywords.

> _main--;
> if(main)
> main(10,NULL,NULL);

What are you trying to do here?  Mismatch between definition
and calling of main().  Why do you decrement _main when you
are not using it to control the depth of recursion?

More ever, using the third argument for main is a compiler
extension, and is unportable.

-- 
Vijay Kumar R Zanvar
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

"Vijay Kumar R Zanvar"  wrote:

> 
> > vector=malloc(0);
> 
> Each compiler is free to define the behaviour of malloc () when
> the size is 0.  Usually, the compiler documents how it does.
> Two possibilies are:
> 
>     When the requested size is zero
>         * return a NULL pointer.

This is correct.

>         * Assume some non-zero size

This is not; or rather, it is misleading. malloc(0) is allowed to return
(in C89) just any unique pointer; in C99, it is allowed to behave as if
it were some non-zero size _except that the pointer must not be
dereferenced_. That restriction is not present when you _just_ assume
some non-zero size.

> In either case, using the return value malloc() can cause undefined
> behaviour.

Well, no. Not quite. Using it _as if it pointed to some usable object_
causes undefined behaviour.
In C89, if you get a non-null result, I'm not sure whether, e.g.,
comparing it for equality with any other same-type or null pointer
invokes UB; I can't determine whether it is supposed to be a _valid_
unique pointer, and if it isn't, even the comparison is UB. If it is,
the comparison must work.
In C99, if you get a non-null result, that result must be a valid
pointer, and can be treated as any pointer _except_ that it cannot be
dereferenced. For example, you can compare it for equality, you can pass
it to a function (which may then not deref it, but...), you can assign
it to a pointer variable. This is also true if you get a null pointer,
under either Standard.

> > address=malloc(1);
> 
> This is OK.

Albeit useless, of course, but I presume that was not the point of the
code.

> > location=NULL;
> >
> > free(pointer);
> > free(vector);
> > free(address);
> 
> If the corresponding mallocs were successful, then this is OK.

Even if not, this is OK. An unsuccessful malloc() returns a null
pointer, and free(0) is legal (and a no-op) under both Standards.

Richard
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
On Mon, 5 Apr 2004 17:48:57 +0530, "Vijay Kumar R Zanvar"
 wrote in comp.lang.c:

One more point I have not seen:

> 
> [BEGINS]
> 
> > Hi friends,
> > I cam across these questions and seem baffled by these
> > Can anyone tell me answers to this?
> >
> > This code may have bugs!. If any suggest remedy
> > to this else give output!
> >
> > #1.c
> > #include
> 
> You should include  for malloc.
> 
> > main()
> > {
> > void *pointer;
> > void *vector;
> > void *address;
> > void *location;
> >
> 
> The prototype of malloc is:
> 
>     void *malloc ( size_t );
> 
> where,
>     size_t is an unsigned integer typedefe in .
> 
> > pointer=malloc(-1);
> 
> Read: http://www.geocities.com/vijoeyz/faq/c/unsigned2.txt
> to know about how a negative integer is assigned to an unsigned
> int.
> 
> > vector=malloc(0);
> 
> Each compiler is free to define the behaviour of malloc () when
> the size is 0.  Usually, the compiler documents how it does.

Both versions of the C standard state that the result of calling
malloc() with a parameter of 0 is implementation-defined, which is a
term with a very specific definition in the standard.

A compiler is "free" to select among the behaviors specifically
allowed by the standard, not any behavior.  And it must document its
choice.

> Two possibilies are:

In fact, the only two possibilities...

>     When the requested size is zero
>         * return a NULL pointer.
>         * Assume some non-zero size

Richard seems to think there is something vague about the "unique
pointer" phrase used by c89/90.  I think the meaning is rather simple.
It merely means that a non-NULL pointer returned by malloc(0) must be
different every time you make that call in a program.  It must also be
different from every pointer returned by a successful non-zero
allocation call, and the address of every non-dynamic object existing
in a program.

In other words, it must not compare equal to any other valid pointer
value in a program.

-- 
Jack Klein
Home: http://JK-Technology.Com
FAQs for
comp.lang.c http://www.eskimo.com/~scs/C-faq/top.html
comp.lang.c++ http://www.parashift.com/c++-faq-lite/
alt.comp.lang.learn.c-c++
http://www.contrib.andrew.cmu.edu/~ajo/docs/FAQ-acllc.html

    Source: geocities.com/vijoeyz/faq/c

               ( geocities.com/vijoeyz/faq)                   ( geocities.com/vijoeyz)