Leer Array Kopiëren en Geheugen | Arraymanipulatie en Sorteren

C# Arrays

Veeg om het menu te tonen

Wanneer je met arrays werkt in C#, is het belangrijk te begrijpen hoe ze in het geheugen worden opgeslagen en wat er gebeurt wanneer je ze kopieert of toewijst. Arrays in C# zijn referentietypen, wat betekent dat variabelen een referentie (of pointer) bevatten naar de locatie in het geheugen waar de gegevens van de array zijn opgeslagen, niet de daadwerkelijke gegevens zelf. Dit heeft belangrijke gevolgen wanneer je de ene arrayvariabele aan een andere toewijst of wanneer je een echte kopie van de inhoud van een array wilt maken. Als je deze details over het hoofd ziet, kun je per ongeluk gegevens wijzigen op plaatsen waar je dat niet bedoelde, wat kan leiden tot bugs die moeilijk te achterhalen zijn.

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));
        }
    }
}

Wanneer je de ene arrayvariabele aan een andere toewijst, verwijzen beide variabelen naar dezelfde geheugenlocatie. Dit betekent dat een wijziging via de ene variabele zichtbaar is in de andere, omdat het slechts twee referenties naar dezelfde array zijn. Als je dit wilt voorkomen, moet je elk element naar een nieuwe array kopiëren, zoals hierboven in de code wordt getoond. Dit creëert een nieuwe array in het geheugen, zodat wijzigingen in de ene array geen invloed hebben op de andere.

Dit brengt de concepten shallow copy en deep copy naar voren. Een shallow copy kopieert alleen de referentie naar de array, niet de daadwerkelijke elementen. Een deep copy maakt een nieuwe array aan en kopieert elk element daarin, waardoor twee onafhankelijke arrays ontstaan.

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));
        }
    }
}

Het codevoorbeeld laat zien wat er gebeurt wanneer je een oppervlakkige kopie van een array maakt in C#. Wanneer je één arrayvariabele aan een andere toewijst, zoals int[] shallow = numbers, wordt er geen nieuwe array aangemaakt of worden de elementen niet gekopieerd. In plaats daarvan verwijzen beide variabelen, numbers en shallow, naar dezelfde array in het geheugen. Dit betekent dat elke wijziging die je via de ene variabele aanbrengt, zichtbaar is via de andere.

Definitie

Een oppervlakkige kopie kopieert de referentie naar de array, waardoor beide variabelen naar dezelfde geheugenlocatie verwijzen. Een diepe kopie maakt een nieuwe array aan en kopieert alle elementen, zodat de arrays onafhankelijk van elkaar zijn.

Was alles duidelijk?

Bedankt voor je feedback!

Sectie 3. Hoofdstuk 5

Vraag AI

Vraag wat u wilt of probeer een van de voorgestelde vragen om onze chat te starten.

Sectie 3. Hoofdstuk 5

Array Kopiëren en Geheugen

1. Wat gebeurt er als je in C# de ene arrayvariabele aan een andere toewijst?

2. Hoe kun je een echte kopie van een array maken?

3. Waarom is het belangrijk om het geheugen van arrays te begrijpen bij het manipuleren van gegevens?