{"id":870,"date":"2024-02-02T19:45:13","date_gmt":"2024-02-02T19:45:13","guid":{"rendered":"http:\/\/int03.co.uk\/blog\/?p=870"},"modified":"2024-02-02T20:25:44","modified_gmt":"2024-02-02T20:25:44","slug":"c-17-if-statement-gotchas","status":"publish","type":"post","link":"https:\/\/int03.co.uk\/blog\/2024\/02\/02\/c-17-if-statement-gotchas\/","title":{"rendered":"C++ 17 if statement gotchas"},"content":{"rendered":"\n

C++17 added a useful extension to the if-statement syntax, by making it possible to include initialisation inside the if-statement. This is called “if statement with initializer”. You can use it like this:<\/p>\n\n\n\n

<\/path><\/path><\/svg><\/span>
if<\/span> (<\/span>int<\/span> spuds = <\/span>getNumberOfSpuds<\/span>()) {<\/span><\/span>\n    <\/span>bakeSpuds<\/span>(spuds);<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
<\/p>\n\n\n\n
Providing spuds != 0 it will obligingly bake them for us (in fact, it will even bake negative spuds… very handy in the current financial climate). Better yet, you can also add a condition, like this:<\/p>\n\n\n\n
<\/path><\/path><\/svg><\/span>
if<\/span> (<\/span>int<\/span> spuds = <\/span>getNumberOfSpuds<\/span>(); spuds > <\/span>10<\/span>) {<\/span><\/span>\n    <\/span>std<\/span>::cout << <\/span>"we have plenty of spuds"<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n} <\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
<\/p>\n\n\n\n
This is often used to check pointers before dereferencing them:<\/p>\n\n\n\n
<\/path><\/path><\/svg><\/span>
if<\/span> (<\/span>auto<\/span>* car = <\/span>getCar<\/span>()) {<\/span><\/span>\n    <\/span>car<\/span>-><\/span>setHandbrake<\/span>(<\/span>true<\/span>);<\/span><\/span>\n    <\/span>car<\/span>-><\/span>setSteeringAngle<\/span>(<\/span>70.f<\/span>);<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
<\/p>\n\n\n\n
Obviously these are very useful features, as it brings the variable instantiation into the scope of the if-statement and makes for neater code. We love it and use it a lot!<\/p>\n\n\n\n
Unfortunately, this also seems to have led to a common misconception in how the condition can be used. In working on some fairly large C++ projects, we found quite a few instances of this type of code:<\/p>\n\n\n\n
<\/path><\/path><\/svg><\/span>
if<\/span> (<\/span>auto<\/span>* car = <\/span>getCar<\/span>(); <\/span>car<\/span>-><\/span>hasWheels<\/span>()) {<\/span><\/span>\n    \/\/ DANGER: if car is nullptr, will dereference nullptr<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
<\/p>\n\n\n\n
The intent of this code is obvious: the developer clearly expected it to only execute the condition if car != nullptr. Essentially, they expected <\/em>it to check that car != nullptr, then execute the condition, and only enter the if-statement if car is valid, and the car has wheels. However, it doesn’t work like that. It will always execute the condition and will dereference the car pointer, regardless of whether it is nullptr or not, so this code is quite likely to crash<\/strong>.<\/p>\n\n\n\n
Usually this is fairly easily fixed by doing something like this:<\/p>\n\n\n\n
<\/path><\/path><\/svg><\/span>
if<\/span> (<\/span>auto<\/span>* car = <\/span>getCar<\/span>(); car && <\/span>car<\/span>-><\/span>hasWheels<\/span>()) {<\/span><\/span>\n    <\/span>std<\/span>::cout << <\/span>"we have a car, and it has wheels"<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
<\/p>\n\n\n\n
But the really nasty thing about buggy code like this is that it can often appear <\/em>to work fine, until one day it blows up. This can lead to really nasty intermittent bugs, which are exceedingly hard to debug. Worse still, static code analysis tools might not spot this issue, and we had obviously missed some of these in code reviews also. If you suspect bugs like this are present, it’s also quite hard to grep your code base to find them. For example: searching for lines containing “if” and a semicolon will bring up a huge number of hits, which have to be searched manually. This makes it especially important not to introduce them in the first place \ud83d\ude42<\/p>\n\n\n\n
Here’s an example of some such code which appears to work (at least, it doesn’t crash), but is obviously not correct:<\/p>\n\n\n\n
<\/path><\/path><\/svg><\/span>
struct<\/span> <\/span>Car<\/span> {<\/span><\/span>\n    <\/span>bool<\/span> <\/span>hasWheels<\/span>() {<\/span><\/span>\n        <\/span>return<\/span> <\/span>true<\/span>;<\/span><\/span>\n    }<\/span><\/span>\n};<\/span><\/span>\n<\/span>\nCar* nullCar = <\/span>nullptr<\/span>;<\/span><\/span>\n<\/span>\nif<\/span> (<\/span>auto<\/span>* car = nullCar) {<\/span><\/span>\n    <\/span>std<\/span>::cout << <\/span>"we have a car"<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nif<\/span> (<\/span>auto<\/span>* car = nullCar; <\/span>car<\/span>-><\/span>hasWheels<\/span>()) {<\/span><\/span>\n    <\/span>std<\/span>::cout << <\/span>"car has wheels"<\/span> << <\/span>std<\/span>::endl;<\/span><\/span>\n    \/\/ Spoiler: this may be a lie<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
<\/p>\n\n\n\n
If you run this, it won’t<\/strong> output “we have a car”, but it probably will<\/strong> output “car has wheels”, even though car is nullptr. It does that because hasWheels is just returning a constant value, so the compiler doesn’t actually need to use our pointer. Although this is a somewhat contrived example (because our function could have been static, and we are using raw pointers etc), I hope it illustrates the point: that just because code appears to work when you test it, that doesn’t necessarily prove the code is correct.<\/p>\n\n\n\n
Another misconception I’ve seen in practice is when people put initialisation in both the initialisation and condition, assuming that the compiler will check both conditions (it doesn’t):<\/p>\n\n\n\n
<\/path><\/path><\/svg><\/span>
if<\/span> (<\/span>auto<\/span>* foo = <\/span>getFoo<\/span>(); <\/span>auto<\/span>* bar = <\/span>getBar<\/span>()) {<\/span><\/span>\n    \/\/ DANGER: if foo == nullptr and bar != nullptr<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
<\/p>\n\n\n\n
It will enter the if statement if bar != nullptr, even if foo == nullptr. For example, this code would result in a nullptr dereference, because it only cares whether the condition on the right hand side is true, and doesn’t care whether car is nullptr or not:<\/p>\n\n\n\n
<\/path><\/path><\/svg><\/span>
if<\/span> (<\/span>auto<\/span>* car = <\/span>nullptr<\/span>; <\/span>auto<\/span>* driver = <\/span>new<\/span> Driver) {<\/span><\/span>\n    \/\/ DANGER: if car == nullptr, it will dereference the nullptr<\/span><\/span>\n    <\/span>car<\/span>-><\/span>setDriver<\/span>(driver);<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
<\/p>\n\n\n\n
It’s worth saying that this code wasn’t introduced by inexperienced C++ developers. In fact, some of it was written by very capable, experienced and knowledgeable C++ developers, some with many years of experience. It just goes to show how easy it is to slip up and introduce this kind of bug. I suspect this is a fairly common issue, and something that it is useful to be aware of.<\/p>\n\n\n\n
Finally, if you want to search for this kind of issue in a large code base, it is somewhat possible by using regular expressions. For example, in Visual Studio’s “Find in Files” option, you can select “Use regular expressions”. To find lines that contain both “if” and a semicolon you can do something like this:<\/p>\n\n\n\n
if.*;<\/mark><\/code><\/p>\n\n\n\n
This expression should find lines that contain “if” and a semicolon, but the semicolon can’t be at the end of the line:<\/p>\n\n\n\n
\\bif\\b.*;(?!\\s*$)<\/mark><\/code><\/code><\/pre>\n\n\n\n
Don’t ask me about regular expressions, because I am no expert – just sharing one that worked for me \ud83d\ude42<\/p>\n\n\n\n
Either way, this will bring up a fairly long list of search results that you will have to sift through manually. All the more reason to take care not to introduce them in the first place…<\/p>\n","protected":false},"excerpt":{"rendered":"
C++17 added a useful extension to the if-statement syntax, by making it possible to include initialisation inside the if-statement. This is called “if statement with initializer”. You can use it like this: Providing spuds != 0 it will obligingly bake them for us (in fact, it will even bake negative spuds… very handy in the … Continue reading C++ 17 if statement gotchas<\/span><\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[],"_links":{"self":[{"href":"https:\/\/int03.co.uk\/blog\/wp-json\/wp\/v2\/posts\/870"}],"collection":[{"href":"https:\/\/int03.co.uk\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/int03.co.uk\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/int03.co.uk\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/int03.co.uk\/blog\/wp-json\/wp\/v2\/comments?post=870"}],"version-history":[{"count":12,"href":"https:\/\/int03.co.uk\/blog\/wp-json\/wp\/v2\/posts\/870\/revisions"}],"predecessor-version":[{"id":885,"href":"https:\/\/int03.co.uk\/blog\/wp-json\/wp\/v2\/posts\/870\/revisions\/885"}],"wp:attachment":[{"href":"https:\/\/int03.co.uk\/blog\/wp-json\/wp\/v2\/media?parent=870"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/int03.co.uk\/blog\/wp-json\/wp\/v2\/categories?post=870"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/int03.co.uk\/blog\/wp-json\/wp\/v2\/tags?post=870"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}