Differnce between C and Java returning an Object reference/pointer

In C we know that the memory allocated locally inside a function will vanish when the function returns

Code:

---

char *getName()
{
char name[]="Sumit";
return name
}

---

The caller of the function will get a pointer to the array.Although the pointer points a garbage unknown location since the array was local, it has now been destroyed.



Now I have a doubt the same thing works in Java

Code:

---

public String getName()
{
String name="Sumit"; //name here is local as above;memory allocated for the object locally
return name;
}

---

The caller of the method will correctly get the String returned.

What is the difference in the mechanism of returning pointer in C and reference in Java?

Hope I m made my point clear.
Eagerly waiting for reply.

Regards

The difference here isn't in the way the pointer is returned really. The difference is what you are actually returning. Or rather, what type of object you are trying to return. In the first example, you are returning a local variable. If you were actually allocating some memory dynamically, copying your characters into that block of memory, and then returning that - then you would be like what your Java example does; assuming the Java example is actually correct.

Code:

---

char *getName( void )
{
    char buf[ BUFSIZ ] = { "some name" };
    char *s = NULL;
    s = malloc( strlen( buf ) + 1 );
    strcpy( s, buf );
    return s;
}

---

Something like that. Of course you need to free that when you are done.


Quzah.

Do you understand why this C version works?

Code:

---

const char *getName()
{
    const char *name="Sumit";
    return name;
}

---

Quote:

---

Originally Posted by Salem

Do you understand why this C version works?

Code:

---

const char *getName()
{
    const char *name="Sumit";
    return name;
}

---

---

I was over thinking it. I suppose we could even shorten that:

Code:

---

char *getName( void )
{
    return "Sumit";
}

---

Quzah.

This C version does not work. It returns garbage (i.e the pointer points to garbage, not to memory conatainig the desired string)

Quote:

---

Originally Posted by Salem

Do you understand why this C version works?

Code:

---

const char *getName()
{
    const char *name="Sumit";
    return name;
}

---

---

Thanks @quzah for your quick reply.

You mean to say that the memory allocated this way is not dynamic

Code:

---

char name[]="Sumit";

---

What we call this type of memory allocation.

Moreover you mean to say that dynamic memory allocated does not have a restricted local (automatic scope)?
Am i right in saying above statements.

Regards

Quote:

---

Originally Posted by quzah

The difference here isn't in the way the pointer is returned really. The difference is what you are actually returning. Or rather, what type of object you are trying to return. In the first example, you are returning a local variable. If you were actually allocating some memory dynamically, copying your characters into that block of memory, and then returning that - then you would be like what your Java example does; assuming the Java example is actually correct.

Code:

---

char *getName( void )
{
    char buf[ BUFSIZ ] = { "some name" };
    char *s = NULL;
    s = malloc( strlen( buf ) + 1 );
    strcpy( s, buf );
    return s;
}

---

Something like that. Of course you need to free that when you are done.


Quzah.

---

Quote:

---

Moreover you mean to say that dynamic memory allocated does not have a restricted local

---

In general, when you allocate memory, it is done on the heap.
But variable declarations get memory on the stack, making them local in scope.

Quote:

---

Originally Posted by sumit180288

Now I have a doubt the same thing works in Java
(...)
The caller of the method will correctly get the String returned.

---

You could say that the local String reference variable is destroyed, but the String object itself is not necessarily destroyed when the method returns. It may be destroyed at some point when it is clear that there are no references that refer to the String object. In general, object lifetime in Java is not deterministically associated with the scope of a variable.

Quote:

---

Originally Posted by sumit180288

This C version does not work. It returns garbage (i.e the pointer points to garbage, not to memory conatainig the desired string)

---

Look more carefully at the type of name and what name refers to before jumping to that conclusion.

Quote:

---

Originally Posted by sumit180288

This C version does not work. It returns garbage (i.e the pointer points to garbage, not to memory conatainig the desired string)

---

It does work, and here's why: the string literal "Sumit" is effectively a global/static variable, so returning it's address (stored in the pointer 'name', that is) it perfectly safe. Now had you declared it:

Code:

---

char name[ ] = "Sumit";

---

Here, the string literal is copied into a local array of bytes and then a pointer to the latter returned to the caller, which is of course unsafe.

Dynamic allocation (such as using malloc) is similar to the first case, except now we are using a library routine that serves up pieces of a global/static chunk of data which can be safely returned to the caller.

> This C version does not work. It returns garbage (i.e the pointer points to garbage, not to memory conatainig the desired string)
What crap are you smoking?

