Traps in C and C++

Cover image

What is a Trap?

Code that compiles...
...links...
...executes...
...and does something different than you think.

An Example

What does this code do?
```
 if (-0.5 <= x <= 0.5) return 0;
```
It does not test whether -0.5 ≤ x ≤ 0.5
-0.5 <= x is a bool
... which is converted to 0 or 1 and then compared to 0.5
Blecch!

Why Study Traps?

To learn when to be careful...
...very careful.
To learn what to avoid...
...when using a language
...when selecting a language
...when designing a language

Warmup

What is the value of y?

x = 3;
p = &x;
y = x/*p /* p points to the denominator */ ;

Is the condition fulfilled?

int x = -2; // 0xFFFFFFFE
if (x & 0x8000000 != 0) /* x is negative */

What's with this?
```
if (a[i] > max);
   max = a[i];
```

Messy Modulus

What's wrong with this test?
```
if (x % 2 == 1) /* x is odd */
```
What if x is negative?
Then x % 2 is -1

What's wrong with this?

int degrees = ...;
degrees = degrees % 360; /* Normalize to 0...359 */

What if degrees is negative?

degrees = ((degrees % 360) + 360) % 360;

For hundreds of years, mathematicians knew how to do this right: a mathematical remainder is always positive

Variadic Functions

What does this print?
```
printf("%d %s", 0.5, "liter");
```
How about 4195812 \��
It gets worse:
```
int x, y;
scanf("%d %d", x, y);
```

Program run:

3 4
Erreur de segmentation (core dumped)

If you are lucky.
With modern compilers, you get warnings for these cases...
...because special knowledge about printf/scanf is hardwired
Other variadic functions don't have that protection.

Incomprehensible Declarations

An array of pointers: char* lines[10];
A pointer to an array of ten elements: char (*row)[10];
A pointer to a function: char* (*message)(int);
A function that (your guess is as good as mine):
```
void (*signal(int sig, void (*func)(int)))(int)
```
It makes no sense to put some parts of the type before, some after the variable

Pascal, a descendant of Algol, did this right:

lines: array[10] of ↑char;
row: ↑array[10] of char;
message: function (int) → ↑char;
signal: function(sig: int, func: function(int) → void)
  → (function(int) → void)

C. A. R. Hoare on Algol: "Here is a language so far ahead of its time that it was not only an improvement on its predecessors but also on nearly all its successors."

Pointers and Arrays

Swap adjacent elements

void swapNeighbors(int a[], int n) {
    for (int i = 0; i < n; i += 2)
        swap(a[i], a[i + 1]);
}

What if n was odd?
Then a[n - 1] was swapped with whatever happened to follow.
a is a pointer to the start of the array
It is not possible to know where the array ends
Remedy: Use vectors and at
Or, if you use [], use a debugging vector implementation such as this one

Dumbed-Down Collections

vector<int> a, b = ...;
int n = ...;
// Does b contain n?
vector<int>::iterator p = find(b.begin(), a.end(), n);
// If so, set to -1 and add to a
if (p != b.end()) { *p = -1; a.push_back(n); }

Dumps core (or worse)
It should have been b.end()
Nobody would do such a stupid mistake
I did...I copied and pasted code, and renamed most of the a to b
Why does find operate on two iterators instead of a vector???

So that you can use it with C arrays!

int a[] = ...;
int* p = find(a, a + size, n);

What's the Point?

A simple Point class with a constructor and default arguments

class Point {
    double _x, _y;
public:
    Point(double x = 0, double y = 0); // Sets _x to x, _y to y
    // ...
}; 

int main() {
    Point p(3, 4); 
    Point q(3); // (3, 0)
    Point o(); // (0, 0)
    ...
}

How many points were constructed?
Just two!
```
Point o();
```
is a function prototype!

What's the Point—Episode 2

A simple Point class with a constructor

class Point {
    double _x, _y;
public:
    Point(double x = 0, double y = 0); // Sets _x to x, _y to y
    void print() const
    // ...
}; 

int main() {
    double r = ..., theta = ...;
    Point p = (r * cos(theta), r * sin(theta));
    // ...
}

Does it set p to the point with polar coordinates r and theta?
Not actually...
p._y is always 0

Did you spot the comma operator?

Point p = (r * cos(theta), r * sin(theta));

Inheritance

A LabeledPoint is just like a Point, but it has a label.

class LabeledPoint : public Point {
    string label;
public:
    virtual void print() const;
}

void LabeledPoint::print() const {
    print(); // print base class to display x, y
    cout << label;
}

The comment is wrong—the call to print is recursive
Remedy: Point::print()

Inheritance—Second Try

Let's try this again:

void LabeledPoint::print() const {
    Point:print(); // print base class to display x, y
    cout << label;
}

It's still recursive!
Did you spot the goto label?
```
Point:print();
```

Point Pointers

You can convert a LabeledPoint* to a Point*:

void print2(Point* p, Point* q) { p->print(); q->print(); }
...
print2(new Point(3, 4), new LabeledPoint(0, 0, "origin"));

What if you have more than two?

void printAll(Point points[], int n) {
    for (int i = 0; i < n; i++) points[i].print();
}

Ok, let's call it:

LabeledPoint lps[10];
...
printAll(lps, 10);

A LabeledPoint array can be converted to a LabeledPoint* (array-pointer duality)
A LabeledPoint* can be convered to a Point* (base conversion)
The two conversions are fundamentally incompatible!

Conclusions

Syntax matters
Unchecked pointers are really dangerous
Pointer-array duality was a terrible idea
When using C++, avoid unsafe features
When using C, you must understand the mapping to the machine
C has its use cases. Use it when you profit from them.
C++ has its use cases. Use it when you profit from them.
Otherwise, look for safer alternatives.