Gibt es einen Grund zu bevorzugen static_cast<>
Casting im C-Stil? Sind sie gleichwertig? Gibt es irgendwelche Geschwindigkeitsunterschiede?
Was ist der Unterschied zwischen static_cast und Casting im C-Stil?
dicroce
Tal
Umwandlungen im C++-Stil werden vom Compiler überprüft. Umwandlungen im C-Stil sind dies nicht und können zur Laufzeit fehlschlagen.
Außerdem kann leicht nach Casts im c++-Stil gesucht werden, während es wirklich schwierig ist, nach Casts im c-Stil zu suchen.
Ein weiterer großer Vorteil ist, dass die 4 verschiedenen Casts im C++-Stil die Absicht des Programmierers klarer ausdrücken.
Beim Schreiben von C++ würde ich so ziemlich immer die C++-Elemente anstelle des C-Stils verwenden.
-
Die einzigen Umwandlungen, die zur Laufzeit fehlschlagen können, sind
dynamic_cast
S.– R.Martinho Fernandes
27. Juli 2012 um 0:13 Uhr
-
C++ reinterpret_cast
(U) kann zur Laufzeit ziemlich genauso fehlschlagen wie Umwandlungen im C-Stil, und sie unterscheiden sich alle erheblich davon, wie dynamic_cast (U) fehlschlägt. – Christoph Schmidt
20. September 2012 um 2:29 Uhr
-
˗1 normaler C-Gips
(int)something
kann nicht fehlschlagen – entweder werden Sie in int umgewandelt oder ein Compilerfehler.– Tomáš Zato – Wiedereinsetzung von Monica
16. November 2015 um 12:34 Uhr
-
Können Sie erläutern, warum C++-Umwandlungen einfacher durchsucht werden können als C-Umwandlungen?
– Minh Tran
16. April 2018 um 15:08 Uhr
-
@MinhTran Für den C ++ – Stil können Sie in Ihren Quelldateien nach dem Schlüsselwort “cast” suchen. Aber was könntest du mit den C-Style-Casts anfangen?
– huangzonghao
31. Mai 2018 um 16:01 Uhr
Zusamenfassend:
static_cast<>()
gibt Ihnen die Möglichkeit, die Kompilierzeit zu überprüfen, C-Style-Cast nicht.static_cast<>()
ist besser lesbar und kann überall in einem C++-Quellcode leicht entdeckt werden, C_Style-Cast ist es nicht.- Absichten werden mit C++-Casts viel besser übermittelt.
Mehr Erklärung:
Die statische Umwandlung führt Konvertierungen zwischen durch kompatible Typen. Sie ähnelt der Besetzung im C-Stil, ist jedoch restriktiver. Zum Beispiel würde die Umwandlung im C-Stil einem Integer-Zeiger erlauben, auf ein Zeichen zu zeigen.
char c = 10; // 1 byte
int *p = (int*)&c; // 4 bytes
Da dies zu einem 4-Byte-Zeiger (ein Zeiger auf einen 4-Byte-Datentyp) führt, der auf 1 Byte des zugewiesenen Speichers zeigt, wird das Schreiben auf diesen Zeiger entweder einen Laufzeitfehler verursachen oder einen angrenzenden Speicher überschreiben.
*p = 5; // run-time error: stack corruption
Im Gegensatz zur Umwandlung im C-Stil ermöglicht die statische Umwandlung dem Compiler, zu überprüfen, ob die Datentypen von Zeiger und Pointee kompatibel sind, wodurch der Programmierer diese falsche Zeigerzuweisung während der Kompilierung abfangen kann.
int *q = static_cast<int*>(&c); // compile-time error
Auf dieser Seite finden Sie auch weitere Erklärungen zu C++-Casts: Klicken Sie hier
-
Ich denke, anstelle von “4-Byte-Zeiger” meinten Sie “Zeiger auf 4-Byte-Datentyp”.
– iheanyi
23. Juli 2014 um 19:55 Uhr
-
aber es erlaubt int q = static_cast
(c); – ToniParker
5. Februar 2019 um 11:28 Uhr
-
@TonyParker Das liegt daran, dass an dieser Zeile nichts falsch ist.
– Braden Best
5. August 2019 um 21:32 Uhr
Eugen Yokota
Sehen Ein Vergleich der Casting-Operatoren von C++.
Die Verwendung derselben Syntax für eine Vielzahl unterschiedlicher Casting-Operationen kann jedoch die Absicht des Programmierers unklar machen.
Darüber hinaus kann es schwierig sein, einen bestimmten Cast-Typ in einer großen Codebasis zu finden.
Die Allgemeingültigkeit der Umwandlung im C-Stil kann für Situationen, in denen nur eine einfache Konvertierung erforderlich ist, übertrieben sein. Die Möglichkeit, zwischen mehreren verschiedenen Casting-Operatoren mit unterschiedlichen Leistungsstufen zu wählen, kann Programmierer daran hindern, versehentlich in einen falschen Typ zu casten.
struct A {};
struct B : A {};
struct C {};
int main()
{
A* a = new A;
int i = 10;
a = (A*) (&i); // NO ERROR! FAIL!
//a = static_cast<A*>(&i); ERROR! SMART!
A* b = new B;
B* b2 = static_cast<B*>(b); // NO ERROR! SMART!
C* c = (C*)(b); // NO ERROR! FAIL!
//C* c = static_cast<C*>(b); ERROR! SMART!
}
Ein großartiger Beitrag, der verschiedene Umwandlungen in C/C++ erklärt und erklärt, was eine Umwandlung im C-Stil wirklich tut: https://anteru.net/blog/2007/12/18/200/index.html
Casting im C-Stil unter Verwendung der (Typ-)Variablensyntax. Das Schlimmste, das jemals erfunden wurde. Dies versucht, die folgenden Umwandlungen in dieser Reihenfolge durchzuführen: (siehe auch C++ Standard, 5.4 expr.cast Abschnitt 5)
- const_cast
- static_cast
- static_cast gefolgt von const_cast
- reinterpret_cast
- reinterpret_castgefolgt von const_cast
Kiriloff
static_cast
überprüft zur Kompilierzeit, dass die Konvertierung nicht zwischen offensichtlich inkompatiblen Typen erfolgt. Gegensätzlich zu dynamic_cast
, wird zur Laufzeit keine Überprüfung der Typenkompatibilität durchgeführt. Ebenfalls, static_cast
Konvertierung ist nicht unbedingt sicher.
static_cast
wird verwendet, um von einem Zeiger auf eine Basisklasse in einen Zeiger auf eine abgeleitete Klasse oder zwischen nativen Typen wie enum in int oder float in int zu konvertieren.
Der Benutzer von static_cast
muss sicherstellen, dass die Konvertierung sicher ist.
Die Umwandlung im C-Stil führt keine Überprüfung durch, weder beim Kompilieren noch zur Laufzeit.
Doug T.
Da es viele verschiedene Arten von Castings mit jeweils unterschiedlicher Semantik gibt, können Sie mit static_cast<> sagen: „Ich führe eine legale Konvertierung von einem Typ in einen anderen durch“, z. B. von int nach double. Eine einfache Besetzung im C-Stil kann viele Dinge bedeuten. Gießen Sie nach oben/unten? Interpretieren Sie einen Zeiger neu?
Siehe auch: stackoverflow.com/questions/103512/…
– Fließen
7. April 2013 um 17:24 Uhr