Ver código fonte para cpp/language/reinterpret cast

Não tem permissão para editar esta página, pelo seguinte motivo:
A operação solicitada está limitada a utilizadores de um dos seguintes grupos: Utilizadores, Administradores.
Pode ver e copiar o código fonte desta página.
{{tr_note}}
{{title|reinterpret_cast conversion}}
{{cpp/language/navbar}}

{{tr|Converte entre os tipos, reinterpretando o padrão de bits subjacente.|Converts between types by reinterpreting the underlying bit pattern.}}

===Sintaxe===
{{sdsc begin}}
{{sdsc | {{ttb|reinterpret_cast &lt;}} {{spar|new_type}} {{ttb|&gt; (}} {{spar|expression}} {{ttb|)}} }}
{{sdsc end}}

{{tr|Retorna um valor de {{tt|new_type}} tipo.|Returns a value of type {{tt|new_type}}.}}

===Explicação===
{{tr|Ao contrário {{c|static_cast}}, mas como {{c|const_cast}}, a expressão {{c|reinterpret_cast}} não compila a quaisquer instruções da CPU. É puramente uma diretiva de compilação que instrui o compilador a tratar a seqüência de bits (representação do objeto) de {{spar|expression}} como se tivesse o tipo {{spar|new_type}}.|Unlike {{c|static_cast}}, but like {{c|const_cast}}, the {{c|reinterpret_cast}} expression does not compile to any CPU instructions. It is purely a compiler directive which instructs the compiler to treat the sequence of bits (object representation) of {{spar|expression}} as if it had the type {{spar|new_type}}.}}

{{tr|Apenas as seguintes conversões podem ser feitas com {{c|reintepret_cast}}, excepto quando essas conversões seria lançado fora constness'''''''' ou volatilidade.|Only the following conversions can be done with {{c|reintepret_cast}}, except when such conversions would cast away ''constness'' or ''volatility''.}}

