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

Answer 1

Type safety means that the compiler will help check that you don't mix (incompatible) data types.

For instance, when you call memcpy, the function (and compiler) only sees two pointers in memory, and will happily start copying data. This means you can mix incompatible data types like this:

SomeClass a;
AnotherClass b;
memcpy((void*)&a, (void*)&b, sizeof(b));

There are many approaches to gaining type safety. You could use templates and make a wrapper around mempcy(), ensuring that the two pointers point to the same data type, or you could use other ways.

Since you are already using vectors from the STL, you are already using a more or less type safe implementation.

Answer 2

"Type safety" means that the compiler checks that you are doing the right things with the right types (e.g triggers a compiler error if you attempt to treat a Banana as an Orange, or give a string to a function expecting to output an integer).

Type safety (mostly) goes right out of the window when void* comes into the picture - it is a pointer that can point to anything (completely unaware of the types involved), and the language leaves going about with it completely in the programmers hands (for example, a void* isn't mostly good for anything except for being cast back to the original type; it can represent anything, but you have to know what it is before you can use it).

Type unsafety also comes to play with variadic functions like printf (the compiler doesn't care how many arguments there are and what their types are - again it is up to the caller to make sure that the format string matches the arguments and their types).

Type-safe alternative to memcpy (for arrays and containers) could be std::copy in <algorithm> - it may be implemented in terms of memmove if all involved types satisfy certain requirements, otherwise it performs assignments - with some classes you can break certain invariants if you bypass their public interface and just go and move / copy them around in memory (for example, I suppose any class with a non-trivial copy constructor is going to misbehave if you make copies of it with memcpy).

Type-safe alternative to C I/O routines are iostreams (and if you want the benefits of the format string, boost::format).

Answer 3

"Type safety" is using a "type system" to ensure that errors are not propagated within programs. For example, without type safety, it might be possible to (silently) add a string type to floating point type in some undesirable way.

In the instances you're talking about, memcpy() and printf(), the lack of type safety is due to the how the functions treat their arguments. For example, with memcpy(arg1, arg2, len), the len bytes starting at memory address arg2 will be copied to memory address arg1, regardless of how many bytes arg1 points to, potentially overwriting other portions of your program.

For type safe alternatives, look into constructors and cout.

In fact, look into the entire C++ FAQ Lite

Answer 4

The signature of memcpy function is

void *memcpy (void* destination, const void* source, size_t num);

so as you can see it doesn't assume anything about pointers involved with the copy, they are just pointers. So if for example you want to copy a range of ints to a range of floats compiler won't complain about that.

Type Safety is a tool that helps developers to avoid certain errors by preventing some kind of erroneous code being compiled (and lately executed). It analyzes semantic aspect of source code to check if conversion between types and types in general are cohoerent.

What does that mean? It means that if your program passes the type checking phase you can be sure not to generate CERTAIN KIND of errors at run-time.

Of course sometimes you need to force this check not to be done, that's why you can use casts to force things to be what you want. Think about another example, malloc: it is defined to be

void* malloc (size_t size);

so when you want to allocate a pointer to floats for example you do:

float* ptr = (float*)malloc(sizeof(float*)*COUNT);

You are forced to cast the result of the function to be float* otherwise the typecheck will find an assign of a void* to a float* but void* is too generic to be assigned so: TYPE CHECK FAIL!

That's why memcpy is not type-safe. It doesn't check anything, it just copy from a pointer to another pointer.

Answer 5

Since you were on Wikipedia anyway: Type safety.

Type safety means, roughly speaking, that the language prohibits you from accidentally mixing up your types.

memcpy is not type-safe because you can easily copy the memory of some int into a char array and end up with meaningless data. printf is not type safe because you can provide a %i format specifier with a string; again, the string will be interpreted as an int and you'll end up with garbage. (Incidentally, the VC++ compiler does check the format string in some situations.)

std::vector<T> is type-safe, because it only allows you to put values of the given type T into it. (You can do explicit typecasts, of course, but the point is that you have to be explicit about doing something that's not type safe).

Answer 6

Type safety means that the compiler can check whether you're using the right types. For example, if you're using printf, you could accidentally crash your program by writing this:

printf("The meaning of life is %s", 42);

because 42 is an integer, not a string.