Omschrijving
In Arduino C++ zijn operators speciale tekens die je helpen bij taken zoals rekenen en vergelijken. Je hebt rekenkundige operators zoals ‘+’, ‘-‘, ‘*’, en ‘/’ voor wiskundige berekeningen. Vergelijkingsoperators zoals ‘==’, ‘!=’, ‘>’, en ‘<‘ controleren of waarden gelijk zijn of hoe ze zich tot elkaar verhouden. Logische operators zoals ‘!’, ‘&&’, en ‘||’ voeren logische bewerkingen uit. Met deze operators wordt het makkelijker om berekeningen en vergelijkingen in je code uit te voeren, zodat je programma precies doet wat je wilt. Hier bekijken we de samengestelde toewijzingsoperatoren. Deze zijn vergelijkbaar met de rekenkundige operators, maar compacter. Er zijn er 10, maar we gaan er voor nu 7 bekijken.

Samengestelde toewijzingsoperatoren zijn speciale tekens in programmeertalen die je helpen om snel en efficiënt wiskundige bewerkingen uit te voeren en de resultaten op te slaan in variabelen.

1. += (samengestelde optelling):
   • Voegt een waarde toe aan een variabele en slaat het resultaat op in dezelfde variabele.
   • Voorbeeld:
     Als x gelijk is aan 10 en je schrijft ‘x += 5’, dan wordt x nu 15.
     De lange versie zou zijn: ‘x = x + 5’
2. -= (samengestelde aftrekking):
   • Trekt een waarde af van een variabele en slaat het resultaat op in dezelfde variabele.
   • Voorbeeld:
     Als y gelijk is aan 20 en je schrijft ‘y -= 4’, dan wordt y nu 16.
     De lange versie zou zijn: ‘x = x – 4’
3. *= (samengestelde vermenigvuldiging):
   • Vermenigvuldigt een variabele met een waarde en slaat het resultaat op in dezelfde variabele.
   • Voorbeeld:
     Als z gelijk is aan 3 en je schrijft ‘z *= 2’, dan wordt z nu 6.
     De lange versie zou zijn: ‘z = z * 6’
4. /= (samengestelde deling):
   • Deelt een variabele door een waarde en slaat het resultaat op in dezelfde variabele.
     Als de resultaat variabele (a) een int is, gaat een deel verloren. Alleen het gedeelte van het gehele deel van het getal wordt opgeslagen.
   • Voorbeeld:
     • Als a een integer is, dus ‘int a = 14’.
       Als a gelijk is aan 14 en je schrijft ‘a /= 4’, dan wordt a nu 3.
       De lange versie zou zijn: ‘a = a / 4’
     • Als a een float is, dus float a =14.
       Als a gelijk is aan 14 en je schrijft ‘a /= 4’, dan wordt a nu 3,5.
       De lange versie zou zijn: ‘a = a / 4’
       
5. %= (samengestelde modulo):
   • Berekent de rest van de deling uit, van een variabele die gedeeld wordt door een waarde en slaat het resultaat op in dezelfde variabele.
   • Voorbeeld:
     Als b gelijk is aan 7 en je schrijft ‘b %= 3’, dan wordt b nu 1.
     3 zit 2 keer in 7 (dit is 6), dus houd je 1 over (dit is de rest).
     De lange versie zou zijn: ‘b = b % 3’
6. — (decrement):
   • Verlaagt de waarde van een variabele met 1.
   • Voorbeeld:
     Als count gelijk is aan 5 en je schrijft ‘count–‘, dan wordt count nu 4.
     De lange versie zou zijn: ‘count = count – 1’
7. ++ (increment):
   • Verhoogt de waarde van een variabele met 1.
   • Voorbeeld:
     Als score gelijk is aan 8 en je schrijft ‘score++’, dan wordt score nu 9.
     De lange versie zou zijn: ‘score = score +1’

Wat is pre-increment/post-increment en pre-decrement/post-decrement:

Pre-increment en post-increment, evenals pre-decrement en post-decrement, zijn manieren om een getal in programmeertalen zoals C++ te verhogen (incrementeren) of te verlagen (decrementeren). Bij pre-increment wordt het getal eerst verhoogd voordat het in een berekening wordt gebruikt, bijvoorbeeld ‘++x’. Bij post-increment wordt het getal eerst gebruikt in een berekening en daarna verhoogd, bijvoorbeeld ‘x++’. Hetzelfde geldt voor pre-decrement (–x) en post-decrement (x–), waarbij ‘–x’ eerst verlaagt en dan gebruikt, en ‘x–‘ eerst gebruikt en dan verlaagt. Deze operatoren zijn handig bij het tellen of bij lussen in programma’s.

• Pre-increment (++) en pre-decrement (–): Eerst wordt de waarde van de variabele verhoogd of verlaagd, en daarna wordt deze nieuwe waarde gebruikt in de rest van de uitdrukking. Voorbeeld:

  int x = 5;
  int result = ++x; // result wordt 6, x wordt 6

