Why don't we use new operator while initializing a string?

Question

I was asked this question in an interview: Is string a reference type or a value type.

I said its a reference type. Then he asked me why don't we use new operator while initializing the string ? I said because the c# language has a simpler syntax for creating a string and the compiler automatically converts the code into a call for the construcor of the System.String class.

Is this answer correct or not ?

Answer 1

Strings are immutable reference types. There's the ldstr IL instruction which allows pushing a new object reference to a string literal. So when you write:

string a = "abc"; 

The compiler tests if the "abc" literal has already been defined in the metadata and if not declare it. Then it translates this code into the following IL instruction:

ldstr "abc" 

Which basically makes the a local variable point to the string literal defined in the metadata.

So I would say that your answer is not quite right as the compiler doesn't translate this into a call to a constructor.

Answer 2

Not exactly the right answer. Strings are "special" reference types. They are immutable. You are right that compiler does something internally, but it is not the constructor call. It calls ldstr which pushes a new object reference to a string literal stored in the metadata.

Sample C# code :

class Program {     static void Main()     {         string str;         string initStr = "test";     } } 

and here is the IL code

.method private hidebysig static void  Main() cil managed {   .entrypoint   // Code size       8 (0x8)   .maxstack  1   .locals init ([0] string str,            [1] string initStr)   IL_0000:  nop   IL_0001:  ldstr      "test"   IL_0006:  stloc.1   IL_0007:  ret } // end of method Program::Main 

You can see ldstr call above.

Even more due to immutability of the Strings it becomes possible to keep only distinct/unique strings. All strings are kept in the hash table where the key is the string value and the value is the reference to that string. Each time when we have a new string CLR checks is there already such a string in the hash table. If there is then no new memory is allocated and the reference is set to this existing string.

You can run this code to check :

class Program {     static void Main()     {         string someString = "abc";         string otherString = "efg";          // will retun false         Console.WriteLine(Object.ReferenceEquals(someString, otherString));          someString = "efg";          // will return true         Console.WriteLine(Object.ReferenceEquals(someString, otherString));     } }