为什么我可以将 char* 隐式转换为 const char* 而不是 unsigned char*

Question

The following code snippet produces a compile error:

char a = 'a';
const char* a_ = &a;
unsigned char b = 'b';
const char* b_ = &b;

The last line produces the error:

error: invalid conversion from 'unsigned char*' to 'const char*'

I can implicitly convert from char* to const char* , but I cannot do the same for unsigned char* ? What is the reason behind this?

Answer 1

You can add constness to the pointee. That's permitted because it's useful and safe.

But you can't just randomly change the pointee's type beyond that.

You're saying "I have a pointer to a char , hey, here it is, whoops no it's a unsigned char " and you cannot do that without a C-style "force" cast or a reinterpret_cast .

This is the right code:

char a = 'a';
const char* a_ = &a;
unsigned char b = 'b';
const unsigned char* b_ = &b;   // (added "unsigned" here)

Answer 2

Because when you store a value to a signed char x; and then fetch it through either signed char *xp = &x;(via *xp ) or a signed char const *xcp =&x; , you get the same value. Always.

But if you have signed char x = -1; and you fetch it through an unsigned char* pointer, you get a different value (255, barring exotic architectures).

That's why INT *ip can be assigned to INT const * but not to UINT * (where INT and UINT is any signed integer type and its unsigned counterpart).

The strict aliasing rules still allow you to access INT values via UINT pointers and vice-versa, but you need an explicit cast to obtain such a pointer (pointing to a differently signed version of the original type).

---

Note: char has unspecified signedness. It's either like signed char or like unsigned char , but it is a type distinct from both of these (unlike every other integer type, where signed INT is the same as INT (except in bitfields)).

Answer 3

A pointer to a non-constant object can be implicitly converted to pointer to a constant object of the same type. So these declarations

char a = 'a';
const char* a_ = &a;

are valid.

Now let's consider the following declarations (for clarity the qualifier const is removed)

unsigned char b = 'b';
char* b_ = &b;

The expression in the right hand side has the type unsigned char * while the initialized object has the type char * . These two types are different and there is no implicit conversion from one type to another. Instead you can write

unsigned char b = 'b';
char* b_ = reinterpret_cast<char *>( &b );

In this case the both entities in the right hand side and in the left hand side have the same type. So you now can add the qualifier const for specification of the declared object

unsigned char b = 'b';
const char* b_ = reinterpret_cast<char *>( &b );

In C and C++ the types char , signed char and unsigned char are three different types. The type char can behave either as the type signed char or as the type unsigned char (can have the same range of values) but this does not make it signed or unsigned char.