Lecture Notes for CS 509, Advanced Programming II

2 April 2003, Classes and Conversions

Outline

• Conversions

• C++ casts old and new.

• New-style casts.

  • Static casts.

  • Constant casts.

  • Reinterpreting casts.

  • Dynamic casts.

• Classes and casts.

  • Converting to class values.

  • Casting From class types.

• User-defined conversions.

Type Matching

• Requiring exact type matches between values is a pain.

  double x = 0
  char d = '0' + i
  

  • Extra work for the programmer.

  • Picayune, especially among similar types.

  • But often important differences too.

• Most languages allow automatic translation between values similar types.

  • Known as conversions or (in C++ talk) casts.

  • Supports natural forms of expression.

  • But they still require that the programmer knows what's going on.

    • How is the conversion done?

    • When is the conversion done?

• Conversions can be a source of nasty compile- and run-time errors.

  • The compiler chooses conversions automatically and silently.

  • You had better agree with the compiler.

Conversions and Polymorphism

• Conversions are another form of polymorphism.

  • The difference between an int and a double may not be important (sometimes).

• Conversions are the weakest form of polymorphism.

  • Restricted to sets of similar types.

    • But what does "similar" mean?

  • Conversions are not universally applicable.

    • Sometimes the difference between an int and a double is important.

  • Conversions are not symmetric.

    • Converting from an int to a double is easier than converting from a double to an int.

• Heavy use of conversions may indicate bad design, bad programming, or both.

C++ Casts

• C++ has many ways to cast between values.

• The two casting families are old style and new style.

• Old-style casts maintain compatibility with C.

• The syntax is (target-type) value

    int i = (int) 1.0;
    

• Old-style casts are unobvious, brittle, and complicated.

  • Unobvious because it looks like much else in C++.

  • Brittle because it doesn't respond to changes well (non-portable).

  • Complicated because it's several casts in one.

  • Java programmers beware.

New-Style Casts

• New style casts break out the various kinds of old-style casts.

  • The new-style casts are all different and not compatible.

  • This can be a huge pain until you learn the differences.

• General syntax is conversion-kind<target-type>(source-value).

  int i = static_cast<int>(1.0);
  

  This is way ugly syntax, but logical within C++.

  • Template functions specifying return types.

• There are four new-style conversions:

  • Static casts for implicit conversions.

  • Constant casts for dealing with const and volatile.

  • Reinterpreting casts for converting pointers.

  • Dynamic casts for parent-to-child conversions.

Static Casts

• Static casts perform the usual implicit C++ casts.

  • A static cast between related values.

  • Between T* and void *, int and double, and so on.

• The syntax is static_cast<target-type>(val)

• Static casts can modify val.

  // expanding
  int i = static_cast<int>('c');
  
  // truncating
  char c = static_cast<char>(1024);
  
  // transforming
  string s = static_cast<string>("hello");
  

  You need to understand how the values are changed.

Constant Casts

• Constant casts remove const or volatile modifiers.

  • volatile is a hint to control compiler optimization.

• The syntax is const_cast<target-type>(val)

  from val type	to target-type
  const T *	T *
  const T &	T &
  const T	T &

• Examples.

  const int ci = 1;
  const int * cip = & i;
  const int & cir = i;
  
  int * ip = const_cast<int *>(ci);
  ip = const_cast<int *>(cip)
  ip = const_cast<int *>(cir);
  
  int & ir1 = const_cast<int &>(ci);
  int & ir2 = const_cast<int &>(cip);
  int & ir3 = const_cast<int &>(cir);
  

Const Cast Compiler Dependencies

• The pointer or reference returned refers to val.

  • The pointer or reference may not work

  • It depends on the compiler.

  • If val is in a read-only memory segment, the const cast is useless.

• Constant casts are a sign that your design or coding is bad.

Constant Cast Examples

• These are dirty tricks.

  void t(const int * ip, 
         const string & sr, 
         const vector<int> iv) {
  
    *(const_cast<int *>(ip)) = 3;
  
    const_cast<string &>(sr) = "hello";
  
    (const_cast<vector<int> &>(iv))[0] = 0;
    }
  

  These kinds of constant casts are almost always bad.

• Constant casts are usually used to modify constant objects.

  • Often needed for self-modifying data structures, or for performance measurements.

  bool C::find(int value) const {
    const_cast<C *>(this)->find_count++;
    return fnd(value);
    }
  

• Splay trees re-arrange themselves on every operation.

Reinterpreting Casts

• Reinterpret casts change pointer or reference interpretations.