Code:

---

$ cat baz.c
#include <stdio.h>
const char *getName()
{
    const char *name="Sumit";
    return name;
}
int main ( ) {
  printf("%s\n",getName());
  return 0;
}
$ gcc -W -Wall -ansi -pedantic baz.c
$ ./a.out
Sumit
$

---

This is NOT the same as your array code in your first post.

If you're still under the illusion that arrays and pointers are the same thing in C, then read this.
Arrays and Pointers

Code:

---

char *f()
        {
                char buf[10];
                /* ... */
                return buf;
        }

---

According to a link http:///www.lysator.liu.se/c/c-faq/c-3.html, the above set of statements will result in garbage set of values returned.

Quote:

---

Originally Posted by Salem

> This C version does not work. It returns garbage (i.e the pointer points to garbage, not to memory conatainig the desired string)
What crap are you smoking?

Code:

---

$ cat baz.c
#include <stdio.h>
const char *getName()
{
    const char *name="Sumit";
    return name;
}
int main ( ) {
  printf("%s\n",getName());
  return 0;
}
$ gcc -W -Wall -ansi -pedantic baz.c
$ ./a.out
Sumit
$

---

This is NOT the same as your array code in your first post.

If you're still under the illusion that arrays and pointers are the same thing in C, then read this.
Arrays and Pointers

---

Quote:

---

Originally Posted by sumit180288

According to a link http:///www.lysator.liu.se/c/c-faq/c-3.html, the above set of statements will result in garbage set of values returned.

---

Effectively yes, though strictly speaking there is undefined behaviour if the return value is used. It is good that you recognise this, but you should also recognise that your claim that "this C version does not work" is not backed up by this example, because the essential part of the code is different.

OK i got ur point
Can you tell me what is the difference between these two codes:

Code:

---

char *f()
{
char *name="Sumit";
return name;
}

---

and

Code:

---

char *f()
{
char name[]="Sumit";
return name;
}

---

WHY the FIRST VERSION WORKS???

Quote:

---

Originally Posted by Salem

> This C version does not work. It returns garbage (i.e the pointer points to garbage, not to memory conatainig the desired string)
What crap are you smoking?

Code:

---

$ cat baz.c
#include <stdio.h>
const char *getName()
{
    const char *name="Sumit";
    return name;
}
int main ( ) {
  printf("%s\n",getName());
  return 0;
}
$ gcc -W -Wall -ansi -pedantic baz.c
$ ./a.out
Sumit
$

---

This is NOT the same as your array code in your first post.

If you're still under the illusion that arrays and pointers are the same thing in C, then read this.
Arrays and Pointers

---

> According to a link http:///www.lysator.liu.se/c/c-faq/c-3.html, the above set of statements will result in garbage set of values returned.
Like I said, until you recognise that char* and char[] are different things, you're just going to be confused.

@Salem. Sorry to say i didn't see the pointer version. I thought u are asking about the array version.
I am also not knowing why this verison works?
Anyone plz clear this doubt.

Regards

Quote:

---

Originally Posted by Salem

Do you understand why this C version works?

Code:

---

const char *getName()
{
    const char *name="Sumit";
    return name;
}

---

---

Some posts from this thread were moved to: Java standard

Quote:

---

Originally Posted by sumit180288

Can you tell me what is the difference between these two codes:

---

You can observe the difference yourself: in the former, name is a pointer that points to the first character of a string literal; in the latter, name is an array of 6 char.

In Salem's example you are returning a pointer, which since C is pass by value, gets copied. That pointer points to a string literal which stays present for the life of the program.

Moreover the array declaration

Code:

---

char a[]="Sumit";

---

Here a also points to the string literal.
What is the difference?

Quote:

---

Originally Posted by AndrewHunter

In Salem's example you are returning a pointer, which since C is pass by value, gets copied. That pointer points to a string literal which stays present for the life of the program.

---

Quote:

---

Originally Posted by sumit180288

returning a string literal would be something like return "Sumit";

---

Yes. However, returning a pointer to the first character in a string literal would have the same effect.

Be careful. It does not point to a string literal.

The "Sumit" here is just one way of writing:

Code:

---

char a[] = {'S','u','m','i','t',0};

---

Saving ones fingers does not change the semantics of variable storage. The array (meaning its contents) are stored locally in the scope of the nearest block.

Quote:

---

Originally Posted by sumit180288

Moreover the array declaration

Code:

---

char a[]="Sumit";

---

Here a also points to the string literal.
What is the difference?

---