• Post-increment (++) en post-decrement (–): Eerst wordt de huidige waarde van de variabele gebruikt in de rest van de uitdrukking, en daarna wordt de waarde van de variabele verhoogd of verlaagd. Voorbeeld:

  int y = 5;
  int result = y++; // result wordt 5, y wordt 6

Deze operatoren zijn handig bij het schrijven van code omdat ze je helpen om sneller en efficiënter basis-wiskundige bewerkingen uit te voeren en variabelen te wijzigen.

Voorbeeld
Een veel gebruikte situatie de for-lus:

int ledPin = 13;  // Verbind de LED met pin 13

void setup() {
  pinMode(ledPin, OUTPUT);  // Stel de LED-pin in als uitgang
}

void loop() {
  for (int i = 0; i < 15; i++) {
    digitalWrite(ledPin, HIGH);  // Zet de LED aan
    delay(500);                  // Wacht 500 milliseconden
    digitalWrite(ledPin, LOW);   // Zet de LED uit
    delay(500);                  // Wacht 500 milliseconden
  }
  
  // Als de loop is voltooid, wacht het programma 10 seconden en begint weer opnieuw op regel 7.
  delay(10000); // wacht 10 seconden
}

Hier gebruiken we het ‘++’ teken om x elke keer met 1 te verhogen.

Omschrijving
In Arduino C++ zijn operators speciale tekens die je helpen bij taken zoals rekenen en vergelijken. Je hebt rekenkundige operators zoals ‘+’, ‘-‘, ‘*’, en ‘/’ voor wiskundige berekeningen. Vergelijkingsoperators zoals ‘==’, ‘!=’, ‘>’, en ‘<‘ checken of dingen gelijk zijn of hoe ze zich tot elkaar verhouden. Logische operators zoals ‘!’, ‘&&’, en ‘||’ voeren logische bewerkingen uit. Met deze operators wordt het makkelijker om berekeningen en vergelijkingen in je code te doen, zodat je programma precies doet wat je wilt. Hier bekijken we de Vergelijkingsoperatoren.

Vergelijkingsoperatoren in Arduino C++ zijn speciale tekens die je kunt gebruiken om dingen met elkaar te vergelijken. Ze helpen je om te kijken of iets waar is of niet waar is in je programma. Hier zijn de belangrijkste:

1. Gelijk aan
   ‘==’ (twee gelijke tekens naast elkaar). Dit gebruik je om te kijken of twee dingen precies hetzelfde zijn.
   • Bijvoorbeeld: ‘if (leeftijd == 10)’ betekent “als de leeftijd precies 10 is”.
2. Niet gelijk aan
   ‘!=’ (uitroepteken en gelijkteken naast elkaar). Hiermee kijk je of twee dingen niet hetzelfde zijn.
   • Bijvoorbeeld: ‘if (kamer != “slaapkamer”)’ betekent “als de kamer niet de slaapkamer is”.
3. Kleiner dan
   ‘<‘ (kleiner teken). Dit gebruik je om te zien of iets kleiner is dan iets anders.
   • Bijvoorbeeld: ‘if (aantalAppels < 5)’ betekent “als het aantal appels minder dan 5 is”.
4. Kleiner dan of gelijk aan
   ‘<=’ (kleiner teken en gelijkteken naast elkaar). Hiermee kijk je of iets kleiner is dan of gelijk aan iets anders.
   • Bijvoorbeeld: ‘if (temperatuur <= 25)’ betekent “als de temperatuur 25 graden of minder is”.
5. Groter dan
   ‘>’ (groter teken). Dit gebruik je om te kijken of iets groter is dan iets anders.
   • Bijvoorbeeld: ‘if (tijd > 12)’ betekent “als de tijd groter is dan 12 uur”.
6. Groter dan of gelijk aan
   ‘>=’ (groter teken en gelijkteken naast elkaar). Hiermee kijk je of iets groter is dan of gelijk aan iets anders.
   • Bijvoorbeeld: ‘if (punten >= 100)’ betekent “als het aantal punten 100 of meer is”.

Waarom zijn Vergelijkingsoperatoren Handig?

• Ze helpen je om beslissingen te nemen in je programma’s, zoals of je een lampje moet aanzetten als het donker is, of een bericht moet laten zien als iemand iets goed heeft gedaan.
• Vergelijkingsoperatoren maken het makkelijker om te bepalen wat er moet gebeuren op basis van wat er gebeurt in je programma.

Voorbeeld
Stel je voor dat je een programma hebt dat controleert of het buiten regent. Je zou het kunnen schrijven als:

int regenSensor = 1;  // Stel in dat er regen is (1 betekent ja, 0 betekent nee)

