Strongly typed

Type information is necessary to test for proper access to and interpretation of data. A big feature in C++ that's relative to C is the inclusion of a strong type system. This means that many type checks performed by the compiler are significantly more strict than what would be allowed with C, which is a weakly typed language.

This is mostly apparent when looking at this legal C code, which will generate an error when compiled as C++:

void* pointer; 
int* number = pointer; 

Alternatively, they can also be written in the following way:

int* number = malloc(sizeof(int) * 5); 

C++ forbids implicit casts, requiring these examples to be written as follows:

void* pointer; 
int* number = (int*) pointer; 

They can also be written in the following way:

int* number = (int*) malloc(sizeof(int) * 5); 

As we explicitly specify the type we are casting to, we can rest assured that during compile time any type casts do what we expect them to do.

Similarly, the compiler will also complain and throw an error if we were to try to assign to a variable with a const qualifier from a reference without this qualifier:

const int constNumber = 42; 
int number = &constNumber; // Error: invalid initialization of reference. 

To work around this, you are required to explicitly cast the following conversion:

const int constNumber = 42; 
int number = const_cast<int&>(constNumber); 

Performing an explicit cast like this is definitely possible and valid. It may also cause immense issues and headaches later on when using this reference to modify the contents of the supposedly constant value. By the time you find yourself writing code like the preceding, however, it can reasonably be assumed that you are aware of the implications.

Such enforcement of explicit types has the significant benefit of making static analysis far more useful and effective than it is in a weakly typed language. This, in turn, benefits run-time safety, as any conversions and assignments are most likely to be safe and without unexpected side effects.

As a type system is predominantly a feature of the compiler rather than any kind of run-time code, with (optional) run-time type information as an exception. The overhead of having a strongly typed type system in C++ is noticed only at compile time, as more strict checks have to be performed on each variable assignment, operation, and conversion.