Question

In the book Coders at Work (p355), Guy Steele says of C++:

I think the decision to be
backwards-compatible with C is a fatal
flaw. It’s just a set of difficulties
that can’t be overcome. C
fundamentally has a corrupt type
system. It’s good enough to help you
avoid some difficulties but it’s not
airtight and you can’t count on it

What does he mean by describing the type system as “corrupt”?

Can you demonstrate with a simple example in C?

Edit:

1. The quote sounds polemic, but I’m not trying to be. I simply want to understand what he means.

2. Please give examples in C not C++. I’m interested in the “fundamentally” part too 🙂

Answer 1

The obvious examples in C of non-type-safety simply come from the fact you can cast from void * to any type without having to explicitly cast so.

struct X
{
  int x;
};

struct Y
{
  double y;
};

struct X xx;
xx.x = 1;
void * vv = &xx;
struct Y * yy = vv; /* no need to cast explicitly */
printf( "%f", yy->y );

Of course printf itself is not exactly typesafe.

C++ is not totally typesafe.

struct Base
{
   int b;
};

struct Derived : Base
{
  int d;

  Derived() 
  {
     b = 1;
     d = 3;
  }
};

Derived derivs[50];
Base * bb = &derivs[0];
std::cout << bb[3].b << std::endl;

It has no problem converting the Derived* to a Base* but you run into problems when you try using the Base* as an array as it will get the pointer arithmetic all wrong and whilst all the b values are 1 you may well get a 3 (As the ints will go 1-3-1-3 etc)