Why can’t I static_cast between char * and unsigned char *?

by

They are completely different types see standard:

3.9.1 Fundamental types [basic.fundamental]

1 Objects declared as characters char) shall be large enough to
store any member of the implementation’s basic character set. If a
character from this set is stored in a character object, the integral
value of that character object is equal to the value of the single
character literal form of that character. It is
implementation-defined whether a char object can hold negative
values. Characters can be explicitly declared unsigned or
signed. Plain char, signed char, and unsigned char are
three distinct types. A char, a signed char, and an unsigned char
occupy the same amount of storage and have the same alignment
requirements (basic.types); that is, they have the same object
representation. For character types, all bits of the object
representation participate in the value representation. For unsigned
character types, all possible bit patterns of the value representation
represent numbers. These requirements do not hold for other types. In
any particular implementation, a plain char object can take on either
the same values as a signed char or an unsigned char; which one is
implementation-defined.

So analogous to this is also why the following fails:

unsigned int* a = new unsigned int(10);
int* b = static_cast<int*>(a); // error different types

a and b are completely different types, really what you are questioning is why is static_cast so restrictive when it can perform the following without problem

unsigned int a = new unsigned int(10);
int b = static_cast<int>(a); // OK but may result in loss of precision

and why can it not deduce that the target types are the same bit-field width and can be represented? It can do this for scalar types but for pointers, unless the target is derived from the source and you wish to perform a downcast then casting between pointers is not going to work.

Bjarne Stroustrop states why static_cast‘s are useful in this link: http://www.stroustrup.com/bs_faq2.html#static-cast but in abbreviated form it is for the user to state clearly what their intentions are and to give the compiler the opportunity to check that what you are intending can be achieved, since static_cast does not support casting between different pointer types then the compiler can catch this error to alert the user and if they really want to do this conversion they then should use reinterpret_cast.

More Related Contents:

  1. Should I use static_cast or reinterpret_cast when casting a void* to whatever
  2. C++ When should we prefer to use a two chained static_cast over reinterpret_cast
  3. Why do we have reinterpret_cast in C++ when two chained static_cast can do its job?
  4. Assigning char array from ifstream breaks array if adding another char to array
  5. The array index doesnt show the character [closed]
  6. uint8_t can’t be printed with cout
  7. Why are C character literals ints instead of chars?
  8. Why use static_cast(x) instead of (int)x?
  9. When to use reinterpret_cast?
  10. What is the difference between static_cast and C style casting?
  11. How to convert a single char into an int [duplicate]
  12. Single quotes vs. double quotes in C or C++
  13. std::string to char*
  14. How to return local array in C++?
  15. Why does streaming a char pointer to cout not print an address?
  16. Conversion from string literal to char* is deprecated
  17. cin for an int inputing a char causes Loop that is supposed to check input to go wild
  18. cannot convert ‘std::basic_string’ to ‘const char*’ for argument ‘1’ to ‘int system(const char*)’
  19. How to convert a char array to a string?
  20. Does accessing the first field of a struct via a C cast violate strict aliasing?
  21. can’t modify char* – Memory access violation
  22. Is reinterpret_cast type punning actually undefined behavior?
  23. Convert char array to single int?
  24. Is casting std::pair const& to std::pair const& safe?
  25. C / C++ How to copy a multidimensional char array without nested loops?
  26. Is it a strict aliasing violation to alias a struct as its first member?
  27. Why is reinterpret_cast not constexpr?
  28. strcmp or string::compare?
  29. Should I use a C++ reinterpret_cast over a C-style cast?
  30. Why Doesn’t reinterpret_cast Force copy_n for Casts between Same-Sized Types?

Leave a Comment