C# Strings – Immutable String in Array, Reference Type vs Value Type

arraycreferencestringsvalue-object

Trying to understand strings better in C#

Are these assertions correct?

string is immutable
string is reference type but behaves like value type

For these code samples…

string x = "one"

(creates string instance holding "one" in memory)

x = "two"

(destroys "one" instance and creates new string instance holding "two" in memory, even though it is using the same variable x)

If the above are correct, what happens in a string array when one index value changes?

string[] array = new string[2];

array[0] = "boo";   (string "boo" created and held in 0 index)
array[1] = "shoo";

array[0] = "moo";

Does the last assignment create an entire new array to change boo to moo? My best "guess" is that the array holds pointers so that array[0] simply points to the new string instance that holds "moo". Is this correct? If not, could someone please clarify, thanks.

Best Answer

You have to be careful with some of the assumptions you are making about strings. The CLR has a "a table, called the intern pool, which contains a single instance of each unique literal string constant declared in a program". So what is really happening in your examples is:

string x = "one" // x references the "one" constant in the intern pool
x = "two" // x now references the "two" constant in the intern pool

array[0] = "boo"; // array[0] references the "boo" constant in the intern pool
array[1] = "shoo"; // array[1] references the "shoo" constant in the intern pool
array[0] = "moo"; // array[0] now references the "moo" constant in the intern pool

Related Solutions

Java Best Practices – String Array Constants and Indexing

I much prefer using Enums to store system wide string constants, makes it easy to create additional functionality and I think it is generally accepted best practice.

public enum Cat {
     A() {
          @Override public void execute() { 
               System.out.println("A clicked"); 
          }
     },
     B() {
          @Override public void execute() { 
               System.out.println("B Clicked"); 
          }
     };
     //template method
     public abstract void execute();
}

then you can call it like so :

String clickedItem = "A";    
Cat.valueOf(clickedItem).execute(); //will print A is clicked

or you could also the Command pattern without enums....

public interface Cat {
     void do();
}

public class CatA() implements Cat {
     void do() {//put your code here}
}
public class CatB() implements Cat {
     void do() {//put your other code here}
}

then build a Map object and populate it with Cat instances:

catMap.put("A", new CatA());
catMap.put("B", new CatB());

then you can replace your if/else if chain with:

catMap.get(clickedItem).do();

C++ – 2D linked list vs. multidimensional array/vector

I hope it's ok to answer my own question. I believe I have found the optimal (without overcomplicating the problem) data structure for my problem. There was at least minor idiocy on my part for not recognising this earlier. The data doesn't need to be accessed by (x,y,z) but instead by (x, y, range of z (say 0 - 3)). This give a C++ struct as follows:

struct node {
  struct node *next;
  int zGroup;
  int z;
  50 bytes of misc data };

I can then address this through a 3D dynamic array (vectors):

vector< vector < vector < node* > > > Data;

Any given Data[x][y][zGroup] points to the first element of a linked list, the entirety of which is needed every time one element of it is needed. No value of this array is NULL, every one contains a linked-list of at least one element.

The third dimension of the array - the zGroup has jagged dimensions, but with dynamic arrays this isn't an issue. Given the data and computations being performed on it, I know that the max x and y values are set when the file is read and do not change, neither does the number of z groups on any given (x,y) line, the actual z-values of nodes may change, but they will remain inside the same z-groups, giving a constant-sized, fully populated array.

With the way that the file is structured it is also easy enough to page it in and out of memory if I am brought to do this with much larger data sets.

Best Answer

Related Solutions

Java Best Practices – String Array Constants and Indexing

C++ – 2D linked list vs. multidimensional array/vector

Related Topic