Lecture Notes for Advanced Programming II

4 December 2001 - A Cautionary Tale

It Began Innocently Enough

• Why does this code compile?

  $ cat t.cc
  class event {
  
    public:
  
      event() { /* whatever */ }
  
      // whatever
    };
  
  int main() {
    event e = new event();
    }
  
  $ CC -c t.cc
  
  $
  

• After all, this code doesn't compile.

  cl cat bad.cc
  int main() {
    double d = new double(3.1415);
    }
  
  $ CC -c bad.cc
  "bad.cc", line 2: Error: Cannot use double* to initialize double.
  1 Error(s) detected.
  
  $ 
  

What's Going On?

• How can the compiler assign a pointer to T to a T value?

• It can't, unless T's an int, or there's a conversion.

• T isn't an int, so there must be a conversion. But where?

• Where can you define conversions? In the event class.

  Sure enough:

  event::event(event * ep) { /* whatever */ }
  

• What's going on.

  1. new event() calls the default constructor,
     returning a pointer.

  2. Convert the event * to an event and do the initialization.

• Check

  cl cat t.cc
  class event {
    public:
      event() { cerr << "default\n"; }
      event(event *) { cerr << "conversion\n"; }
      event(const event &) { cerr << "copy\n"; }
    };
  
  int main() {
    event e = new event();
    }
  
  $ CC -o t t.cc
  
  $ ./t
  default
  conversion
  
  $
  

What're The Fixes?

• Delete the conversion constructor.

  • Just do

    int main() {
      event e;
      }
    

    or, more generally,

    event e1 = *ep;  // copy
    e = *ep;         // assignment
    

  • This is the best solution.

• Define a conversion function.

  $ cat t.cc
  class event {
    public:
      event from_pointer(void) {
        return *this;
        }
      string to_string(void) {
        // whatever
        }
    };
  
  int main() {
    event e = (new event())->from_pointer();
    cout << e.to_string() << "\n";
    }
  
  $ CC -c t.cc
  
  $ 
  

  Important: this fix doesn't fix the real problem.

  Works better when replacing conversion operators.

What're The Fixes? (Continued)

• Use the explicit keyword.

  $ cat t.cc
  class event {
    public:
    
      // whatever
  
      explicit event(event *) { /* whatever */ }
  
      // whatever
    };
  
  
  int main() {
    event e1 = new event();                     // bad
    event e2 = event(new event());              // works, but bad
    event e3 = static_cast<event>(new event()); // works, but bad
    }
  
  $ CC -c t.cc
  "t.cc", line 24: Error: Cannot use event* to initialize event.
  1 Error(s) detected.
  
  $ 
  

  Important: this fix doesn't fix the real problem.

Lessons to Learn

• Know what you're doing.

  • event e = new event(); is dumb code.

  • It's also bad code: what happens to the pointer?

  • Use the const modifier on pointer and reference arguments.

  • Your code is talking about you.

• Dynamic memory is not your friend.

  • Make sure you really need to use it.

• Don't define conversions.

  • They may be handy, but they're definitely dangerous.

  • Instead, define functions that convert.

• Make conversion constructors visible and explicit.

  • Not as convenient, but much safer.

  • Compilers are complicated, c++ is complicated,
    c++ compilers are deadly.

• Implement the normal conversions.

  • Converting from T* to T is not normal.

  • Implement conversions, not other functions.

  • Prevents surprises, aids in understanding.

This page last modified on 6 December 2001.