why don't string object refs behave like other object refs?

Question

string a = "a";

string b = a;

string a = "c";

Why does string b still have the value "a" and not "c"?

As string is an object and not a stack value type, what's with this behaviour?

Thanks

Answer 1

You're pointing the variable to something new, it's no different than if you said

Foo a = new Foo();
Foo b = a;
a = new Foo();
// a no longer equal to b

In this example, b is pointing to what a initially referenced. By changing the value of a, a and b are no longer referencing the same object in memory. This is different than working with properties of a and b.

Foo a = new Foo();
Foo b = a;
a.Name = "Bar";
Console.WriteLine(b.Name);

In this case, "Bar" gets written to the screen because a and b still reference the same object.

Answer 2

Let me start by saying that your choices for variables and data are poor. It makes it very difficult for someone to say "the string a in your example..." because "a" could be the content of the string, or the variable containing the reference. (And it is easily confused with the indefinite article 'a'.)

Also, your code doesn't compile because it declares variable "a" twice. You are likely to get better answers if you ask questions in a way that makes them amenable to being answered clearly.

So let's start over.

We have two variables and two string literals.

string x = "hello";
string y = x;
x = "goodbye";

Now the question is "why does y equal 'hello' and not 'goodbye'"?

Let's go back to basics. What is a variable? A variable is a storage location.

What is a value of the string type? A value of the string type is a reference to string data..

What is a variable of type string? Put it together. A variable of type string is a storage location which holds a reference to string data.

So, what is x? a storage location. What is its first value? a reference to the string data "hello".

What is y? a storage location. What is its first value? a reference to the string data "hello", same as x.

Now we change the contents of storage location x to refer to the string data "goodbye". The contents of storage location y do not change; we didn't set y.

Make sense?

why don’t string object refs behave like other object refs?

I deny the premise of the question. String object refs do behave like other object refs. Can you give an example of where they don't?

Answer 3

Part of what confuses people so much about this is thinking of the following as an append operation:

str1 = str1 + str2;

If string were a mutable type, and the above were shorthand for something like this:

str1.Append(str2);

Then what you're asking would make sense.

But str1 = str1 + str2 is not just some method call on a mutable object; it is an assignment. Realizing this makes it clear that setting a = "c" in your example is no different from assigning any variable (reference type or not) to something new.

The below comparison between code that deals with two List<char> objects and code that deals with two string objects should hopefully make this clearer.

var a = new List<char>();
var b = a; // at this point, a and b refer to the same List<char>

b.Add('a'); // since a and b refer to the same List<char> ...
if (b.Contains('a')) { /* ...this is true... */ }
if (a.Contains('a')) { /* ...and so is this */ }

// HOWEVER...
a = new List<char>(); // now a and b do NOT refer to the same List<char>...
if (b.Contains('a')) { /* ...so this is still true... */ }
if (a.Contains('a')) { /* ...but this is not */ }

Compare this with a slightly modified version of the code you posted:

string a = "a";

string b = a; // at this point, a and b refer to the same string ("a")...
if (b == "a") { /* ...so this is true... */ }
if (a == "a") { /* ...and so is this */ }

// REMEMBER: the below is not simply an append operation like List<T>.Add --
// it is an ASSIGNMENT
a = a + "c"; // now they do not -- b is still "c", but a is "ac"
if (b == "a") { /* ...so this is still true... */ }
if (a == "a") { /* ...but this is not */ }

Answer 4

In .Net, a, b and c are reference to the objects and not the objects themselves. When you reset a, you are pointing this reference to a new memory location. The old memory location and any references to it are unchanged.

Answer 5

I guess the OP thinks string objects to be mutable, so something like var = "content"; would actually store the new character array inside the already existing object.

String is, however, an immutable type, which means that in this case a new string object is created and assigned to var.

See for example: http://codebetter.com/blogs/patricksmacchia/archive/2008/01/13/immutable-types-understand-them-and-use-them.aspx

Answer 6

It is a misunderstanding because of the builtin string support of c#.

string a = "123"; //The way to write it in C#
string a = new string("123"); //Would be more obvious

The second way to define a is more obvious what happens, but it is verbose.Since strings have direct support from the compiler calling the string constructor is unnecessary.
Writing your example verbose:

string a = new string("a");

string b = a;

string a = new string("c");

Here the behavior is as expected a gets a reference to the new string object assigned. while the reference held by b still points to the old string.