Lecture notes for CS 509, Advanced Programming II

Lecture Notes for CS 509, Advanced Programming II

19 November 2002, Classes and Conversions

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 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.
Dynamic casts will be covered in more detail later.

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.

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 22 November 2002.