Lära Arraykopiering och minne | Arraymanipulation och sortering

Svep för att visa menyn

När du arbetar med arrayer i C# är det viktigt att förstå hur de lagras i minnet och vad som händer när du kopierar eller tilldelar dem. Arrayer i C# är referenstyper, vilket innebär att variabler innehåller en referens (eller pekare) till var arrayens data är lagrad i minnet, inte själva datan. Detta har betydande konsekvenser när du tilldelar en arrayvariabel till en annan eller när du vill göra en verklig kopia av en arrays innehåll. Om du förbiser dessa detaljer kan du av misstag ändra data på ställen du inte avsett, vilket leder till svårspårade buggar.

Program.cs


              12345678910111213141516171819202122232425262728293031
            
namespace ConsoleApp
{
    public class Program
    {
        public static void Main(string[] args)
        {
            int[] original = { 1, 2, 3, 4, 5 };

            // Assigning the array reference
            int[] assigned = original;

            // Copying the array elements
            int[] copied = new int[original.Length];
            for (int i = 0; i < original.Length; i++)
            {
                copied[i] = original[i];
            }

            // Modify the assigned array
            assigned[0] = 99;

            // Modify the copied array
            copied[1] = 77;

            System.Console.WriteLine("original: " + string.Join(", ", original));
            System.Console.WriteLine("assigned: " + string.Join(", ", assigned));
            System.Console.WriteLine("copied: " + string.Join(", ", copied));
        }
    }
}

När du tilldelar en arrayvariabel till en annan pekar båda variablerna på samma minnesplats. Detta innebär att en ändring som görs via en variabel syns i den andra, eftersom de bara är två referenser till samma array. Om du vill undvika detta måste du kopiera varje element till en ny array, som visas i koden ovan. Detta skapar en ny array i minnet, så ändringar i en array påverkar inte den andra.

Detta leder till begreppen ytlig kopiering och djup kopiering. En ytlig kopiering kopierar endast referensen till arrayen, inte själva elementen. En djup kopiering skapar en ny array och kopierar varje element till den, vilket resulterar i två oberoende arrayer.

Program.cs


              1234567891011121314151617
            
namespace ConsoleApp
{
    public class Program
    {
        public static void Main(string[] args)
        {
            int[] numbers = { 10, 20, 30 };
            int[] shallow = numbers;

            shallow[1] = 99;

            System.Console.WriteLine("numbers: " + string.Join(", ", numbers));
            System.Console.WriteLine("shallow: " + string.Join(", ", shallow));
        }
    }
}

Kodexemplet visar vad som händer när du utför en ytlig kopia av en array i C#. När du tilldelar en arrayvariabel till en annan, som int[] shallow = numbers, skapar du inte en ny array eller kopierar elementen. Istället pekar båda variablerna, numbers och shallow, på samma array i minnet. Detta innebär att varje ändring du gör via en variabel kommer att vara synlig genom den andra.

Definition

En ytlig kopia kopierar referensen till arrayen, så båda variablerna pekar på samma minnesplats. En djup kopia skapar en ny array och kopierar alla element, så arrayerna är oberoende av varandra.

1. Vad händer när du tilldelar en arrayvariabel till en annan i C#?

2. Hur kan du skapa en verklig kopia av en array?

3. Varför är det viktigt att förstå arrayminne när du manipulerar data?

Var allt tydligt?

Tack för dina kommentarer!

Avsnitt 3. Kapitel 5

Fråga AI

Fråga vad du vill eller prova någon av de föreslagna frågorna för att starta vårt samtal

Avsnitt 3. Kapitel 5