• The syntax is reinterpret_cast<target-type>(val)

  • val and target-type are usually (but not always) reference or pointer types.

  int i = 1;
  int & ir = i;
  int * ip = &i;
  
  string & cr = reinterpret_cast<string &>(i);
  string * cp = reinterpret_cast<string *>(i);
  
  string & sr = reinterpret_cast<string &>(ir);
  string * sp = reinterpret_cast<string *>(ir);
    
  string & sr = reinterpret_cast<string &>(ip);
  string * sp = reinterpret_cast<string *>(ip);
  
  

Beware Reinterpret Casts

• Reinterpret casts usually do no value modification.

  • Bits may be chopped to fit (in a compiler-dependent way).

• Reinterpret casts are not static casts, and vice versa.

  // wrong, a static cast.
  
     int i = reinterpret_cast<int>(1.0);  
  
  // wrong, a reinterpret cast.
  
     char * cp = static_cast<char *>(ip); 
  

  • Related types? Use a static cast.

  • Unrelated pointer or reference types? Use a reinterpret cast.

Dynamic Casts

• A dynamic cast converts from parent to child.

  • Also known as downcasting.

  • Part of the run-time type information (RTTI) system.

• The syntax is dynamic_cast<target-class>(val)

  • val should be a pointer or reference to a class instance.

  • target-class should be a pointer or reference to a class type.

  • Both must be pointers or references, you can't mix them.

  • If val doesn't point to an instance of target-class, the dynamic cast returns 0.
  

Classes and Casts

• Given a class C, casting values of other types to or from values of type C is often useful.

  Given the class big_int,

  • Cast strings into big ints.

    big_int bi = "1000000000000000000000000000";
    

  • Cast big ints into strings.

    string msg = string("128! = ") + bi;
    

  Other types convert to and from big_ints in the same way.

• Classes can define conversions to and from the class.

  • A conversion from T value to a class value.

  • A conversion from a class value to a T value.

Converting to Class Values

• A cast constructor converts from other values into class values.

• Cast constructors have constructor syntax.

  • C::C(const T & tval)

    big_int::big_int(const string & str) { ... }
    
    big_int bi("100000000000000000000000000");
    

• A cast constructor creates a new implicit cast the compiler can use.

  • It's a static cast.

• Cast constructors loosen the type system, and are dangerous.

  • Mistakes and misunderstandings get turned into incorrect code.

Cast Constructor Fine Points

• The complier uses cast constructors when needed.

  bi = "10";
  

  "10" gets converted to a string, which gets converted to a big int, which gets assigned by bi.

• This can get confusing fast.

• The compiler takes the shortest sequence of conversions it finds.

  • You had better agree with what the compiler does.

• Cast constructors can turn typos into subtle programming errors.

  • The explicit keyword can prevent these problems.

    explicit C::C(const T & tval);
    

  • Explicit constructors must be called explicitly.

    explicit big_int::big_int(const string & str) { ... }
    
    big_int bi("10");   // Counts as explicit.
    bi = "20";          // Wrong - no explicit call.
    bi = big_int("30"); // Ok - explicit call.
    
    

Casting From Class Types

• Casts are operators, they can be overloaded.

• To cast from a class value to a value of type T, define a class operator that casts to T.

• Uses quasi-old-style syntax:

  • C::operator target-type ()

  • No return type, no arguments.

    big_int::operator string () { ... }
    

• Defines a static (that is, implicit) cast.

  cout << static_cast<string>(bi) << "\n";
  

  • Because it's implicit, the compiler can use it.

User-Defined Conversions

• Try to avoid user-defined conversions if possible.

  • They are seductive (because useful) and tricky (inadvertent definitions).

• They are near-term useful, but long-term trouble.

  • Complicate program understanding - e.g. overloading.

  • Turn compile-time bad code into run-time bad code.

  • They are implicit, invisible, and compiler determined.

• Mark single-parameter constructors as explicit.

• Don't define conversion operators - use member functions.

  string big_int::get_string(void) const { return ...; }
  
  cout << bi.get_string() << "\n";
  

• If you must define them, define an absolute minimal set.

  • Which can be difficult to define.

Points to Remember

• Conversions are a weak form of polymorphism.

  • The weakest and most dangerous.

• C++ has to casting styles, old and new.

  • Old-style casts are dangerous and difficult; avoid it.

• There are four new-style casts.

  • Static, constant, reinterpretation, and dynamic.

• Classes can define conversion operators for their values.

  • Convert to or from a class value.

• Casts are difficult and dangerous; avoid them.

  • A sign of poor design, poor coding, or both.

This page last modified on 3 April 2003.