Implicit type conversion rules in C++ operators

by

In C++ operators (for POD types) always act on objects of the same type.
Thus if they are not the same one will be promoted to match the other.
The type of the result of the operation is the same as operands (after conversion).

if:
either is      long double       other is promoted >      long double
either is           double       other is promoted >           double
either is           float        other is promoted >           float
either is long long unsigned int other is promoted > long long unsigned int
either is long long          int other is promoted > long long          int
either is long      unsigned int other is promoted > long      unsigned int
either is long               int other is promoted > long               int
either is           unsigned int other is promoted >           unsigned int
either is                    int other is promoted >                    int

Otherwise:
both operands are promoted to int

Note. The minimum size of operations is int. So short/char are promoted to int before the operation is done.

In all your expressions the int is promoted to a float before the operation is performed. The result of the operation is a float.

int + float =>  float + float = float
int * float =>  float * float = float
float * int =>  float * float = float
int / float =>  float / float = float
float / int =>  float / float = float
int / int                     = int
int ^ float =>  <compiler error>

More Related Contents:

  1. Why it is so ? And It is without you explicitly do casting [duplicate]
  2. Can I use the result of a comparison as an integer in C++?
  3. When should static_cast, dynamic_cast, const_cast and reinterpret_cast be used?
  4. What does casting to `void` really do? [duplicate]
  5. dynamic_cast and static_cast in C++
  6. Can I assume (bool)true == (int)1 for any C++ compiler?
  7. Converting a pointer into an integer
  8. What is the difference between (type)value and type(value)?
  9. What exactly is a type cast in C/C++?
  10. Should I worry about the alignment during pointer casting?
  11. Cast pointer to member function to normal pointer
  12. Reinterpret_cast vs. C-style cast
  13. Implicit conversion from char** to const char**
  14. Weird Behaviour with const_cast [duplicate]
  15. Can a cast operator be explicit?
  16. casting via void* instead of using reinterpret_cast [duplicate]
  17. Difference in behavior while using dynamic_cast with reference and pointers
  18. Casting int to bool in C/C++
  19. Passing shared_ptr as shared_ptr
  20. What is the difference between C-like casting and functional casting? [duplicate]
  21. What exactly is or was the purpose of C++ function-style casts?
  22. Why cast a pointer to a float into a pointer to a long, then dereference?
  23. Why doesn’t this reinterpret_cast compile?
  24. Performance hit from C++ style casts?
  25. C++: Why is const_cast evil?
  26. Safety of casting between pointers of two identical classes?
  27. C++ When should we prefer to use a two chained static_cast over reinterpret_cast
  28. What is the modern, correct way to do type punning in C++?
  29. Why does an lvalue cast work?
  30. Why do we have reinterpret_cast in C++ when two chained static_cast can do its job?

Leave a Comment