Lecture Notes for Advanced Programming II

3 April 2003 - A Cautionary Tale

It Began Innocently Enough

• Why does this code compile?

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

• After all, this code doesn't compile.

  $ 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.
  
  $ 
  

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.

Let's See

$ 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.

  int main() {
    event e;
    }
  

  or, more generally,

  event * ep = new event();
  
  event e1 = *ep;  // copy
  e = *ep;         // assignment
  

• This is the best solution.

  • What doesn't exist can't cause problems.

Use a Conversion Function

• 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.

• This works better when replacing conversion operators.

The explicit Fix

• Use the explicit keyword.

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

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

The Real Problem

• All of these solutions (except the first) create garbage.

  event e = new event();
  
  event e = (new event())->from_pointer();
  
  event e = event(new event());
  

  Where does the pointer go after conversion?

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?

  • Your code is talking about you.

• Dynamic memory is not your friend - make sure you need 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.

This page last modified on 10 April 2003.