Warum kann ich kein static_cast zwischen char * und unsigned char * durchführen?

Anscheinend betrachtet der Compiler sie als nicht verwandte Typen und daher reinterpret_cast Wird benötigt. Warum ist das die Regel?

Sie sind völlig unterschiedliche Typen siehe Standard:

3.9.1 Grundtypen [basic.fundamental]

1 Als Zeichen char deklarierte Objekte müssen groß genug sein, um jedes Mitglied des grundlegenden Zeichensatzes der Implementierung zu speichern. Wenn ein Zeichen aus diesem Satz in einem Zeichenobjekt gespeichert wird, ist der ganzzahlige Wert dieses Zeichenobjekts gleich dem Wert der Einzelzeichen-Literalform dieses Zeichens. Es wird durch die Implementierung definiert, ob ein char-Objekt negative Werte enthalten kann. Zeichen können explizit ohne Vorzeichen deklariert werden oder
unterzeichnet. Einfaches Zeichen, Zeichen mit Vorzeichen und Zeichen ohne Vorzeichen sind drei verschiedene Typen. Ein Zeichen, ein Zeichen mit Vorzeichen und ein Zeichen ohne Vorzeichen belegen den gleichen Speicherplatz und haben die gleichen Ausrichtungsanforderungen (Grundtypen); das heißt, sie haben dieselbe Objektdarstellung. Bei Zeichentypen alle Bits des Objekts
Repräsentation an der Wertrepräsentation teilnehmen. Bei vorzeichenlosen Zeichentypen stellen alle möglichen Bitmuster der Wertdarstellung Zahlen dar. Diese Anforderungen gelten nicht für andere Typen. In einer bestimmten Implementierung kann ein einfaches char-Objekt entweder die gleichen Werte wie ein vorzeichenbehaftetes oder ein vorzeichenloses Zeichen annehmen; welche ist implementierungsdefiniert.

Analog dazu schlägt auch folgendes fehl:

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

a und b sind völlig unterschiedliche Typen, Sie fragen sich wirklich, warum static_cast so restriktiv ist, wenn es die folgenden problemlos ausführen kann

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

und warum kann daraus nicht abgeleitet werden, dass die Zieltypen die gleiche Bitfeldbreite haben und dargestellt werden können? Dies ist für skalare Typen möglich, aber für Zeiger, es sei denn, das Ziel wird von der Quelle abgeleitet und Sie möchten einen Downcast durchführen, dann funktioniert das Umwandeln zwischen Zeigern nicht.

Bjarne Stroustrop erklärt warum static_cast‘s sind in diesem Link nützlich: http://www.stroustrup.com/bs_faq2.html#static-cast aber in abgekürzter Form ist es Sache des Benutzers, seine Absichten klar zu formulieren und dem Compiler die Möglichkeit zu geben, zu überprüfen, ob das von Ihnen beabsichtigte erreicht werden kann, da static_cast unterstützt das Casting zwischen verschiedenen Zeigertypen nicht, dann kann der Compiler diesen Fehler abfangen, um den Benutzer zu warnen, und wenn er diese Konvertierung wirklich durchführen möchte, sollte er verwenden reinterpret_cast.

Sie versuchen, nicht verwandte Zeiger mit einem static_cast zu konvertieren. Dafür ist static_cast nicht da. Hier sieht man: Typ Gießen.

Mit static_cast können Sie numerische Daten (zB char in unsigned char sollte funktionieren) oder Zeiger auf verwandte Klassen (durch eine Vererbung verwandt) konvertieren. Dies ist beides nicht der Fall. Sie möchten einen unabhängigen Zeiger in einen anderen konvertieren, daher müssen Sie reinterpret_cast verwenden.

Im Grunde ist das, was Sie versuchen, für den Compiler dasselbe wie der Versuch, ein char * in ein void * umzuwandeln.

Ok, hier noch ein paar zusätzliche Gedanken, warum es grundsätzlich falsch ist, dies zuzulassen. Mit static_cast können numerische Typen ineinander umgewandelt werden. Es ist also völlig legal, Folgendes zu schreiben:

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

was ist auch möglich:

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

Wenn Sie sich diesen Code in Assembler ansehen, werden Sie feststellen, dass der zweite Cast keine bloße Neuinterpretation des Bitmusters von d ist, sondern hier einige Assembler-Anweisungen für Konvertierungen eingefügt werden.

Wenn wir dieses Verhalten nun auf Arrays ausdehnen, könnte es in dem Fall funktionieren, in dem einfach eine andere Art der Interpretation des Bitmusters ausreicht. Aber was ist mit der Umwandlung von Arrays von Doubles in Arrays von Ints? Hier müssen Sie entweder erklären, dass Sie einfach eine Neuinterpretation der Bitmuster wünschen – dafür gibt es einen Mechanismus namens reinterpret_cast, oder Sie müssen zusätzliche Arbeit leisten. Wie Sie sehen, reicht eine einfache Erweiterung des static_cast für Zeiger / Arrays nicht aus, da es sich ähnlich verhalten muss wie das statische_casting einzelner Werte der Typen. Dies erfordert manchmal zusätzlichen Code, und es ist nicht klar, wie dies für Arrays erfolgen soll. In Ihrem Fall – aufhören bei – weil es die Konvention ist? Dies ist für Nicht-String-Fälle (Zahl) nicht ausreichend. Was passiert, wenn sich die Größe des Datentyps ändert (zB int vs. double auf x86-32bit)?

Das gewünschte Verhalten kann nicht für alle Anwendungsfälle richtig definiert werden, deshalb ist es nicht im C++-Standard enthalten. Andernfalls müssten Sie sich Dinge merken wie: “Ich kann diesen Typ in den anderen umwandeln, solange sie vom Typ Integer sind, die gleiche Breite haben und …”. Auf diese Weise ist es völlig klar – entweder sind es verwandte KLASSEN – dann können Sie die Zeiger umwandeln, oder es handelt sich um numerische Typen – dann können Sie die Werte umwandeln.

Abgesehen davon, dass sie Hinweise sind, unsigned char * und char * nichts gemeinsam haben (EdChum hat bereits erwähnt, dass char, signed char und unsigned char sind drei verschiedene Typen). Das gleiche könnte man auch sagen Foo * und Bar * Zeigertypen auf unterschiedliche Strukturen.

static_cast bedeutet, dass ein Zeiger des Quelltyps als Zeiger des Zieltyps verwendet werden kann, was eine Untertypbeziehung erfordert. Daher kann es nicht im Kontext Ihrer Frage verwendet werden; was du brauchst ist entweder reinterpret_cast die genau das tut, was Sie wollen, oder eine Besetzung im C-Stil.