Change in original array but the clone array stay the same; C#-CodePudding

Here is my original array called "gridPlacement"

Original Array: "gridPlacement"

Clone Array: "p1"

class gridMemory
{
    static public string[] gridPlacement =
        new string[9] {"x", "b", "c", "h", null, null, null, null, null };
}

Here is my cloned array called "p1". Although, it is only consist some part of the original array.

class handleWinLost
{
    static public string[] p1 = new string[3] {
        gridMemory.gridPlacement[0],
        gridMemory.gridPlacement[3]
        gridMemory.gridPlacement[2]
    };
}

When I made changes to the index 2 of original array from "c" to "b". Array p1 last element stay the same, "c". Even though, gridMemory.gridPlacement[2] which is p1[2].

CodePudding user response：

This statement:

static public string[] p1 = new string[3] {
    gridMemory.gridPlacement[0],
    gridMemory.gridPlacement[3]
    gridMemory.gridPlacement[2]
};

... creates an array, and assigns values to the element. Leaving aside the fact that it's a field declaration, it's equivalent to:

string[] p1 = new string[3];
p1[0] = gridMemory.gridPlacement[0];
p1[1] = gridMemory.gridPlacement[3];
p1[2] = gridMemory.gridPlacement[2];

Each of those assignments just evaluates the expression on the right hand side, and copies it to the array element described on the left hand side. It doesn't set up any lasting relationship between say p1[0] and gridMemory.gridPlacement[0]. Any later changes in gridMemory.gridPlacement are completely irrelevant to handleWinLost.p1.

CodePudding user response：

If you want to reflect changes of the original array, store indexes instead:

public static int[] p1 = new int[3] { 0, 3, 2 };

And then get the values like this:

string value = gridMemory.gridPlacement[p1[i]];

You can also make p1 private and provide a method for the access:

private static int[] p1 = new int[3] { 0, 3, 2 };

public static int PlacementCount => p1.Length;

public static string GetPlacementAt(int index) 
{
    return gridMemory.gridPlacement[p1[index]];
}

and access it like this (in a loop as an example):

for (int i = 0; i < handleWinLost.PlacementCount; i  ) {
    string placement = handleWinLost.GetPlacementAt(i);
    Console.WriteLine(placement);
}

CodePudding user response：

You intend to run this line of code:

gridMemory.gridPlacement[2] = "b";

Ultimately, strings are reference types, with some special treatment to give them value semantics. This means before the line runs, you have two reference variables: gridMemory.gridPlacement[2] and p1[2], that both refer to the same string object in memory, which happens to have a value of "c".

That is, we have the variable gridMemory.gridPlacement[2], whose value is a reference to some address in memory, and we have the variable p1[2] whose value is also a reference to some address in memory. These two references happen to target the same memory, but they are not the same reference.

So now we run the line of code. What it does is create a new string object in memory ("b"), and assign a reference to that string object to gridMemory.gridPlacement[2].

At no point is p1[2] ever involved in this code. It still refers to the same memory, which still has a value of "c".