Comment convertir des types C++

Méthodes : 1. static_cast, utilisé pour la conversion de types non polymorphes ; 2. reinterpret_cast, converti en un autre type non lié ; 3. const_cast, supprime l'attribut const de la variable puis l'attribue ; , utilisé pour la conversion de pointeur ou de référence entre les hiérarchies d'héritage de classe.

L'environnement d'exploitation de ce tutoriel : système Windows 7, version C++17, ordinateur Dell G3.

Afin de standardiser la conversion de type en C et d'améliorer la visibilité de la conversion de type, C++ introduit quatre opérateurs de conversion de type forcée : static_cast, reinterpret_cast, const_cast ,dynamic_cast

Ce sont essentiellement des classes modèles.

Les éléments suivants sont introduits séparément :

1.static_cast

Il est utilisé pour la conversion de type non polymorphe (conversion statique), correspond à une conversion de type implicite en C , mais il ne peut pas être utilisé pour la conversion de deux types non liés , comme la conversion entre un entier et un pointeur entier, bien que les deux fassent quatre octets, mais l'un d'eux représente des données et l'autre représente l'adresse. Les types ne sont pas pertinents et ne peuvent pas être convertis.

Cette conversion est terminée au moment de la compilation et est similaire à la conversion de type de style C, mais veuillez noter les points suivants

Vous ne pouvez pas convertir entre deux types de classe qui n'ont aucune relation de dérivation

Vous ne pouvez pas supprimer les modificateurs de type du type d'origine, tels que const, volatile, __unaligned

Comme il n'y a pas de vérification de type dynamique lors de la conversion d'objets, il existe des risques de sécurité lors de la conversion d'objets de classe de base en classe dérivée objets

void Test()
{
    //C中的方式
    int i = 10;
    double d1 = i;//隐式类型转换
    //int *p = i;//无法隐式类型转换，只能强制类型转换
    int *p = (int*)i;
    //C++中的方式
    double d2 = static_cast<double>(i);
    //相当于创建一个static_cast<double>类型的匿名对象赋值给d2
    int* p2 = static_cast<int*>(i);//无法转换，会报错
}

2.reinterpret_cast

Le sens de la réinterprétation est de réinterpréter, ce qui peut convertir un type en un autre type sans rapport, correspond à la conversion de type forcée en C , qui gère les situations où la conversion implicite ne peut pas être effectuée

void Test()
{
    int i = 10;
    int* p2 = reinterpret_cast<int*>(i);
}

La conversion de type forcée peut parfois gérer certains problèmes de manière violente

comme dans l'exemple suivant :

Pour une fonction avec paramètres, comment appeler la fonction sans passer de paramètres ?

void Fun(int s)
{
    cout << s << endl;
}
typedef void(*FUNC)();
void Test()
{
    FUNC pf = reinterpret_cast<FUNC>(Fun);
    pf();
}

Le casting en C peut également être géré.

Bien que nous convertissions les pointeurs de fonction via cette méthode BUG, ​​un tel code n'est pas portable et produit parfois des résultats incertains, il n'est donc pas recommandé de l'utiliser comme ceci

Comme ici La valeur de la sortie s est une valeur aléatoire. Bien que l'utilisateur ne passe pas de paramètres externes, la fonction créera un paramètre formel lorsqu'elle sera appelée. Le paramètre formel n'est pas initialisé et est naturellement une valeur aléatoire

.

3.const_cast

Sa fonction est de supprimer l'attribut const de la variable pour faciliter la réaffectation

Cette conversion est terminée au moment de la compilation et est utilisée pour supprimer les modificateurs const et volatile. Seuls les pointeurs ou les références peuvent être convertis

void Test3()
{
    const int i = 10;
    int *p = const_cast<int*>(&i);
    *p = 20;
    cout << i << endl;
    cout << *p << endl;
}

4.dynamic_cast

<. 🎜>

Principalement utilisé pour le "casting vers le bas sécurisé", pour la conversion de pointeur ou de référence entre les hiérarchies d'héritage de classe. Il est principalement utilisé pour effectuer un « downcasting sécurisé », c'est-à-dire convertir des pointeurs ou des références d'objets de classe de base en d'autres pointeurs ou références du même niveau d'héritage.

Quant à la "première conversion" (c'est-à-dire que le pointeur de classe dérivé ou le type de référence est converti en son type de classe de base), elle est sûre en soi, même si Dynamic_cast peut être utilisé pour la conversion. n'est pas nécessaire. Une conversion ordinaire peut déjà atteindre l'objectif, après tout, l'utilisation de Dynamic_cast nécessite une surcharge.

class Base
{
public:
    Base(){};
    virtual void Show(){cout<<"This is Base calss";}
};
class Derived:public Base
{
public:
    Derived(){};
    void Show(){cout<<"This is Derived class";}
};
int main()
{
    Base *base ;
    Derived *der = new Derived;
    //base = dynamic_cast<Base*>(der); //正确，但不必要。
    base = der; //先上转换总是安全的
    base->Show();
    system("pause");
}

Tutoriel recommandé : "

C#"

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!