Ein Cast-Operator ist ein unärer Operator , der die Umwandlung eines Datentyps in einen anderen Datentyp erzwingt.
C++ unterstützt vier Casting-Typen:

1. Statischer Cast
2. Dynamischer Cast
3. Const Cast
4. Reinterpret Cast

Statischer Wurf: Dies ist die einfachste Wurfart, die verwendet werden kann. Es ist ein Cast zur Kompilierzeit . Es führt Dinge wie implizite Konvertierungen zwischen Typen durch (z. B. int zu Float oder Zeiger auf void *) und kann auch explizite Konvertierungsfunktionen (oder implizite) aufrufen.
Für zB

#include <iostream>
using namespace std;
int main()
{
    float f = 3.5;
    int a = f; // this is how you do in C
    int b = static_cast<int>(f);
    cout << b;
}

Ausgabe:

3

Lassen Sie uns nun ein paar Änderungen im Code vornehmen.

#include <iostream>
using namespace std;
int main()
{
    int a = 10;
    char c = 'a';
  
    // pass at compile time, may fail at run time
    int* q = (int*)&c; 
    int* p = static_cast<int*>(&c);
    return 0;
}

Wenn Sie den Code kompilieren, erhalten Sie eine Fehlermeldung:

[Error] invalid static_cast from type 'char*' to type 'int*'

Das bedeutet, dass selbst wenn Sie glauben, Sie könnten ein bestimmtes Objekt in ein anderes typisieren, aber sein illegales , static_cast Ihnen dies nicht erlaubt.

Nehmen wir ein weiteres Beispiel für das Konvertieren von Objekten in und aus einer Klasse.

#include <iostream>
#include <string>
using namespace std;
class Int {
    int x;
  
public:
    Int(int x_in = 0)
        : x{ x_in }
    {
        cout << "Conversion Ctor called" << endl;
    }
    operator string()
    {
        cout << "Conversion Operator" << endl;
        return to_string(x);
    }
};
int main()
{
    Int obj(3);
    string str = obj;
    obj = 20;
    string str2 = static_cast<string>(obj);
    obj = static_cast<Int>(30);
    return 0;
}

Führen Sie den obigen Code aus:

Conversion Ctor called
Conversion Operator
Conversion Ctor called
Conversion Operator
Conversion Ctor called

Lassen Sie uns versuchen, die obige Ausgabe zu verstehen:

1. Wenn obj erstellt wird, wird der Konstruktor aufgerufen, der in unserem Fall auch ein Konvertierungskonstruktor ist (für C++ 14-Regeln werden Bits geändert).
2. Wenn Sie str aus obj erstellen, gibt der Compiler keinen Fehler aus, da wir den Conversion-Operator definiert haben.
3. Wenn Sie make obj=20aufrufen, rufen Sie tatsächlich den Konvertierungskonstruktor auf.
4. Wenn Sie str2 aus static_cast machen , ist es ziemlich ähnlich zu string str=obj;, aber mit einer strengen Typprüfung.
5. Wenn Sie schreiben obj=static_cast<Int>(30), konvertieren Sie 30 mit static_cast in Int .

Nehmen wir ein Beispiel, bei dem es um Vererbung geht.

#include <iostream>
using namespace std;
class Base {
};
class Derived : public Base {
};
int main()
{
    Derived d1;
    Base* b1 = (Base*)(&d1); // allowed
    Base* b2 = static_cast<Base*>(&d1);
  
    return 0;
}

Der obige Code wird ohne Fehler kompiliert.

1. Wir haben die Adresse von übernommen d1und explizit in gegossen und in Basegespeichert b1.
2. Wir haben die Adresse von d1genommen und static_cast verwendet, um sie in umzuwandeln, Baseund sie in gespeichert b2.

Wie wir wissen, führt static_cast eine strenge Typprüfung durch, lassen Sie uns den geänderten Code leicht sehen, um ihn zu sehen:

#include <iostream>
using namespace std;
class Base {
};
class Derived : private Base { // Inherited private/protected not public
};
int main()
{
    Derived d1;
    Base* b1 = (Base*)(&d1); // allowed
    Base* b2 = static_cast<Base*>(&d1);
    return 0;
}

Versuchen Sie, den obigen Code zu kompilieren. Was sehen Sie? Kompilierungsfehler!!!!!!

[Error] 'Base' is an inaccessible base of 'Derived'

Der obige Code wird nicht kompiliert, selbst wenn Sie als geschützt erben . Um also static_cast zu verwenden, erben Sie es als öffentlich.

Verwenden Sie static_cast, um den 'to and from'-void-Zeiger umzuwandeln.

#include <iostream>
int main()
{
    int i = 10;
    void* v = static_cast<void*>(&i);
    int* ip = static_cast<int*>(v);
    return 0;
}