En matris är en samling data av en viss typ som kan nås med ett index. Det är särskilt användbart för att lagra information av en viss datatyp när du inte nödvändigtvis vet hur mycket information du behöver förhand. Säg till exempel att du ville lagra en samling heltal. Du kan dedicera rader och kodrader för att deklarera varje heltal och ge var och en en unik identifierare som gör att du kan komma åt det vid ett senare tillfälle. Eller så kan du ha ett enda antal heltal och få åtkomst till vart och ett av dina heltal genom att helt enkelt passera ett indexvärde. Mycket effektivare, mycket lättare att manipulera.

Så låt oss gå igenom hur man deklarerar, tilldelar variabler till och använder en matris i C #, och hur detta kan översättas till Unity3D-miljön. För din bekvämlighet har jag också inkluderat en videoversion av den här artikeln nedan.

Använda 1 och 2D-matriser i Unity3D / C #

Deklaration

För att deklarera en matris anger du helt enkelt den datatyp du vill följt av fyrkantiga parenteser och slutligen identifieraren du vill att denna matris ska gå förbi. Såhär;

 heltal [] array; 

Du kanske vill göra din grupp offentligt tillgänglig, i vilket fall du skulle kvalificera din förklaring med en public, eller kanske du vill se till att den förblir otillgänglig offentligt, i vilket fall du skulle kvalificera förklaringen med ”privat ”.

initiering

Det räcker dock inte att bara förklara en matris. Du måste initiera det. Som någon som lärde sig att koda till stor del genom att titta på exempel på nätet och titta på YouTube-tutorials verkar det som om att inte korrekt initiera matriser är ett av de vanligaste misstag som nybörjare gör.

Så för att initiera din matris måste du ange den som en ny instans för din datatypsuppsättning med en specificerad storlek. Du kan göra detta med din ursprungliga deklaration eller senare med din kod. Det senare är användbart i situationer där du behöver matrisen för att vara tillgänglig klassvis (så du behöver den förklaras högst upp i din kod), men du vet inte hur stor den måste vara förrän du börjar köra din kod. Så för att initiera en mängd heltal med en storlek på sex, skulle du skriva;

 offentligt heltal [] array = nytt heltal [6]; 

Eller om du vill att din förklaring och initialisering ska ske separat ...

 privat int [] array; public void SomeFunction () {array = nytt heltal [6]; } 

Du kan också förklara, initialisera och ställa in din grupp samtidigt genom att ställa in värdena på deklarationen. Storleken på matrisen bestäms i sig av antalet värden du lägger i det. Till exempel...

 privat int [] array = nytt int [] {9, 4, 7, 1, 3, 6}; 

... kommer att ge oss en rad ints som är sex långa, och som redan har värdena inställda.

Ställa in data

När du har angett och initierat ditt array och antagit att du inte tilldelade variabler vid deklarationen som visas ovan, är det dags att mata in data i den. Detta görs helt enkelt genom att lämna ett index till din matris och sedan komma åt det som en annan variabel. Så om vi ville ställa in det första objektet i matrisen till 9, skulle vi skriva;

 matris [0] = 9; 

Du kommer att märka att vi använde 0, inte 1, som vårt indexvärde. Arrayindex börjar på noll, vilket är viktigt när du kommer till det sista indexet i en matris; du skulle subtrahera en från längden på arrayen för att få det sista objektet i den arrayen. Om du till exempel ställer in det sista objektet i vårt array till 6 skulle du göra det;

 array [array.Length - 1] = 6; 

Looping Through the Array

Med hjälp av vår Längdvariabel kan vi gå igenom vårt array och ställa in eller komma åt vart och ett av våra objekt på bara några kodrader. Följande kodstycke slingrar genom alla objekt i matrisen och sätter deras värde till samma som indexet och skriver sedan ut det värdet till loggen.

 för (int i = 0; i <array. Längd; i ++) {array [i] = i; Debug.Log (i.ToString ()); } 

Inom syntaxen för kommandot för skapar du ett heltal med namnet “i” som förklarar att for-loopen kommer att köras medan i är mindre än längden på arrayen, och att jag kommer att öka med en med varje iteration av slingan. Lägg märke till att vi inte behöver subtrahera en från array.Length. Det beror på att vi slingrar medan i är mindre än längden. Vilket kommer att vara sant tills jag är lika med längden, så vi kommer inte att gå längre än matrisen.

Du kan också gå igenom din array utan att använda längdvariabeln med kommandot “foreach”. För att uppnå samma resultat som ovan på detta sätt skriver du;

 int-räkning = 0; förhand (heltal i array) {heltal = räkning; Debug.Log (heltal); räkna ++; } 

