reinterpret_cast conversion

This page has been machine-translated from the English version of the wiki using Google Translate. The translation may contain errors and awkward wording. Hover over text to see the original version. You can help to fix errors and improve the translation. For instructions click here. Click here for the English version of this page

[editar] Sintaxe

[editar] Explicação

• um lvalue se new_type é um tipo de referência ou uma referência lvalue rvalue a funcionar tipo;

  Original:

  an lvalue if new_type is an lvalue reference type or an rvalue reference to function type;

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.
• um xValue se new_type é uma referência para rvalue tipo de objeto;

  Original:

  an xvalue if new_type is an rvalue reference to object type;

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.
• uma outra forma prvalue.

  Original:

  a prvalue otherwise.

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.

[editar] Palavras-chave

reinterpret_cast

[editar] Digite aliasing

• T2 é o tipo (possivelmente cv qualificado) dinâmica do objeto

  Original:

  T2 is the (possibly cv-qualified) dynamic type of the object

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.

• T2 e T1 são tanto (possivelmente multi-nível, possivelmente cv-qualificados em cada nível) ponteiros para o (desde C++11) mesmo tipo T3

  Original:

  T2 and T1 are both (possibly multi-level, possibly cv-qualified at each level) pointers to the same type T3 (desde C++11)

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.

• T2 é a variante (possivelmente cv qualificado) assinado ou não assinado do tipo dinâmico do objeto

  Original:

  T2 is the (possibly cv-qualified) signed or unsigned variant of the dynamic type of the object

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.

• T2 é um tipo de agregado ou um tipo de união que detém um dos tipos mencionados como membro elemento ou não-estático (incluindo, recursivamente, elementos de subaggregates e membros não-estáticos de dados dos sindicatos constantes): isso torna seguro para lançar a partir do primeiro membro de uma estrutura e de um elemento de uma união com a união struct / que o contém.

  Original:

  T2 is an aggregate type or a union type which holds one of the aforementioned types as an element or non-static member (including, recursively, elements of subaggregates and non-static data members of the contained unions): this makes it safe to cast from the first member of a struct and from an element of a union to the struct/union that contains it.

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.

• T2 é uma classe base (possivelmente cv-qualificado) do tipo dinâmico do objeto

  Original:

  T2 is a (possibly cv-qualified) base class of the dynamic type of the object

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.

• T2 is char or unsigned char

[editar] Exemplo

#include <cstdint>
#include <cassert>
#include <iostream>
int f() { return 42; }
int main()
{
    int i = 7;
 
    // pointer to integer and back
    uintptr_t v1 = reinterpret_cast<uintptr_t>(&i); // static_cast is an error
    std::cout << "The value of &i is 0x" << std::hex << v1 << '\n';
    int* p1 = reinterpret_cast<int*>(v1);
    assert(p1 == &i);
 
    // pointer to function to another and back
    void(*fp1)() = reinterpret_cast<void(*)()>(f);
    // fp1(); undefined behavior
    int(*fp2)() = reinterpret_cast<int(*)()>(fp1);
    std::cout << std::dec << fp2() << '\n'; // safe
 
    // type aliasing through pointer
    char* p2 = reinterpret_cast<char*>(&i);
    if(p2[0] == '\x7')
        std::cout << "This system is little-endian\n";
    else
        std::cout << "This system is big-endian\n";
 
    // type aliasing through reference
    reinterpret_cast<unsigned int&>(i) = 42;
    std::cout << i << '\n';
}

The value of &i is 0x7fff352c3580
42
This system is little-endian
42

[editar] Veja também