@1@ {{tr|Uma expressão de enumeração, integral, ponteiro, ou ponteiro-para-membro tipo pode ser convertido para o seu próprio tipo. O valor resultante é o mesmo que o valor de {{tt|expression}}. {{mark since c++11}}|An expression of integral, enumeration, pointer, or pointer-to-member type can be converted to its own type. The resulting value is the same as the value of {{tt|expression}}. {{mark since c++11}}}}
@2@ {{tr|Qualquer ponteiro pode ser convertido para qualquer tipo integral suficientemente grande para conter o valor do apontador (por exemplo, para {{lc|std::uintptr_t}})|Any pointer can be converted to any integral type large enough to hold the value of the pointer (e.g. to {{lc|std::uintptr_t}})}}
@3@ {{tr|Um valor de qualquer tipo integral ou enumeração pode ser convertido para um tipo de ponteiro. Um ponteiro convertido para um número inteiro de tamanho suficiente e de volta para o mesmo tipo de ponteiro é garantido para ter o seu valor original, caso contrário, o ponteiro resultante não pode ser dereferenced com segurança. O {{lc|NULL}} ponteiro nulo constante ou inteiro igual a zero não é garantido para produzir o valor de ponteiro nulo do tipo de destino; {{rlp|static_cast}} {{rlp|implicit_cast|{{tr|conversão implícita|implicit conversion}}}} ou deve ser utilizada para este fim.|A value of any integral or enumeration type can be converted to a pointer type. A pointer converted to an integer of sufficient size and back to the same pointer type is guaranteed to have its original value, otherwise the resulting pointer cannot be dereferenced safely. The null pointer constant {{lc|NULL}} or integer zero is not guaranteed to yield the null pointer value of the target type; {{rlp|static_cast}} or {{rlp|implicit_cast|{{tr|conversão implícita|implicit conversion}}}} should be used for this purpose.}}
@4@ {{tr|Qualquer valor de {{lc|std::nullptr_t}} tipo, incluindo {{c|nullptr}} pode ser convertido para qualquer tipo integral, como se fosse {{c|(void*)0}}, mas nenhum valor, nem mesmo {{c|nullptr}} pode ser convertido para {{lc|std::nullptr_t}}: {{c|static_cast}} deve ser usada para esse fim. {{mark since c++11}}|Any value of type {{lc|std::nullptr_t}}, including {{c|nullptr}} can be converted to any integral type as if it was {{c|(void*)0}}, but no value, not even {{c|nullptr}} can be converted to {{lc|std::nullptr_t}}: {{c|static_cast}} should be used for that purpose. {{mark since c++11}}}}
@5@ {{tr|Qualquer ponteiro de objeto de {{tt|T1}} tipo pode ser convertido para o ponteiro de objeto de outro tipo {{tt|T2}}. Se requisito {{tt|T2}} do alinhamento não é mais rigoroso do que {{tt|T1}}, a conversão do ponteiro resultante de volta para os seus rendimentos de tipo originais do valor original, caso contrário, o ponteiro resultante não pode ser dereferenced com segurança. Em qualquer caso, o ponteiro resultante só pode ser dereferenced com segurança se permitido pelas regras do tipo'''' aliasing (ver abaixo) |Any pointer to object of type {{tt|T1}} can be converted to pointer to object of another type {{tt|T2}}. If {{tt|T2}}'s alignment requirement is not stricter than {{tt|T1}}'s, conversion of the resulting pointer back to its original type yields the original value, otherwise the resulting pointer cannot be dereferenced safely. In any case, the resulting pointer may only be dereferenced safely if allowed by the ''type aliasing'' rules (see below) }}
@6@ {{tr|Uma expressão lvalue de {{tt|T1}} tipo pode ser convertida para fazer referência a um outro tipo {{tt|T2}}. O resultado é um lvalue ou xValue referindo-se ao mesmo objecto que o lvalue original, mas com um tipo diferente. Não temporário é criado, nenhuma cópia é feita, nenhum construtor ou funções de conversão são chamados. A referência resultante só pode ser acessado com segurança se permitido pelas regras do tipo'' aliasing'' (veja abaixo)|An lvalue expression of type {{tt|T1}} can be converted to reference to another type {{tt|T2}}. The result is an lvalue or xvalue referring to the same object as the original lvalue, but with a different type. No temporary is created, no copy is made, no constructors or conversion functions are called. The resulting reference can only be accessed safely if allowed by the ''type aliasing'' rules (see below)}}
@7@ {{tr|Qualquer ponteiro de função pode ser convertido para um apontador para um tipo de função diferente. Chamando a função através de um ponteiro para um tipo de função diferente é indefinido, mas a conversão de tais ponteiro volta para ponteiro para o tipo de função original produz o ponteiro para a função original.|Any pointer to function can be converted to a pointer to a different function type. Calling the function through a pointer to a different function type is undefined, but converting such pointer back to pointer to the original function type yields the pointer to the original function.}}
@8@ {{tr|Em algumas implementações (em particular, em qualquer sistema POSIX compatível), um ponteiro de função pode ser convertido para um ponteiro de objecto ou vice-versa. Se a aplicação suporta a conversão em ambos os sentidos, a conversão para o tipo original produz o valor original, caso contrário o ponteiro resultante não pode ser dereferenced ou chamado com segurança.|On some implementations (in particular, on any POSIX compatible system), a function pointer can be converted to an object pointer or vice versa. If the implementation supports conversion in both directions, conversion to the original type yields the original value, otherwise the resulting pointer cannot be dereferenced or called safely.}}
@9@ {{tr|O valor de ponteiro nulo de qualquer tipo de ponteiro pode ser convertido em qualquer outro tipo de ponteiro, o que resulta no valor de ponteiro nulo desse tipo. Note-se que a constante {{c|nullptr}} ponteiro nulo ou qualquer outro valor de {{lc|std::nullptr_t}} tipo não pode ser convertido para um ponteiro com {{c|reinterpret_cast}}: conversão implícita ou {{c|static_cast}} deve ser usada para esse fim.|The null pointer value of any pointer type can be converted to any other pointer type, resulting in the null pointer value of that type. Note that the null pointer constant {{c|nullptr}} or any other value of type {{lc|std::nullptr_t}} cannot be converted to a pointer with {{c|reinterpret_cast}}: implicit conversion or {{c|static_cast}} should be used for this purpose.}}
@10@ {{tr|Um ponteiro de rvalue para função de membro pode ser convertido para um ponteiro para função de membro diferente de um tipo diferente. A conversão para o tipo original produz o valor original, caso contrário, o ponteiro resultante não pode ser usado com segurança.|An rvalue pointer to member function can be converted to pointer to a different member function of a different type. Conversion to the original type yields the original value, otherwise the resulting pointer cannot be used safely.}}
@11@ {{tr|Um ponteiro rvalue ao objeto membro de alguma {{tt|T1}} classe pode ser convertido para um ponteiro a outro objeto membro de outra {{tt|T2}} classe. Se o alinhamento {{tt|T2}} não é mais rigoroso do que {{tt|T1}}, a conversão para o rendimento do tipo de origem o valor original, caso contrário, o ponteiro resultante não pode ser usado com segurança.|An rvalue pointer to member object of some class {{tt|T1}} can be converted to a pointer to another member object of another class {{tt|T2}}. If {{tt|T2}}'s alignment is not stricter than {{tt|T1}}'s, conversion to the original type yields the original value, otherwise the resulting pointer cannot be used safely.}}

{{cpp/language/cast_return}}

===Palavras-chave===
{{ltt|cpp/keywords/reinterpret_cast}}

===Digite aliasing===
{{tr|Quando um ponteiro ou referência a objeto do tipo {{tt|T1}} é {{tt|reintrepret_cast}} (ou estilo C elenco) para um ponteiro ou referência ao objeto de um tipo diferente {{tt|T2}}, o elenco sempre bem-sucedida, mas o ponteiro resultante ou de referência pode ser acessado somente se uma das o seguinte é verdadeiro:|When a pointer or reference to object of type {{tt|T1}} is {{tt|reintrepret_cast}} (or C-style cast) to a pointer or reference to object of a different type {{tt|T2}}, the cast always succeeds, but the resulting pointer or reference may only be accessed if one of the following is true:}}

* {{tr|T2 é o tipo (possivelmente cv qualificado) dinâmica do objeto|T2 is the (possibly cv-qualified) dynamic type of the object}}

* {{tr|T2 e T1 são tanto (possivelmente multi-nível, possivelmente cv-qualificados em cada nível) ponteiros para o {{mark since c++11}} mesmo tipo T3|T2 and T1 are both (possibly multi-level, possibly cv-qualified at each level) pointers to the same type T3 {{mark since c++11}}}}

* {{tr|T2 é a variante (possivelmente cv qualificado) assinado ou não assinado do tipo dinâmico do objeto|T2 is the (possibly cv-qualified) signed or unsigned variant of the dynamic type of the object}}

* {{tr|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.|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.}}

* {{tr|T2 é uma classe base (possivelmente cv-qualificado) do tipo dinâmico do objeto|T2 is a (possibly cv-qualified) base class of the dynamic type of the object}}

* T2 is {{c|char}} or {{c|unsigned char}}

{{tr|Se T2 não satisfaz estes requisitos, acessando o objeto através do novo ponteiro ou referência invoca um comportamento indefinido. Isto é conhecido como a regra estrita aliasing'''' e aplica-se a ambos os C + + e linguagens de programação C.|If T2 does not satisfy these requirements, accessing the object through the new pointer or reference invokes undefined behavior. This is known as the ''strict aliasing'' rule and applies to both C++ and C programming languages.}}

===Exemplo===
{{example
 |{{tr| Demonstra algumas utilizações de reinterpret_cast:
 | Demonstrates some uses of reinterpret_cast:
 }}| code=
#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';
}
 | output=
The value of &i is 0x7fff352c3580
42
This system is little-endian
42
}}

===Veja também===
{{dsc begin}}
{{dsc inc | cpp/language/dsc const_cast}}
{{dsc inc | cpp/language/dsc static_cast}}
{{dsc inc | cpp/language/dsc dynamic_cast}}
{{dsc end}}

[[de:cpp/language/reinterpret cast]]
[[en:cpp/language/reinterpret cast]]
[[es:cpp/language/reinterpret cast]]
[[fr:cpp/language/reinterpret cast]]
[[it:cpp/language/reinterpret cast]]
[[ja:cpp/language/reinterpret cast]]
[[ru:cpp/language/reinterpret cast]]
[[zh:cpp/language/reinterpret cast]]
Predefinições utilizadas nesta página:
Voltar para cpp/language/reinterpret cast.
cppreference.com

Procurar

Espaços nominais

Variantes

Visualizações

Ações

Ver código fonte para cpp/language/reinterpret cast

Navegação

Ferramentas
