static_cast conversion

Convertit entre les types en utilisant une combinaison de conversions implicites et définies par l'utilisateur.

Syntaxe

Retourne une valeur de type target-type .

Explication

Seules les conversions suivantes peuvent être effectuées avec static_cast , sauf lorsque ces conversions supprimeraient la constance (ou la volatilité).

struct B {};
struct D : B { B b; };
D d;
B& br1 = d;
B& br2 = d.b;
static_cast<D&>(br1); // OK, lvalue désignant l'objet original « d »
static_cast<D&>(br2); // UB : le sous-objet « b » n'est pas un sous-objet de classe de base

Comme pour toutes les expressions de cast, le résultat est :

• un lvalue si target-type est un type référence lvalue ou une référence rvalue vers un type fonction (depuis C++11) ;

• un prvalue sinon.

1. ↑ Ce type de static_cast est utilisé pour implémenter la sémantique de déplacement dans std::move .
2. ↑ Si l'arithmétique IEEE est supportée, l'arrondi par défaut est vers la valeur la plus proche.

Objets convertibles par pointeur

Deux objets a et b sont interchangeables par pointeur si :

• ils sont le même objet, ou
• l'un est un objet union et l'autre est un membre de données non statique de cet objet, ou
• l'un est un standard-layout class object et l'autre est le premier membre de données non statique de cet objet ou de tout sous-objet de classe de base de cet objet, ou
• il existe un objet c tel que a et c sont pointer-interconvertible, et c et b sont pointer-interconvertible.

union U { int a; double b; } u;
void* x = &u;                        // la valeur de x est « pointeur vers u »
double* y = static_cast<double*>(x); // la valeur de y est « pointeur vers u.b »
char* z = static_cast<char*>(x);     // la valeur de z est « pointeur vers u »

Notes

Les conversions de base-vers-dérivé ( downcasts ) utilisant static_cast n'effectuent aucune vérification à l'exécution pour garantir que le type dynamique de l'objet pointé/référencé est Derived , et ne peuvent être utilisées en sécurité que si ce prérequis est garanti par d'autres moyens, comme lors de l'implémentation du polymorphisme statique . Un downcast sécurisé peut être effectué avec dynamic_cast .

static_cast peut également être utilisé pour lever l'ambiguïté des surcharges de fonctions en effectuant une conversion fonction-vers-pointeur vers un type spécifique, comme dans

std::for_each(files.begin(), files.end(),
              static_cast<std::ostream&(*)(std::ostream&)>(std::flush));

Mots-clés

static_cast

Exemple

#include <iostream>
#include <vector>
struct B
{
    int m = 42;
    const char* hello() const
    {
        return "Hello world, this is B!\n";
    }
};
struct D : B
{
    const char* hello() const
    {
        return "Hello world, this is D!\n";
    }
};
enum class E { ONE = 1, TWO, THREE };
enum EU { ONE = 1, TWO, THREE };
int main()
{
    // 1. conversion descendante statique
    D d;
    B& br = d; // conversion ascendante via conversion implicite
    std::cout << "1) " << br.hello();
    D& another_d = static_cast<D&>(br); // conversion descendante
    std::cout << "1) " << another_d.hello();
    // 3. lvalue vers xvalue
    std::vector<int> v0{1, 2, 3};
    std::vector<int> v2 = static_cast<std::vector<int>&&>(v0);
    std::cout << "3) après déplacement, v0.size() = " << v0.size() << '\n';
    // 4. expression à valeur ignorée
    static_cast<void>(v2.size());
    // 5. conversion d'initialisation
    int n = static_cast<int>(3.14);
    std::cout << "5) n = " << n << '\n';
    std::vector<int> v = static_cast<std::vector<int>>(10);
    std::cout << "5) v.size() = " << v.size() << '\n';
    // 6. inverse de la conversion implicite
    void* nv = &n;
    int* ni = static_cast<int*>(nv);
    std::cout << "6) *ni = " << *ni << '\n';
    // 7a. enum délimité vers int
    E e = E::TWO;
    int two = static_cast<int>(e);
    std::cout << "7a) " << two << '\n';
    // 7b. int vers enum, enum vers un autre enum
    E e2 = static_cast<E>(two);
    [[maybe_unused]]
    EU eu = static_cast<EU>(e2);
    // 7f. pointeur vers membre en conversion ascendante
    int D::*pm = &D::m;
    std::cout << "7f) " << br.*static_cast<int B::*>(pm) << '\n';
    // 7g. void* vers n'importe quel pointeur d'objet
    void* voidp = &e;
    [[maybe_unused]]
    std::vector<int>* p = static_cast<std::vector<int>*>(voidp);
}

1) Hello world, this is B!
1) Hello world, this is D!
3) after move, v0.size() = 0
5) n = 3
5) v.size() = 10
6) *ni = 3
7a) 2
7f) 42

1) Bonjour le monde, voici B !
1) Bonjour le monde, voici D !
3) après déplacement, v0.size() = 0
5) n = 3
5) v.size() = 10
6) *ni = 3
7a) 2
7f) 42

` n'est pas traduit (comme demandé)
- Les termes C++ (`size()`, `move`, `n`, `v`, `ni`) sont conservés
- Seul le texte anglais ordinaire a été traduit en français

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

Références

Voir aussi

• const_cast
• dynamic_cast
• reinterpret_cast
• conversion explicite
• conversions implicites