CKTIS / C++
Opteloperator +
De binaire operator + telt getallen op of verplaatst een pointer met een geheel aantal elementen. Lees meer over typeconversies, grenzen van pointerrekenen en risico’s op overflow.
Versie: C++23; repository compiler flag, production runtime not attested
Syntax
a + bDe ingebouwde binaire operator + in de expressie a + b berekent de som van numerieke waarden; de operator wijzigt de operanden zelf niet. De gebruikelijke rekenkundige conversies bepalen een gemeenschappelijk type voor de operanden en het resultaat: 7 + 0.5 heeft bijvoorbeeld het type double en de waarde 7.5. Kleine integertypen worden gepromoveerd, zodat het optellen van twee short-waarden een resultaat van het type int oplevert.
Additieve operatoren worden van links naar rechts gegroepeerd: a + b + c betekent (a + b) + c. Vermenigvuldiging heeft een hogere prioriteit, dus a + b * c betekent a + (b * c). De groepering bepaalt niet in welke volgorde de operanden worden geëvalueerd. Overflow van een resultaat van een signed integertype leidt tot ongedefinieerd gedrag. Berekeningen met een unsigned integerresultaat werken modulo 2^N, waarbij N de breedte van dat type is; bij het mengen van signed en unsigned typen is voorzichtigheid met conversies nodig.
Voor een pointer p naar een arrayelement en een integer n verplaatsen zowel p + n als n + p de pointer met n elementen, niet bytes. Het type waarnaar p wijst, moet een volledig objecttype zijn en moet soortgelijk zijn aan het elementtype van de array. Wijst p naar een element van een met extern gedeclareerde array waarvan het elementtype op de plaats van de optelling nog onvolledig is, dan is p + 1 niet welgevormd, ook als het type waarnaar p wijst en het elementtype identiek zijn. Het resultaat moet wijzen naar een element van dezelfde array of naar de positie direct na het einde ervan; die laatste positie mag niet worden gedereferentieerd. Een verplaatsing buiten dit bereik of het gebruik van een pointer naar een type dat niet soortgelijk is aan het elementtype leidt tot ongedefinieerd gedrag. Tel je bijvoorbeeld 1 op bij een unsigned int* die naar een element van een array van het type int[] wijst, dan is het gedrag ongedefinieerd, ook als het volgende element binnen de array valt. Twee pointers optellen is niet toegestaan.
Unair +a is een afzonderlijke operator, geen optelling van twee waarden. Door de gebruiker gedefinieerde typen kunnen operator+ definiëren; het gedrag daarvan hangt af van de gekozen overload. De bovenstaande regels beschrijven de ingebouwde operator. Het voorbeeld laat een som van integers, een som van het type double, een pointerverplaatsing en de ongewijzigde waarden van a en b zien. De genoemde bron is een voortdurend bijgewerkt werkdocument, geen vastgelegde C++23-tekst.
Voorbeelden
#include <iostream>
int main() {
int a = 7;
int b = 5;
int values[] = {10, 20, 30};
int* p = values;
std::cout << a + b << '\n';
std::cout << a + 0.5 << '\n';
std::cout << *(p + 1) << '\n';
std::cout << a << ' ' << b << '\n';
}
Resultaat
12 7.5 20 7 5
De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.