Thread: reinterpret vs c-style cast

Originally Posted by C_ntua

And you say in Java you cast all the time. What is the difference in C++?

Too much to bring up. You can read a lot of the Java vs C++ replies, if you want. There are a few.

Originally Posted by C_ntua

Here is a personal example. I want to have a function pointer. One function pointer that generally points to functions that can do a lot of things. So the function pointer is a type of returning void and accepting a list of void* pointers. Depending on the function the pointer points I cast the elements of the list in appropriate type. There are some reasons of course I chose to do this. And yes I know it would be easy to miss-cast or if I changed something I would have to change a lot of things. But still I chose to do so. So why wouldn't a language, a tool, provide me a default easy and readable way to do so? I used C-style casts, because they were more readable. It would have been better to use the other casts, because of the fact that they are more safe. That is the thing. I would expect something unsafe to be less readable than something safe. And the readability of the code makes you spot more easily other bugs, more common that miss-casts

There are a lot of solutions to that one. The one that comes to mind is templates. Make the functions accept a pointer of type T. Then it can point to whatever function. When you call it and if the arguments are wrong, the return is wrong, etc, you will get a compile error.
C++ provides a lot of ways to avoid casts, as you can see.

Originally Posted by C_ntua

Polymorphism can be achieve with casting and virtual functions. Polymorphism is really important so making one of the two ugly doesn't seem as a good idea.

Polymorphism is about not using casts.

Originally Posted by C_ntua

Pointers are not safe either, but C++ chose to have them. The point is that I would like for a language to provide a nice way to do things the way you want to. It is ok to provide safety for something that somebody can use without knowing what he is doing. But for something that you are aware of, like the effects of casting, it should be easy to use.

As I understand it, pointers were kept for backwards compatibility. Originally, Bjarne wanted only references in the language.
But I do agree with you - if the programmer is absolutely sure something must be done in a specific way, then the language should provide the tools to do so - after all, that is what C and C++ is all about - flexibility and speed.

As I understand it, pointers were kept for backwards compatibility. Originally, Bjarne wanted only references in the language.

Not really. References were created pretty late in the game - when operator overloading was added to the language. And I don't think Bjarne ever considered extending them so that pointers would become unnecessary. That would make them the pointers instead.
C++ has always been a hybrid language. A hybrid of procedural and object-oriented (and later generic) programming, and a hybrid of low-level system and high-level application programming. Pointers are an absolutely essential part of the low-level aspects of the language.

Originally Posted by CornedBee

Not really. References were created pretty late in the game - when operator overloading was added to the language. And I don't think Bjarne ever considered extending them so that pointers would become unnecessary. That would make them the pointers instead.
C++ has always been a hybrid language. A hybrid of procedural and object-oriented (and later generic) programming, and a hybrid of low-level system and high-level application programming. Pointers are an absolutely essential part of the low-level aspects of the language.

Can you actually solve problems such as linked lists with C++ type references [without an awful lot of workarounds]. As far as I understand, you can't re-assign a reference, so whilst you could set the next-element when you create a node, you couldn't then change it.

--
Mats

My recommendation would be to cast less.

Originally Posted by C_ntua

Someone said that you have to caste in Java every second line, and I asked why, among other things. I would like to ask again. Why is casting in Java/C# OK, but not in C++. Elaborate a bit...

It's pretty much a relic from before Java had generics. When every collection can only store references to Object, you have to cast every single time you retrieve an element from the collection.

Since much real-world code is about manipulating data in containers, there was a lot of casting.

Originally Posted by C_ntua

Someone said that you have to caste in Java every second line, and I asked why, among other things. I would like to ask again. Why is casting in Java/C# OK, but not in C++. Elaborate a bit...

Well I'd say it's not OK in those languages either, but in too many cases there's just no other option because of their short sighted design.

Originally Posted by master5001

C++ casts are for C++ code. I didn't read the initial post or any susbsequent arguments. That is all there is to say about that and there is zero room for argument. Any argument is simply promoting being sloppy. They didn't make all "them fancy C++ casts" for no reason.

You realize that reading the entire topic helps, eh, buddy?
It is not so much about sloppiness, but about ugliness and too much typing.

Originally Posted by C_ntua

What do you mean short sighted design? Java provides the same level of polymorphism with C++. If you can use a virtual function in C++ you can do in Java. If you can cast in Java you can do it in C++. C++ offers you safer casts, but you would cast in Java but not in C++?

Java and C++ are similar, but not the same language, thus what exists in C++ does not always exist in Java and vice versa. Remember that.
And short-sighted design means that a language means you do in an X way, but sometimes, if you need to do it an Y way, then it is a short-sighted design, if the language hinders you from doing it the X way.

I don't defend anything, the answer that what you do in Java is worse than in C++ is acceptable. What I want to clarify is that if this is the case, and the designers of C++, Java, C# had different opinions about casting, how can you say it is "bad"?

Because they are not the same languages, and have different goals and strengths.
For example, C++ is a type-strict language and thus circumventing this is said to be bad, and that is what casts do.
But in C, for example, it is not bad to cast - indeed, it is preferred and a must in many situations because C is not type-strict.
And I remember someone mentioning that casting is much a relic from old times in Java from when it lacked generics.

As for specific language examples, I'm afraid that's beyond my knowledge.

As far as type theory goes, Java is much more a type-safe language than C++.