Som ni ser är syntaxen för själva slingan mer förenklad. Vi deklarerar helt enkelt vår datatyp (int) och ger den en identifierare (heltal) och anger sedan den matris vi ska slinga igenom (array). Men bristen på ett inneboende inkrementellt värde innebär att vi måste skapa och öka vårt eget, som vi gjorde med variabeln "räkna".

2D-matriser

En tvådimensionell matris kan tänkas som ett rutnät eller en lista med matriser. Du förklarar på samma sätt som en enstaka dimensionell matris, men med ett komma för att beteckna att denna matris har mer än en dimension.

 public int array [, ] = new int [, ]; 

Det är kanske enklast att visualisera en tvådimensionell matris när man ställer in variablerna på deklarationen som så;

 public int array [, ] = new int [, ] {0, 5, 1}, {8, 2, 9}, {4, 6, 7} 

Som du kan se kan den flerdimensionella matrisen ses som ett tvådimensionellt rutnät, eller en lista med enkeldimensionella matriser, som var och en är tre i längd. För att få eller ställa in värdet på en matrisposition, passerar du helt enkelt in det horisontella och vertikala indexet, liknande ett rutnät eller ett kalkylblad. Så om vi ville skriva ut den nedre högra variabeln till konsolen, skulle vi skriva;

 Debug.Log (array [2, 2] .ToString ()); 

Kom ihåg att indexen börjar på noll så att maxindexet är längden (3 i detta fall) minus ett.

Använda matriser i enhet

Unity tillhandahåller en automatisk GUI-lösning för redigering av matriser i vissa sammanhang genom Unity Inspector. Det finns två sätt att få en grupp att visas i inspektören, du kan antingen offentliggöra den (som visas ovan) eller så kan du göra det seriellt. Så här gör du en deklaration i serie;

 [SerializeField] privat int [] array; 
Om du gör en matris offentlig eller seriell i din kod kommer du att kunna redigera i enhetsinspektören. |

Oavsett om det är offentligt eller seriellt, matriser som visas i inspektören initialiseras automatiskt, så du behöver inte ange storlek och innehåll för matrisen i din kod, men du kan om du vill. Att ha en grupp offentligt är dock inte exakt bästa praxis, så det skulle vara bättre att gå in i vanan att ha dina matriser privata (och serialiseras om du behöver redigera i inspektören) och skriva en offentlig funktion för att ändra eller extrahera information från matrisen. Detta gör att du också kan hålla full kontroll över hur information som går in eller ut ur matrisen hanteras.

Om du av någon anledning behöver din grupp för att vara offentlig och den matrisen kommer att ha en massa artiklar (tusentals eller fler) vill du INTE att den ska dyka upp i inspektören, eftersom det kommer att göra att Unity hänger under lång tid och troligen kraschar. I en sådan situation kan du hålla din grupp borta från inspektören med följande kval.

 [HideInInspector] public int [] array; 

Och kom ihåg att dessa matriser måste initialiseras i din kod.

Anpassade klassuppsättningar

Matriser kan göras med en anpassad klass som datatyp genom att initialisera på exakt samma sätt som visas ovan. Den enda skillnaden är att om du vill att ditt utbud av anpassade klasser ska visas i inspektören måste du göra klassserien. Du gör det genom att sätta;

 [System.Serializable] 

Ovanför din klass. Så ett komplett skript för att skapa en matris av en anpassad klassdatatyp kan se ut så här;

 använder System; med hjälp av System.Collections.Generic; använder UnityEngine; offentlig klass MyClass {[SerializeField] private SubClass [] myArray; public void SetValue (int index, SubClass subClass) {// Utför valideringskontroller här. myArray [index] = underklass; } public SubClass GetValue (int index) {// Utför valideringskontroller här. returnera myArray [index]; }} [System.Serializable] public class SubClass {public int number; public string text; } 

Detta skulle skapa en mängd SubClass s, som för tillfället bara innehåller viss godtycklig information för demonstrationsändamål, som är synlig och modifierbar från enhetsinspektören, men som skulle behöva passera genom SetValue och GetValue funktioner för att manipulera data i den arrayen.

Och det är slutet på denna korta handledning om hur man initierar och använder matriser i C # och Unity3D. Jag hoppas att du hittade detta användbart.

Känner du att du förstår grunderna i matriser i C # och Unity3D?

  • Definitivt
  • Absolut inte
  • Jag tror det
Se resultat

© 2019 John Bullock