string in Stack or Heap ?

[thomus07]

I understand string is reference type.
string s;
Is "s" pointing a stack or heap object ?

[Mutant_Fruit]

All reference types live on the heap. Only value types live on the stack, though value type will live on the heap if you box it (cast it to object).

[thomus07]

All reference types live on the heap. Only value types live on the stack, though value type will live on the heap if you box it (cast it to object).

Thanks Mutant_Fruit

But we won't use new to create this string object.

[darwen]

You will be implicitly :

string s = "hello";

compiles to (in IL)

.locals init (
    [0] string s)

L_0000: nop 
L_0001: ldstr "hello"
L_0006: stloc.0

If you look in the docs it says that

ldstr
Pushes a new object reference to a string literal stored in the metadata.

So "hello" is stored in the metadata of the assembly, but the ldstr instruction creates a reference to a string object (i.e. on the heap) from this metadata.

Darwen.

[thomus07]

You will be implicitly :

string s = "hello";

compiles to (in IL)

.locals init (
    [0] string s)

L_0000: nop 
L_0001: ldstr "hello"
L_0006: stloc.0

If you look in the docs it says that



So "hello" is stored in the metadata of the assembly, but the ldstr instruction creates a reference to a string object (i.e. on the heap) from this metadata.

Darwen.

Thanks Darwen.

[srishi1302]

I have the question in same line
then why reference of string is not passed to any of my function
ie

code:
public static void swap(string s1, string s2)
{
// If Pass strings from main to this function i will get local copies of s1 and s2
//instead of their references
}

code:
Any help is appreciated
Thanks in advance.

[dannystommen]

if you want to pass a reference as paramater, you need to add the 'ref' modifier.

public static void swap(ref string s1, ref string s2)
{
   ...
}

[darwen]

// If Pass strings from main to this function i will get local copies of s1 and s2
//instead of their references

How do you know you're getting local copies ?

Actually you're not getting local copies, you're getting references. The strings are passed by reference. Because System.String is a class which are always passed by reference in .NET - that's why they are called 'reference types'.

But System.String is peculiar in that it is an immutable class i.e. it exposes no methods which allow you to change the contents of the class once it's been created. Hence it behaves like a value type, but in fact is a reference type.

That's probably why you think you're getting a local copy - you aren't, you are just getting references to instances of string which you can't change.

Darwen.

[Mutant_Fruit]

if you want to pass a reference as paramater, you need to add the 'ref' modifier.

public static void swap(ref string s1, ref string s2)
{
   ...
}

Strings are reference types so you don't 'copy' them by passing them to anther function. The ref parameters are unnecessary for this case.

[BigEd781]

if you want to pass a reference as paramater, you need to add the 'ref' modifier.

public static void swap(ref string s1, ref string s2)
{
   ...
}

Well, you need to use ref if you want the original reference instead of a copy. Reference types are always passed by reference, but that a copy of that reference is passed in by default (i.e., when you don't use the 'ref' keyword.)

[thomus07]

            string s1 = "first string";
            string s2 = "second string";

            s1 = s2;

So, what happens in s1 = s2 ?

- Is that the address of s2 copied to s1 (Shallow copy)?
- Copy the entire contents (deep copy) ?

- or What ?

[BigEd781]

They are references, so the reference is copied to s1;

[thomus07]

Thank you BigEd781.

May I know what makes it immutable.

[vcdebugger]

may be the keyword "sealed" which dont allow you to inherit the string class further ?

[BigEd781]

may be the keyword "sealed" which dont allow you to inherit the string class further ?

No, it is immutable simply because the class gives you no way to change its member data. Look at this class:

class Foo
{
    public readonly int Id;
    public readonly string Name;

    public Foo( int id, string name )
    {
        Id = id;
        Name = name;
    }
}

That class is immutable. You pass some data into the constructor, the data is set, and now there is no way that it can be changed by the outside world.