What is type safety and what are the “type safe” alternatives? [duplicate]

Answer 1

Type safety governs the usage of the compiler checking if the variable is of a right type. C is very loose on data type safety, for example, this is actually in the ANSI C standards, that states that type promotion will occur for data type char, an example in this assignment will explain this,

char ch = 32; /* that is a space character accordingly to ASCII */
int n = ch + 3;

Notice how the ch variable gets 'promoted' to type int. That is legitimate but warrants closer inspection if that is what you are implying.

Compilers such as the C# compiler will not allow this to happen, that is the very reason why in C, there is a usage of cast's operator for example:

int n = (int)3.1415926535f;

Nit picky aside, that is a pi value, what happens, is that the value of n will be 3.

The above serves to illustrate the type safety and that C is very loose on this regard.

Type safety in modern languages is more strict, such as Java, C#, in order to constrain the usage and meaning of the variables. PHP is an excellent example of loose typing, where you could do this:

$myvar = 34;
$myvar = $myvar + "foo";

is $myvar an integer, or is it a floating point or is it a string. The type safety here is not very clear on what is the intention which can lead to bugs and a happy debugging session trying to figure out what is happening.

Hope this helps

Answer 2

Type safety refers to a coding paradigm that enforces every variable to have a dedicated type at compilation time, for example int a = 4; double d = 100.0; struct ms {char s;} mystruct; The type of a variable is never 'lost'. If you want to change its type from a to b, an explicit or implicit conversion must be defined.

printf is not typesafe because you pass the arguments in a variadic argument list:

float f = 1.f;
printf("This is a float: %f\nAnd this is a string: %s",f,f);

printf does not know which kind of values she receives. The format string is used by the implementation to find out, but if the string is wrong, the implementation has no chance to find it out because there is no type information available at compile-time. The above printf call is most likely to end up catastrophic - printf expects a string as second parameter, but gets a floating-point number.

Answer 3

A short version of the answer:

class Person;

person.DoSomething(); // This is type safe.

void * p = &person; // You can now start doing unsafe things with p.

You can't pass a Person to memcpy. It only knows and cares about memory. Bytes.

Answer 4

It means that the compiler will generate no warning if you try to use a type in a way that doesn't make sense for that type. For example, the following is undefined behavior and in practice will copy the bits of a pointer into the bits of a float, where they make absolutely no sense. If sizeof(char*) > sizeof(float), it will overwrite whatever memory locations happen to be just above where f lives.

float f;
char *c = someString();
memcpy(&f, &c, sizeof(char*));