OLD [G_PRO] Programmeren en OO programmeren
1.0.0
1.0.0
  • Welkom
  • Inleiding
    • Benodigdheden
    • Afspraken code
    • Afspraken oefeningen
    • Nuttige extras
    • Dankwoord
    • Mee helpen?
  • Semester 1: Programming Principles
    • H1: Werken met Visual Studio
      • Introductie tot C#
      • Visual Studio en .NET Core installeren
      • Een C# project maken in Visual Studio
      • Fouten in je code
      • Je eerste stappen in C#
      • Input/Output: ReadLine/WriteLine
      • Kleuren in Console
      • Oefeningen
    • H2: Variabelen en datatypes
      • De syntaxis van C#
      • Datatypes
      • Variabelen
      • Expressies en operators
      • Oefeningen
    • H3: Strings en hun methoden
      • Strings
      • Strings samenvoegen
      • Omzetten van en naar strings
      • Functionaliteit van strings
      • Oefeningen
    • H4: Beslissingen
      • Beslissingen intro
      • Enkelvoudige booleaanse expressies
      • If, else, else if
      • Samengestelde booleaanse expressies
      • Scope van variabelen
      • Oefeningen
    • H5: Loops
      • Loops intro
      • While en Do While
      • For
      • Debuggen
      • Oefeningen
    • H6: Arrays
      • Array principes
      • Alternatieve syntax
      • Werken met arrays
      • Defaultwaarden
      • List<T>
      • Oefeningen
    • H7: Methoden
      • Methoden intro
      • Parameters
      • Return waarden
      • Geavanceerde methoden
      • Oefeningen
    • Intermezzo: TextCell
    • H8: Numerieke data
      • De Math klasse
      • Random
      • Casting en conversie
      • Oefeningen
    • H9: Meerdimensionaal werken
      • N-dimensionale arrays
      • Geneste iteratie
      • Oefeningen
    • H10: Gevorderde tekstverwerking
      • Voorstelling van tekst
      • Interpolatie met formattering
      • Werken met arrays van strings
      • Input en output van tekstbestanden
      • Oefeningen
    • Afsluiter: TextCell2D
  • Semester 2 : OOP
    • H10: Klassen en objecten
      • OOP Intro
      • Klassen en objecten aanmaken
      • DateTime: leren werken met objecten
      • Enumeraties: nog een eigen datatype
      • Klassen en objecten weergeven deel 1
      • Attributen
      • Methoden
      • Access modifiers
      • Properties
      • Oefeningen
    • H11: Objecten (al dan niet) aanmaken
      • Constructors
      • Spelen met strings
      • Oefeningen
    • H12: Geheugenmanagement bij klassen
      • value en reference met eigen objecten
      • nullable value types
      • NullReference exception
      • Labo
    • H13: Datastructuren
      • Foreach en var
      • List
      • Dictionary
      • Immutable datastructuren
      • Verdere datastructuren
      • Labo
    • H14: Overerving
      • Overerving intro
      • Virtual en override
      • Abstract
      • Constructors bij overerving
      • Oefeningen
    • H15: Geavanceerde overerving
      • protected access modifier
      • Base keyword
      • System.Object
      • Labo
    • H16: Exception handling
      • Werken met exceptions
      • Zelf uitzonderingen maken
      • Wanneer exceptions en handling gebruiken
      • Labo
    • H17: polymorfisme en interfaces
      • Polymorfisme
      • Polymorfisme in de praktijk
      • Interfaces
      • Losse koppeling
      • Labo
  • Appendix
    • Visual Studio Tips & Tricks
    • Ea-ict coding guidelines
    • Oefeningen kerkhof
  • Semester 1 appendix
    • Nice to know stuff
      • Out en Ref parameters
      • Jagged arrays
    • All-In-Projecten
      • Overzicht
      • Console Matrix
      • Ascii filmpjes maken met loops
      • Ascii filmpjes maken met methoden
      • Fun with methods: een verhaalgenerator
      • Tekst-gebaseerd Maze game
      • Conway game of life
  • Semester 2 appendix
    • Operator overloading
    • Object Initializer Syntax
    • Compositie en aggregatie
    • Nice to know stuff
      • Klassen herbruiken
      • Expression bodied members
    • All-In-Projecten
      • Overzicht
      • OO Textbased Game
      • War Simulator
      • Map Maker
      • Magic The Gathering API
      • SchoolAdmin
  • Pro (geen leerstof en/of in opbouw)
    • Bitwise operators
    • Generics en collections
      • Generics methoden en types
      • Generic classes en constraints
      • Collections
      • Labo-oefeningen
    • Events
      • Events
      • Chat server
    • Software engineering
      • SOLID
Powered by GitBook
On this page
  • Itereren over een tweedimensionale array
  • Itereren met onderling afhankelijke indexen
  • Itereren zonder arrays

Was this helpful?

Export as PDF
  1. Semester 1: Programming Principles
  2. H9: Meerdimensionaal werken

Geneste iteratie

Itereren over een tweedimensionale array

Met meerdimensionale arrays kunnen we de richtingen los van elkaar bekijken. Bijvoorbeeld, om ons OXO-rooster af te printen (eerste rij op één regel, tweede rij op een volgende regel, derde rij op een derde regel), kunnen we dit doen:

