Почему я не могу static_cast между char * и unsigned char *?

Они совершенно разных типов см. стандарт:

3.9.1 Основные типы [basic.fundamental]

1 Объекты, объявленные как символы char), должны быть достаточно большими для хранения любого члена базового набора символов реализации. Если символ из этого набора хранится в символьном объекте, интегральное значение этого символьного объекта равно значению односимвольной литеральной формы этого символа. Реализация определяет, может ли объект char содержать отрицательные значения. Символы могут быть явно объявлены беззнаковыми или
подписанными. Обычный символ, подписанный символ и неподписанный символ — это три разных типа. Символ, знаковый символ и неподписанный символ занимают одинаковый объем памяти и имеют одинаковое выравнивание. требования (basic.types); то есть они имеют одно и то же объектное представление. Для символьных типов все биты представления object
участвуют в представлении значения. Для типов символов без знака все возможные битовые комбинации представления значения представляют числа. Эти требования не распространяются на другие типы. В любой конкретной реализации простой объект char может принимать те же значения, что и подписанный char, или неподписанный char; какой из них определяется реализацией.

По аналогии с этим также происходит следующее:

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

a и b - это совершенно разные типы, на самом деле вы спрашиваете, почему static_cast настолько ограничителен, когда он может без проблем выполнять следующие действия.

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

и почему он не может сделать вывод, что целевые типы имеют одинаковую ширину битового поля и могут быть представлены? Он может сделать это для скалярных типов, но для указателей, если цель не получена из источника, и вы хотите выполнить понижающее приведение, тогда приведение между указателями не будет работать.

Бьерн Страутроп объясняет, почему static_cast полезны в этой ссылке: http://www.stroustrup.com/bs_faq2.html#static-cast, но в сокращенной форме пользователь должен четко указать свои намерения и дать компилятору возможность проверить, может ли быть достигнуто то, что вы намереваетесь, поскольку static_cast не поддерживает приведение между различными типами указателей, тогда компилятор может поймать эту ошибку, чтобы предупредить пользователя, и если они действительно хотят выполнить это преобразование, им следует использовать reinterpret_cast.

вы пытаетесь преобразовать несвязанные указатели с помощью static_cast. static_cast не для этого. Здесь вы можете увидеть: Приведение типов.

С помощью static_cast вы можете преобразовывать числовые данные (например, должен работать char в unsigned char) или указатели на связанные классы (связанные некоторым наследованием). Это не так. Вы хотите преобразовать один несвязанный указатель в другой, поэтому вам нужно использовать reinterpret_cast.

По сути, то, что вы пытаетесь сделать, для компилятора то же самое, что и попытка преобразовать char * в void *.

Хорошо, вот некоторые дополнительные мысли, почему допускать это в корне неправильно. static_cast можно использовать для преобразования числовых типов друг в друга. Так что вполне законно написать следующее:

char x = 5;
unsigned char y = static_cast<unsigned char>(x);

что еще можно:

double d = 1.2;
int i = static_cast<int>(d);

Если вы посмотрите на этот код на ассемблере, вы увидите, что второе приведение — это не просто повторная интерпретация битового шаблона d, а вместо этого здесь вставлены некоторые ассемблерные инструкции для преобразований.

Теперь, если мы распространим это поведение на массивы, случай, когда достаточно просто другого способа интерпретации битового шаблона, это может сработать. Но как насчет приведения массивов двойных значений к массивам целых чисел? Здесь вы либо должны заявить, что вам просто нужна переинтерпретация битовых шаблонов - для этого есть механизм, называемый reinterpret_cast, либо вы должны выполнить дополнительную работу. Как видите, простого расширения static_cast для указателей/массивов недостаточно, поскольку он должен вести себя аналогично static_casting одиночных значений типов. Иногда для этого требуется дополнительный код, и неясно, как это должно быть сделано для массивов. В вашем случае - остановка на \0 - потому что это соглашение? Этого недостаточно для нестроковых случаев (число). Что произойдет, если размер типа данных изменится (например, int или double на x86-32bit)?

Поведение, которое вы хотите, не может быть правильно определено для всех вариантов использования, поэтому оно не входит в стандарт C++. В противном случае вам пришлось бы помнить такие вещи, как: «Я могу привести этот тип к другому, если они имеют целочисленный тип, имеют одинаковую ширину и ...». Таким образом, совершенно ясно - либо они связаны КЛАССЫ - тогда вы можете приводить указатели, либо они являются числовыми типами - тогда вы можете приводить значения.

Помимо указателей, unsigned char * и char * не имеют ничего общего (EdChum уже упоминал тот факт, что char, signed char и unsigned char — это три разных типа). Вы можете сказать то же самое для типов указателей Foo * и Bar * на любые непохожие структуры.

static_cast означает, что указатель исходного типа может использоваться как указатель целевого типа, что требует отношения подтипа. Следовательно, его нельзя использовать в контексте вашего вопроса; вам нужен либо reinterpret_cast, который делает именно то, что вы хотите, либо приведение в стиле C.