Again, in that case, you are copying the character literal into a local array of bytes.

I would like to add that we are essentially "playing with fire" here. No comments made can be verified on all implementations, since Java doesn't have one. This entire conversation should be moved to the tech board.

@whiteflags and @all dear members

Can u tell me the difference in the mechanisms of memory storage in case of a string literal and the one mentioned by @whiteflags i.e.

Code:

---

char a[] = {'S','u','m','i','t',0};

---

Is String literal not stored as a[] is stored?

Quote:

---

Originally Posted by whiteflags

Be careful. It does not point to a string literal.

The "Sumit" here is just one way of writing:

Code:

---

char a[] = {'S','u','m','i','t',0};

---

Saving ones fingers does not change the semantics of variable storage. The array (meaning its contents) are stored locally in the scope of the nearest block.

---

Quote:

---

Originally Posted by sumit180288

Is String literal not stored as a[] is stored?

---

What do you mean?

EDIT:
Oh, I think I understand. Let me just say this: the string literal has static storage duration. Its lifetime is for the entire program. A local array's lifetime, on the other hand, is only until its scope ends, unless it has say, static storage duration due to being declared static.

Code:

---

char a[] = { "stuff" };

---

That declares a local variable (assuming this in a function) with the name of a, that is an array of characters, whose size is determined by the number of characters provided as the initializer.

Code:

---

char *a = "stuff";

---

This declares a variable named a that is a pointer to a character, and that points at a string literal.

They are two different things.


Quzah.

@laserlight.
Nice thoughts there. Could you please tell me a link or a reference where i can get these nice facts about the scope of a literal.

Quote:

---

Originally Posted by laserlight

What do you mean?

EDIT:
Oh, I think I understand. Let me just say this: the string literal has static storage duration. Its lifetime is for the entire program. A local array's lifetime, on the other hand, is only until its scope ends, unless it has say, static storage duration due to being declared static.

---

Quote:

---

Originally Posted by sumit180288

@Salem. Sorry to say i didn't see the pointer version. I thought u are asking about the array version.
I am also not knowing why this verison works?
Anyone plz clear this doubt.

Regards

---

Ok... all the way back to your first message...

The Java version works because Java has a native string type that is "reference counted". That is the memory occupied by the string is not released if there is anything referring to it, like in your first example.

However, C does not have a string type (despite some who argue to the contrary). C programs use character arrays to store groups of characters with a terminating null. We call it a string but it isn't really a string (in the Pascal/Basic/Java sense) at all. It is nothing but an array, that gets destroyed in the stack cleanup when the function exits, leaving you with a pointer to garbage.

Why does the one in message 15 work? Because the literal string "Sumit" is not created or stored in the program stack area used by the function, therefore it's address remains valid after the function exits... that is, it doesn't get invalidated by the stack cleanup.


This is one of the pitfalls of comparing languages... as they say "This ain't That"... and it's a mistake to try to understand one by knowing the other.

@Tater
Correctly said... But i will one more argument in support.
Every thing is an object in Java (including arrays) i.e. Memory for these objects are allocated dynamically out of heap.
Hence as u mentioned It remains there until all references to that memory location dies out. (i.e. reference count becomes zero).
This is internally performed internally using the GC (Garbage collector) which is a very nice functionality provided by Java and we dont have to worry about
freeing up this dynamic heap memory. It is automatically managed by JDK.


Memory allocated out of heap space will remain for a lifetime which is till program ends or if memory is freed forcefully.

1. The memory which is allocated using malloc() etc function
2. String literal. (Dynamic allocation not done but literals have static scope)
etc.

@ALL PLZ ADD ANYTHING ELSE WHERE MEMORY IS DYNAMICALLY ALLOCATED.

Quote:

---

Originally Posted by CommonTater

Ok... all the way back to your first message...

The Java version works because Java has a native string type that is "reference counted". That is the memory occupied by the string is not released if there is anything referring to it, like in your first example.

However, C does not have a string type (despite some who argue to the contrary). C programs use character arrays to store groups of characters with a terminating null. We call it a string but it isn't really a string (in the Pascal/Basic/Java sense) at all. It is nothing but an array, that gets destroyed in the stack cleanup when the function exits, leaving you with a pointer to garbage.

Why does the one in message 15 work? Because the literal string "Sumit" is not created or stored in the program stack area used by the function, therefore it's address remains valid after the function exits... that is, it doesn't get invalidated by the stack cleanup.


This is one of the pitfalls of comparing languages... as they say "This ain't That"... and it's a mistake to try to understand one by knowing the other.

---