C++ (and a Few Java) Traps

What is a trap?

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

Example: Dupe of URL

What does this program do? (From Bloch and Gafter's Java Puzzlers)

public class BrowserTest {
   public static void main(String[] args) {
      System.out.print("iexplore:");
      http://www.google.com;
      System.out.println(":maximize");
   }
}

Does it even compile?
Yes
What is
```
      http: //www.google.com;
```
It's a label followed by a comment

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

A Super Trap

class Employee {
   string _name;
   string _dept;
public:
   Employee(string name, string dept);
   virtual void print() const { cout << _name << endl; }
   string dept() const;
};

class Manager : public Employee {
public:
   Manager(string name, string dept);
   virtual void print() const {
      print(); // print superclass
      cout << "Managing " << dept() << endl;
   }
};

print() does not print the superclass
Recursive call
Remedy: Employee::print()
In Java: super.print()

Super Trap Episode 2

class Employee {
   string _name;
   string _dept;
public:
   Employee(string name, string dept);
   virtual void print() const { cout << _name << endl; }
   string dept() const;
};

class Manager : public Employee {
public:
   Manager(string name, string dept);
   virtual void print() const {
      Employee:print(); // print superclass
      cout << "Managing " << dept() << endl;
   }
};

Did you spot the goto label?
```
Employee:print();
```
Still a recursive call

A Virtual Trap

class Shape {
   Color _color;
public:
   Shape() { reset(); }
   virtual void reset() { _color = BLACK; }
}; 

class Point : public Shape  {  
   double _x, _y;
public:
   void reset() {
      Shape::reset();
      _x = 0; _y = 0;
   }  
};

Why are points constructed with random coordinates?
The Point constructor calls the Shape constructor...
... which calls reset.
Which reset?
this->reset(), of course!
But...this has type Shape* since the Point hasn't yet been constructed...
...so it calls Shape::reset.

Virtual Trap Episode 2

class Employee {
   private String name;
   public Employee(String name) { 
      this.name = name; 
      System.out.println("Constructing " + this);
   }
   public String toString() { return name; }
}

class Manager extends Employee {
   private String dept;
   public Manager(String name, String dept) { 
      super(name);
      this.dept = dept; 
   }
   public String toString() { 
      return super.toString() + " " + dept.substring(0, 3); 
   }
}

Why does the program crash when constructing a Manager?
new Manager("...", "Sales") calls Employee("...")
... which calls toString in the print statement
... which calls Manager.toString
... even though the manager part has not yet been constructed
... and the call to dept.substring yield a NPE

A Constructive Trap

template<typename T> class Array {
public:
   Array(int size);
   T& operator[](int);
// ...
}; 

int main() {
   Array<double> a(10);
   a[0] = 0; a[1] = 1; a[2] = 4; 
   a[3] = 9; a[4] = 16;
   a[5] = 25; a = 36; a[7] = 49; 
   a[8] = 64; a[9] = 81;
   // ...
}

Why are some entries set to zero?
a[5] = 25; a = 36; a[7] = 49;
A one-arg constructor is also a type conversion!
```
a = Array<double>(36);
```

Constructive Trap Episode 2

template<typename T> class Array {
   T* _data;
   int _size;
public:
   explicit Array(int size) 
      :  _size(size), _data(new T(size)) {}
   T& operator[](int n) { return _data[n]; }
}

 main() {
   Array<double> a(10), b(10);
   for (int i = 0; i < 10; i ++) { a[i] = b[i] = i + 1; }
   for (int i = 0; i < 10; i ++) { cout << b[i] << " "; }
      // 5 6 7 8 9 10 7 8 9 10      
}

_data(new T(size)) // should have been new T[size]
Why did it compile???
new double(10) points to a single value (containing 1000)
There is no difference in C++ between a pointer to a value and a pointer to an array
Both are T*

A Collective Trap

List<Integer> nums = new ArrayList<>();
List<String> strings = new ArrayList<>();
for (int i = 1; i < 10; i++) { nums.add(i); strings.add("s" + i); }
strings.remove("s3");
nums.remove(3);

What is strings?
[s1, s2, s4, s5, s6, s7, s8, s9]
What is nums
[1, 2, 3, 5, 6, 7, 8, 9]
Why is 3 still in there?
Oh, it's the other remove method!

Collective Trap Episode 2

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

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);

The Big Three

What's wrong?

template<typename T> class Array {
   T* _data;
   int _size;
public:
   explicit Array(int size) 
      :  _size(size), _data(new T[size]) {}
   ~Array() { delete[] _data; }
   T& operator[](int n) { return _data[n]; }
};

Array<int> a(10);
Array<int> b(10);
a = b;
// b is destroyed, then a

What gets deleted twice?
What doesn't get deleted?
Need operator=
... and copy constructor
The Big 3: It's not just a good idea--it's the law (Marshall Cline)

The Big Two

What's wrong?

class Point {
  private int x;
  private int y;
  public Point(int x, int y) { this.x = x; this.y = y; }
  public boolean equals(Object other) {
    return x == ((Point) other).x && y == ((Point) other).y;
  }
}

Set<Point> points = new HashSet<>();
for (int i = 0; i < 1000; i++) points.add(new Point(i / 100, i % 10));

Adds 100 points, each ten times
But points.size() is 1000 (or close to it)
Always define hashCode when you define equals!

The Big One

You can convert a Manager* to an Employee*:

void layoff(Employee* e) { cout << e->name() << " is fired!"; }

What if you have more than one?

void fireThemAll(Employee es[], int n) {
    for (int i = 0; i < n; i++) { cout << e[i].name() << " is fired!"; }
}

Ok, let's call fire a whole bunch of managers:

Manager uselessMiddleManagers[10];
fireThemAll(uselessMiddleManagers, 10);

A Manager[] array can be converted to a Manager* (array-pointer duality)
A Manager* can be convered to a Employee* (superclass conversion)
Employee es[] is the same as Employee* (array-pointer duality)
The two conversions are fundamentally incompatible!

Conclusion

All languages have bad parts
Some have more than others
Some are more catastrophic than others
What you don't know can hurt you
It's better to know
Stay away from the bad parts
Stay away from languages with too many bad parts...
...unless the good parts outweigh the risk
Source code for all examples is here.