if (regenSensor == 1) {
  Serial.println("Het regent buiten! Neem je paraplu mee.");
} else {
  Serial.println("Het regent niet buiten. Je kunt zonder paraplu gaan.");
}

Hier gebruiken we het ‘==’ teken om te kijken of regenSensor gelijk is aan 1. Als dat zo is, printen we een bericht om te zeggen dat het regent. Anders, als regenSensor niet gelijk is aan 1 (wat zou betekenen dat het niet regent), printen we een ander bericht.

Vergelijkingsoperatoren maken programmeren leuk omdat ze je helpen om je programma’s te laten weten wat ze moeten doen, net zoals je beslissingen maakt in het dagelijks leven!

Omschrijving
In Arduino C++ zijn operators speciale tekens die je helpen bij taken zoals rekenen en vergelijken. Je hebt rekenkundige operators zoals ‘+’, ‘-‘, ‘*’, en ‘/’ voor wiskundige berekeningen. Vergelijkingsoperators zoals ‘==’, ‘!=’, ‘>’, en ‘<‘ checken of dingen gelijk zijn of hoe ze zich tot elkaar verhouden. Logische operators zoals ‘!’, ‘&&’, en ‘||’ voeren logische bewerkingen uit. Met deze operators wordt het makkelijker om berekeningen en vergelijkingen in je code te doen, zodat je programma precies doet wat je wilt. Hier bekijken we de rekenkundige operators.

Rekenkundige operators
Dit zijn speciale tekens in programma’s waarmee je wiskundige berekeningen kunt doen. Hier zijn wat voorbeelden:

1. Optellen (+): Met dit teken tel je twee getallen bij elkaar op. Bijvoorbeeld, 3 + 5 = 8.
2. Aftrekken (-): Met dit teken trek je het ene getal van het andere af. Bijvoorbeeld, 7 – 4 = 3.
3. Vermenigvuldigen (*): Met dit teken vermenigvuldig je twee getallen met elkaar. Bijvoorbeeld, 2 * 6 = 12.
4. Delen (/): Met dit teken deel je het ene getal door het andere. Bijvoorbeeld, 10 / 2 = 5.

Deze tekens maken het makkelijker om ingewikkelde berekeningen te doen in je programma’s, net zoals je op een rekenmachine zou doen!

Volgorde van rekenkundige operators
Het is ook belangrijk om te weten dat de volgorde waarin je deze tekens gebruikt, de uitkomst van je berekeningen kan veranderen:

1. Haakjes: Berekeningen tussen haakjes worden altijd als eerste gedaan. Bijvoorbeeld, in ‘(4 + 5) * 3’ reken je eerst ‘4 + 5’ uit tot ‘9’, en dan ‘9 * 3′, wat ’27’ oplevert.
2. Vermenigvuldigen en delen: Deze worden eerst gedaan voordat je optellen en aftrekken doet. Bijvoorbeeld, in ‘4 + 5 * 3’, eerst ‘5 * 3’ uitrekenen geeft 15, en dan ‘4 + 15′ geeft ’19’.
3. Optellen en aftrekken: Deze worden van links naar rechts uitgevoerd als er geen haakjes zijn. Bijvoorbeeld, in ’10 – 3 + 2′, eerst ’10 – 3′ geeft ‘7’, en dan ‘7 + 2’ geeft ‘9’.

Deze regels zorgen ervoor dat je de juiste antwoorden krijgt in je berekeningen, net zoals bij het gebruik van een rekenmachine!

Als een berekening ingewikkelder wordt, maak dan gebruik van haken. Dit vereenvoudigt de berekening, maakt hem overzichtelijker en zodoende minder fout gevoelig.

Voorbeeld
Bijvoorbeeld ‘x = 5 + 16 * 3 / 3 – 2’, wat is de waarde van x nu?

Om de waarde van ( x ) te vinden in de berekening ( x = 5 + 16 * 3 / 3 – 2 ), moeten we de volgorde van de rekenkundige operatoren volgen:

1. Eerst wordt vermenigvuldigen en delen uitgevoerd van links naar rechts:

• ( 16 * 3 / 3 )
• ( 16 * 3 = 48 )
• ( 48 / 3 = 16 )

1. Vervolgens wordt optellen en aftrekken van links naar rechts uitgevoerd:

• ( 5 + 16 = 21 )
• ( 21 – 2 = 19 )

Dus, ( x = 19 ).

Verklaring:

• Eerst wordt ( 16 * 3 = 48 ) berekend.
• Vervolgens wordt ( 48 / 3 = 16 ).
• Dan wordt ( 5 + 16 = 21 ) berekend.
• Tot slot wordt ( 21 – 2 = 19 ).

De volgorde van bewerkingen wordt bepaald door de rekenkundige regels waarbij vermenigvuldigen en delen voorrang hebben op optellen en aftrekken, en bewerkingen van links naar rechts worden uitgevoerd als ze dezelfde prioriteit hebben.