Lecture notes for CS 509, Advanced Programming II

Lecture Notes for CS 509, Advanced Programming II

4 April 2002, 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.

Conversions

Conversions treat a value of one type as another type; a.k.a. casting.
Conversions can be convenient and simplifying.
Conversions can be source of nasty compile- and run-time errors.
- The compiler chooses conversions automatically and silently.
- You had better agree with the compiler.
Generally speaking, an over-reliance on casting indicates bad design.

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.

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, on purpose probably.
There are four new-style conversions:
- Static casts - the implicit conversions.
- Constant casts - dealing with const and volatile.
- Reinterpreting casts - converting pointers.
- Dynamic casts - parent-to-child conversions.

Static Casts

Static casts perform the usual implicit C++ casts.
- Between T* and void *, int and double, and so on.
The syntax is static_cast<target-type>(val)

Static casts can modify val.

int i = static_cast<int>('c');

char c = static_cast<char>(1024);

int i = static_cast<int>(pi + 0.5);

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)
- val's type must be const T *, const T &, or const T.
- If val's type is const T *,
  then target-type must be T *.
- Similarly for references (sort of).
  - If val has type const T,
    then target-type can have type T &.
The pointer or reference returned refers to val.
- The pointer or reference may not work
- It depends on the compiler.
Constant casts are a good 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 interpretation.
The syntax is reinterpret_cast<target-type>(val)

Reinterpret casts do no value modification.

T2 * t2p = &t2_value;
T1 * t1p = reinterpret_cast<T1 *>(t2p);
t2p_copy = reinterpret_cast<T2 *>(t1p);

// Always true.

   assert(t2p_copy == t2p);

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

Dynamic Casts

Dynamic cast convert from parent to child.
- Also known as downcasting.
- Part of the run-time type information (RTTI) system.
The syntax is dynamic_cast<target-type>(val)
val should be a pointer to a class.
If val isn't the target type, the cast returns 0.
Frequent dynamic casts indicate questionable design.

Classes and Casts

Given a class C, casting values of other types to or from values of type C is often useful.
- Suppose C is big_int.
- Cast strings into big ints.
```
big_int bi = "1000000000000000000000000000";
```
- Cast big ints into strings.
```
string msg = string("128! = ") + bi;
```
Classes can define conversions to and from the class.

Converting to Class Values

Cast constructors convert from other types into class types.

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.

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.

This page last modified on 9 April 2002.