Wees voorzichtig met het vergelijken van getallen in C++

C++ is een veelgebruikte programmeertaal, maar ook een waarin programmeerfouten het meest voorkomen. Veel van deze fouten zijn te wijten aan logische fouten. Met name fouten die tijdens vergelijkingen worden gemaakt, kunnen de nauwkeurigheid en betrouwbaarheid van uw code beïnvloeden.

De C++-taal heeft een bepaalde vergelijkingsfout die veel nieuwe ontwikkelaars over het hoofd zien. Deze fout is het gevolg van een onjuist begrip van hoe operators werken bij het uitvoeren van meerdere vergelijkingen. Ontdek hoe u deze veelgemaakte fout kunt vermijden en waarom deze in de eerste plaats voorkomt.

Vergelijkingen in C++

De programmeertaal C++ biedt veel verschillende functies en hulpmiddelen, samen met basisbewerkingen zoals vergelijkingsoperatoren. Vergelijkingsoperatoren zijn speciale bewerkingen in programmeertalen waarmee je gegevens met elkaar kunt vergelijken. Ontwikkelaars gebruiken deze operators vrij vaak, vooral bij het maken van algoritmen.

U kunt vergelijkingsoperatoren in veel verschillende voorbeelden in het dagelijks leven tegenkomen. Wanneer u bijvoorbeeld in de supermarkt winkelt, gebruikt u deze operatoren in gedachten om prijzen te vergelijken. Als de prijs van het ene product lager is dan het andere, kies je dat product.

U kunt vergelijkingsoperatoren zien in if-else verklaringen best vaak. Vergelijkingsoperatoren zijn de plek om te controleren of een waarde groter is dan, kleiner dan of gelijk is aan een andere waarde. Er is een heel klein maar belangrijk detail dat je niet over het hoofd mag zien. Resultaten van vergelijkingsuitdrukkingen retourneren waar of onwaar, dit zijn booleaanse waarden. Deze waarden zijn een van de basiscomponenten van de besturingsstructuur bij het programmeren.

In de programmeertaal C++ is bijvoorbeeld de "==" operator controleert of twee waarden gelijk zijn. Als de waarden gelijk zijn, retourneert het resultaat waar. Anders is het resultaat onwaar.

als (een == b)
{
opbrengstWAAR;
} 
anders
{
opbrengstvals;
}

Een voorbeeld van een vergelijkingsprobleem

Een van de veelgemaakte fouten die C++-beginners maken, is het gebruik van vergelijkingsoperatoren. Met deze operators kunnen programmeurs twee waarden vergelijken en verschillende bewerkingen uitvoeren op basis van het resultaat van die vergelijking. Het onjuist gebruiken van deze operatoren kan echter onverwachte fouten veroorzaken.

Hoewel bijvoorbeeld de uitdrukking 3 < 15 < 10 wiskundig onjuist is, beschouwt C++ het resultaat ervan als waar. U kunt dit aantonen door het volgende eenvoudige testprogramma te schrijven.

Maak eerst een bestand met de naam test.cpp. Open dit bestand met uw favoriete code-editor en voeg de volgende code eraan toe.

#erbij betrekken
int een = 15;
intvoornaamst()
{
als (3 < een < 10)
 {
soa::cout << "foe" << soa::eindel;
 }
anders
 {
soa::cout << "boe" << soa::eindel;
 }
opbrengst0;
}

U kunt deze opdracht gebruiken om de code te compileren en uit te voeren:

g++ test.cpp -o Test

Je hebt nu een programma genaamd Test. Voer het programma uit en onderzoek de uitvoer.

C++ beschouwde 3 < 15 < 10 als waar bij het uitvoeren van dit programma. Waarom zou het resultaat op deze manier uitkomen, ook al is het een wiskundig onjuiste bewering?

Oorzaken van het vergelijkingsprobleem in C++

Zoals de meeste programmeertalen, leest C++ code van links naar rechts. Elke vergelijkingsoperator produceert een booleaanse waarde. Booleaanse waarden betekenen niet alleen waar en onwaar; ze hebben een wiskundig equivalent.

Het werkingsprincipe van een computer is afhankelijk van enen en nullen. Voor een computer is het resultaat van iets waar of onwaar. Computerprogramma's behandelen het getal 1 meestal als waar en het getal 0 als onwaar.

Bekijk het vergelijkingsprobleem opnieuw en lees de stelling van links naar rechts; je zult zien dat er twee verschillende vergelijkingen zijn. De eerste vergelijking is tussen de nummers 3 en 15. Dit is een echte waarde omdat 3 kleiner is dan 15.

De tweede vergelijking is tussen dat resultaat en het getal 10. Omdat het een numerieke vergelijking moet uitvoeren, converteert C++ de booleaanse waarde in stilte naar 1. 1 is minder dan 10, dus het algehele resultaat is waar.

Concluderend, hoewel het een wiskundige misvatting lijkt, is deze bewering waar voor C++ en computers.

Hoe vergelijkingsproblemen in C ++ op te lossen

C++ gebruikt, samen met de meeste andere programmeertalen, een andere syntaxis voor logische vergelijking dan traditionele wiskunde. De wiskundige uitdrukking 3 < a < 15 betekent “3 is kleiner dan a En a is minder dan 15.” Zoals je hebt gezien, interpreteert C++ die uitdrukking echter anders.

Gebruik de operator && om en in C++ weer te geven. U kunt vervolgens booleaanse uitdrukkingen aan elkaar koppelen en logica bouwen met behulp van operatoren zoals && om EN te vertegenwoordigen, || om OR, en te vertegenwoordigen ! om NIET te vertegenwoordigen. Talen zoals Java gebruikt dezelfde logische operatoren.

Met de juiste logische operator kunt u de bug in het eerdere voorbeeld oplossen:

#erbij betrekken
int een = 15;
intvoornaamst()
{
als (3 < een && een < 10)
 {
soa::cout << "foe" << soa::eindel;
 }
anders
 {
soa::cout << "boe" << soa::eindel;
 }
opbrengst0;
}

Nu zal deze code testen of de waarde a groter is dan 3 en of de waarde a kleiner is dan 10. Compileer en voer het programma uit en observeer het resultaat.

In het vorige voorbeeld werd 'foo' afgedrukt, maar het programma drukt nu 'boo' af zoals bedoeld. De booleaanse waarde van de linkerkant van de vergelijking (3 < a) is waar. De waarde van de rechterkant (a < 10) is onwaar. Sinds goed en fout is altijd vals, evalueert de algehele expressie naar false, zodat de voorwaarde mislukt en de anders blok loopt.

Probeer de AND om te wisselen (&&) operator naar een OR (||) en het verschillende resultaat observeren.

Het belang van logische controles in C++

Logische vergelijkingen in C++ omvatten het gebruik van booleaanse waarden en vergelijkingsoperatoren. Zorg ervoor dat u de juiste booleaanse waarden en vergelijkingsoperatoren gebruikt om de werking van uw programma's te controleren. Het kan moeilijk zijn om slecht gevormde expressies te herkennen, omdat C++ vaak ander gedrag vertoont dan volledig te mislukken.

Nu weet je hoe compilers dit probleem negeren en elke vergelijking behandelen als een boolean bij het lezen van links naar rechts. Pas op voor dit probleem in elke taal die u gebruikt en leer de effecten ervan te herkennen, zodat u een stap voor kunt blijven.