public static void PrintRij(int rij, string[,] array) {
	for(int i = 0; i < array.getLength(1); i++) {
		Console.Write(array[rij,i]);
	}
	Console.WriteLine();
}

// ergens anders in de code
for(int rij = 0; rij < oxoRooster.GetLength(0); rij++) {
    PrintRij(rij,oxoRooster);
}

Als we het rooster in één dimensie zouden voorstellen met een variabele oxoArray, moesten we dit doen:

// na elementen met index 2, 5 en 8 moeten we een newline printen
for(int i = 0; i < oxoArray.Length; i++) {
    Console.Write(oxoArray[i]);
    // dit omvat meer rekenwerk
    // 3 is hier ook "hardgecodeerd" als lengte van een rij
    // dus als we de spelregels wijzigen (bv. OXOXO), werkt deze code niet meer
    if((i + 1) % 3 == 0) {
        Console.WriteLine();
    }
}

We hebben de tweedimensionale versie voor een beter inzicht met een hulpmethode gedaan. Dat hoeft niet, want je kan de inhoud van PrintRij ook rechtstreeks invullen. Dan krijg je een geneste lus:

// per rij doorlopen we de kolommen en printen we een newline
for(int rij = 0; rij < oxoRooster.GetLength(0); rij++) {
    // voor een kolom tonen we gewoon alle waarden
    for(int kolom = 0; kolom < oxoRooster.GetLength(1); kolom++) {
        Console.Write(oxoRooster[rij,kolom]);
    }
    Console.WriteLine();
}

In het begin kan deze structuur wat intimiderend zijn, maar er is niets nieuws aan deze luscode. Kijk eerst naar wat één uitvoering doet en zie dat als één geheel. Denk dan na over wat er gebeurt als je dat geheel herhaalt, zonder na te denken over hoe dat geheel werkt.

Itereren met onderling afhankelijke indexen

In het vorige voorbeeld toonden we per rij even veel symbolen. Dus de werking van PrintRij hing niet echt af van de kolom waarop we ons bevonden. Dat is niet altijd zo. Soms is er interactie tussen de tellers van de buitenste en de binnenste for-lus.

Volgend voorbeeld toont hoe je enkel een driehoekig deel van een rooster toont:

public static void PrintRij(int rij, string[,] array, int maxI) {
	for(int i = 0; i < array.getLength(1) && i <= maxI; i++) {
		Console.Write(array[rij,i]);
	}
	Console.WriteLine();
}

for(int rij = 0; rij < oxoRooster.GetLength(0); rij++) {
    PrintRij(rij,oxoRooster,rij); // print bv. 3 karakters van rij 3, 4 karakters van rij 4,...
}

Opnieuw kan je de lussen in elkaar schuiven:

for(int rij = 0; rij < oxoRooster.GetLength(0); rij++) {
    for(int kolom = 0; kolom < oxoRooster.GetLength(1) && kolom <= rij; kolom++) {
        Console.Write(oxoRooster[rij,kolom]);
    }
    Console.WriteLine();
}

En opnieuw hanteer je dezelfde denkwijze om hier uit wijs te raken. Kijk eerst naar wat in de lus staat. Zie rij gewoon als een getal dat bepaalt hoe veel karakters je maximum kan printen, zonder na te denken over hoe dat getal verandert. Pas als je de werking van de inhoud van de lus goed in je hoofd hebt, denk je na over wat er gebeurt als je die inhoud gaat herhalen met verschillende waarden voor rij.

Itereren zonder arrays

Geneste lussen komen vaak voor bij meerdimensionale arrays, maar dat is vooral omdat de twee technieken goed samen gaan. Er is geen verplichting om ze samen te gebruiken.

Je kan geneste lussen gebruiken voor allerlei taken waarbij je herhaling hebt op meerdere niveaus. Bijvoorbeeld voor volgende figuur:

1 
2 2 
3 3 3 
4 4 4 4 
5 5 5 5 5 

Hier zijn twee vormen van herhaling:

  • de herhaling die het snelst terugkeert, namelijk van links naar rechts (we printen een aantal keer hetzelfde getal)

  • de herhaling die minder vaak gebeurt, namelijk van boven naar onder (we printen een aantal keer een regel)

We denken eerst na over de herhaling die het snelst terugkeert. We kennen alles om een getal een aantal keer (gelijk aan zichzelf) te printen:

for (int i = 1; i <= getal; i++) {
  Console.Write($"{getal} ");
}

We kennen ook alles om een newline een aantal keer te printen:

for (int i = 1; i <= anderGetal; i++) {
  Console.WriteLine();
}

Om de twee lussen te combineren, moeten we vermijden dat we dezelfde naam i gebruiken, dus we hernoemen die van de binnenste herhaling naar j. En het aantal keer dat we een getal op een regel willen herhalen, is gelijk aan het nummer van die regel. Dan krijgen we dus:

for (int i = 1; i <= anderGetal; i++) {
  for (int j = 1; j <= i; j++) {
    Console.Write($"{i} ");
  }
  Console.WriteLine();
}
PreviousN-dimensionale arraysNextOefeningen

Last updated 3 years ago

Was this helpful?