Espaços nominais
Variantes
Acções

Member access operators

Da cppreference.com
< cpp‎ | language

 
 
Linguagem C + +
Tópicos gerais
Original:
General topics
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Controle de fluxo
Original:
Flow control
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Declarações execução condicional
Original:
Conditional execution statements
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Instruções de iteração
Original:
Iteration statements
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Ir declarações
Original:
Jump statements
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Funções
Original:
Functions
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
declaração da função
lambda declaração da função
modelo de função
linha especificador
especificações de exceção (obsoleta)
noexcept especificador (C++11)
Exceções
Original:
Exceptions
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Namespaces
Original:
Namespaces
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Tipos
Original:
Types
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
decltype specifier (C++11)
Especificadores
Original:
Specifiers
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
cv especificadores
armazenamento duração especificadores
constexpr especificador (C++11)
auto especificador (C++11)
alignas especificador (C++11)
Inicialização
Original:
Initialization
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Literais
Original:
Literals
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Expressões
Original:
Expressions
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
representações alternativas
Utilitários
Original:
Utilities
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Tipos
Original:
Types
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
typedef declaration
tipo de alias declaração (C++11)
atributos (C++11)
Lança
Original:
Casts
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
conversões implícitas
const_cast conversion
static_cast conversion
dynamic_cast conversion
reinterpret_cast conversion
Elenco C-estilo e funcional
Alocação de memória
Original:
Memory allocation
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Classes
Original:
Classes
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Classe propriedades específicas de função
Original:
Class-specific function properties
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Funções membro especiais
Original:
Special member functions
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Modelos
Original:
Templates
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
modelo de classe
modelo de função
especialização de modelo
pacotes de parâmetros (C++11)
Diversos
Original:
Miscellaneous
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Assembly embutido
 
Acessa um membro de um objeto.
Original:
Accesses a member of an object.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Operator name Syntax Over​load​able Prototype examples (for class T)
Inside class definition Outside class definition
array subscript a[b] Yes R& T::operator[](const T2& b); N/A
indirection (variable pointed to by a) *a Yes R& T::operator*(); R& operator*(T &a);
address of &a Yes R* T::operator&(); R* operator&(T &a);
member of object a.b No N/A N/A
member of pointer a->b Yes R* T::operator->() N/A
pointer to member of object a.*b No N/A N/A
pointer to member of pointer a->*b Yes R* T::operator->*(R) R* T::operator->*(T, R)
'Notas'
Original:
Notes
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
  • Tal como acontece com a maioria dos definidos pelo utilizador sobrecargas, tipos de retorno deve coincidir com os tipos de retorno fornecidos pelos operadores embutidas de modo a que os operadores definidos pelo utilizador podem ser usados ​​da mesma maneira como o built-ins. No entanto, numa definida pelo utilizador sobrecarga de operador, de qualquer tipo pode ser utilizado como tipo de retorno (incluindo void). Uma exceção é operator->, que deve retornar um ponteiro.
    Original:
    As with most user-defined overloads, return types should match return types provided by the builtin operators so that the user-defined operators can be used in the same manner as the built-ins. However, in a user-defined operator overload, any type can be used as return type (including void). One exception is operator->, which must return a pointer.
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.

Índice

[editar] Explicação

' Índice de matriz operador fornece acesso aos elementos do array interno
Original:
array subscript operator provides access to the elements in the internal array
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Indireção', membro do ponteiro e ponteiro para membro do ponteiro operadores fornecer semântica ponteiro para qualquer objeto.
Original:
indirection, member of pointer and pointer to member of pointer operators provide pointer semantics for any object.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Membro do ponteiro e ponteiro para membro do ponteiro operadores retornar um ponteiro para o objeto real que será usado para o acesso de membros.
Original:
member of pointer and pointer to member of pointer operators return a pointer to the actual object which will be used for member access.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[editar] Built-in operador subscrito

Para cada tipo de objeto T (possivelmente cv qualificado), a assinatura da função seguinte participa de resolução de sobrecarga:
Original:
For every object type T (possibly cv-qualified), the following function signature participates in overload resolution:
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
T& operator[](T*, std::ptrdiff_t);
T& operator[](std::ptrdiff_t, T*);
O operando não-ponteiro pode ser qualquer expressão do tipo enumeração integral ou sem escopo, é convertidos implicitamente para std::ptrdiff_t. A expressão A[B] é exactamente idêntico ao *(A+B) expressão, isto é, operando ponteiro (que pode ser um resultado da matriz-de-ponteiro de conversão, e que deve apontar para um elemento de matriz de um ou um após o final) é ajustado para ponto a outro elemento da mesma matriz, seguindo as regras de aritmética de ponteiro, e é então desreferenciado.
Original:
The non-pointer operand may be any expression of integral or unscoped enumeration type, it is convertidos implicitamente to std::ptrdiff_t. The expression A[B] is exactly identical to the expression *(A+B), that is, the pointer operand (which may be a result of array-to-pointer conversion, and which must point to an element of some array or one past the end) is adjusted to point at another element of the same array, following the rules of aritmética de ponteiro, and is then dereferenced.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
#include <iostream>
 
int main()
{
    int a[4] = {1,2,3,4};
    int* p = &a[2];
    std::cout << p[1] << p[-1] << 1[p] << (-1)[p] << '\n';
}

Output:

4242

[editar] Built-in operador de indireção

Para cada tipo de T que seja tipo de objeto (possivelmente cv-qualificado) ou tipo de função (não-const ou ref qualificado), a assinatura da função seguinte participa de resolução de sobrecarga:
Original:
For every type T that is either object type (possibly cv-qualified) or function type (not const- or ref-qualified), the following function signature participates in overload resolution:
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
T& operator*(T*);
O operando do operador de indireção built-in é um ponteiro para o objeto ou função, eo resultado é o lvalue que o ponteiro está apontando. Note-se que um ponteiro para tipo incompleto pode ser dereferenced, por exemplo, ao inicializar a referência.
Original:
The operand of the built-in indirection operator is a pointer to object or function, and the result is the lvalue that the pointer is pointing at. Note that a pointer to incomplete type can be dereferenced, e.g. when initializing a reference.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
#include <iostream>
int f() { return 42; }
int main()
{
    int n = 1;
    int* pn = &n;
 
    int& r = *pn;  // lvalue can be bound to a reference
    int m = *pn;   // indirection + lvalue-to-rvalue conversion
 
    int (*fp)() = &f;
    int (&fr)() = *fp; // function lvalue can be bound to a reference 
}


[editar] Built-in-endereço do operador

O operando do built-in operator& ou é uma expressão lvalue de qualquer tipo ou o nome qualificado de uma função membro não-static / objeto de alguma classe. Este operador não participa de resolução de sobrecarga, regras especiais são usados:
Original:
The operand of the built-in operator& is either an lvalue expression of any type or the qualified name of a non-static member function/object in some class. This operator does not participate in overload resolution, special rules are used:
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Se o operando é uma expressão lvalue de algum tipo T, operator& cria e retorna uma prvalue de T* tipo, com a qualificação cv mesmo, que está apontando para o objeto designado pelo operando. Se o operando tem o tipo incompleto, o ponteiro pode ser formado, mas se esse tipo incompleto passa a ser uma classe que define a sua própria operator&, o comportamento é indefinido. Para os operandos do tipo definido pelo utilizador com operator&, std::addressof pode ser usado para obter o ponteiro verdadeiro.
Original:
If the operand is an lvalue expression of some type T, operator& creates and returns a prvalue of type T*, with the same cv qualification, that is pointing at the object designated by the operand. If the operand has incomplete type, the pointer can be formed, but if that incomplete type happens to be a class that defines its own operator&, the behavior is undefined. For the operands of type with user-defined operator&, std::addressof may be used to obtain the true pointer.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Se o operando é o nome de uma função sobrecarregada, o endereço pode ser tomada se a sobrecarga pode ser resolvida devido ao contexto, ou seja, o resultado de' operator& é usado para inicializar um objeto, em uma expressão de conversão no lado esquerdo de uma atribuição, como um parâmetro da função ou uma instrução de retorno.
Original:
If the operand is the name of an overloaded function, the address may be taken only if the overload can be resolved due to context, that is, the result of operator& is used to initialize an object, in a cast expression, on the left of an assignment, as a function parameter or in a return statement.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Se o operando é um nome qualificado de um membro não-estático, por exemplo, &Class::member, o resultado é um ponteiro prvalue para função de membro ou ponteiro para objeto membro de T tipo em C classe. Note que nem &member nem Class::member nem mesmo (&Class::member) pode ser usado para inicializar um ponteiro ao membro.
Original:
If the operand is a qualified name of a non-static member, e.g. &Class::member, the result is a prvalue pointer to member function or pointer to member object of type T in class C. Note that neither &member nor Class::member nor even (&Class::member) may be used to initialize a pointer to member.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
void f(int) {}
void f(double) {}
struct A { int i; };
struct B { void f(); };
int main()
{
    int n = 1;
    int* pn = &n; // pointer
    int A::* mp = &A::i;  // pointer to member object
    void (B::*mpf)() = &B::f; // pointer to member function
 
//    auto pf2 = &f; // error: ambiguous overloaded function type
    void (*pf)(int) = &f; // overload resolution due to initialization
    auto pf2 = static_cast<void(*)(int)>(&f); // overload resolution due to cast
}


[editar] Built-in operadores de acesso de membros

O operando esquerdo do built-in operator. e operator-> é uma expressão do tipo classe completa T (para operator.) ou ponteiro para completar tipo de classe T* (para operator->, que é avaliada antes que o operador pode ser chamado. Operando direito é o nome do de um objeto de membro ou função membro de T ou de uma das aulas T de base, por exemplo, expr.member, opcionalmente qualificado expr.name::member, por exemplo, opcionalmente precedido pela palavra-chave modelo', por exemplo, expr.template member.
Original:
The left operand of the built-in operator. and operator-> is an expression of complete class type T (for operator.) or pointer to complete class type T* (for operator->, which is evaluated before the operator can be called. The right operand is the name of a member object or member function of T or of one of T's base classes, e.g. expr.member, optionally qualified, e.g. expr.name::member, optionally prepended by the keyword template, e.g. expr.template member.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
A->B A expressão é exatamente equivalente a (*A).B para tipos de embutidos. Se um operator-> definido pelo usuário é fornecida, operator-> é chamada novamente sobre o valor que ela retorna, de forma recursiva, até que o operator-> é atingido que retorna um ponteiro simples. Depois disso, a semântica embutidas são aplicadas a esse ponteiro.
Original:
The expression A->B is exactly equivalent to (*A).B for builtin types. If a user-defined operator-> is provided, operator-> is called again on the value that it returns, recursively, until the operator-> is reached that returns a plain pointer. After that, builtin semantics are applied to that pointer.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Na expr.B, expressão
Original:
In the expression expr.B,
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
1)
B se tem T& tipo, o resultado é um lvalue T.
Original:
if B has type T&, the result is an lvalue T.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
2)
B se é um membro de dados estático de T tipo, o resultado é um lvalue T designar esse membro de dados estático.
Original:
if B is a static data member of type T, the result is an lvalue T designating that static data member.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
3)
B se é um membro não-estático de dados T tipo, o resultado é um lvalue se expr é um lvalue, o resultado é xValue se expr é um xValue, e o resultado é uma prvalue contrário. B Se não for declarado de ser um membro mutável, a cv-qualificação do resultado é a união do CV-qualificações dos expr e B. B Se é mutável, a cv-qualificação do resultado é a união de voláteis-qualificações.
Original:
if B is a non-static data member of type T, the result is an lvalue if expr is an lvalue, the result is xvalue if expr is an xvalue, and the result is a prvalue otherwise. If B is not declared to be a mutable member, the cv-qualification of the result is the union of cv-qualifications of expr and B. If B is mutable, the cv-qualification of the result is the union of volatile-qualifications.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
4)
se B é uma função de membro estático, o resultado é um lvalue designando a função memeber estática. Essencialmente, expr é avaliado e descartado neste caso.
Original:
if B is a static member function, the result is an lvalue designating the static memeber function. Essentially, expr is evaluated and discarded in this case.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
5)
B se é uma função membro não-estático, o resultado é um tipo especial prvalue de que só pode ser usado como o operando à esquerda em uma expressão chamada de função, e para nenhum outro fim.
Original:
if B is a non-static member function, the result is a special kind of prvalue that can only be used as the left-hand operand in a function-call expression, and for no other purpose.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
6)
B se é um membro de enumeração, o resultado é um prvalue do.
Original:
if B is a member enumeration, the result is a prvalue of the.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
7)
B se é um tipo aninhado, o programa é mal-formado (não compilar)
Original:
if B is a nested type, the program is ill-formed (won't compile)
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
8)
expr se tem não-classe tipo escalar e B é o nome do tipo ou decltype especificador designar o mesmo tipo (menos CV-qualificações), então o resultado é um tipo especial de prvalue que só pode ser usado como o operando à esquerda em uma expressão chamada de função, e para nenhum outro fim. A chamada de função é chamado de chamada destruidor pseudo ', ele não tem argumentos, retorna void, e não executa nenhuma outra ação do que a avaliação inicial de expr.
Original:
if expr has non-class scalar type and B is the type name or decltype specifier designating the same type (minus cv-qualifications), then the result is a special kind of prvalue that can only be used as the left-hand operand in a function-call expression, and for no other purpose. The function call is called pseudo destructor call', it takes no arguments, returns void, and performs no action other than initial evaluation of expr.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
#include <iostream>
template<typename T>
struct P { typedef T* ptr; };
template<typename T>
struct A {
    class B {};
    enum E {RED = 1, BLUE = 2};
    int n;
    static int sn;
    int f() { return 10+n; }
    static int fs() { return 4; }
    A(int n) : n(n) {}
 
    // keyword template needed to refer to a dependent template member
    void g() {
        T obj;
        int* p = obj.template ptr<int>;
        p->~T(); // T is int, this calls int's pseudo destructor
    }
};
template<> int A<P<int>>::sn = 2;
 
int main()
{
    A<P<int>> a(1);
    std::cout << a.n << ' '
              << a.sn << ' ' // << A::sn also works
              << a.f() << ' ' 
              << a.fs() << ' ' // A::fs() also works
              << a.RED << ' '  // nested type not allowed
//            << a.B  // nested type not allowed
              ;
}

Output:

1 2 11 4 1

[editar] Built-in operadores ponteiro-para-membro de acesso

operando à direita de ambos operator.* e operator->* é uma expressão do tipo ponteiro para membro na classe T. Para operator.*, o operando esquerdo é uma expressão de T tipo de classe, ou de alguma classe derivada em que T é a base acessível inequívoca. Para operator->*, o operando esquerdo é um ponteiro para T ou à sua base.
Original:
The right operand of both operator.* and operator->* is an expression of type pointer to member in class T. For operator.*, the left operand is an expression of class type T, or of some derived class in which T is unambiguous accessible base. For operator->*, the left operand is a pointer to T or to its base.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Para cada combinação de tipos de B, D, T, onde D é o mesmo que o B ou uma classe derivada de B, e T é qualquer tipo de objeto ou função, a assinatura da função seguinte participa de resolução de sobrecarga:
Original:
For every combination of types B, D, T, where D is either the same as B or a class derived from B, and T is either object or function type, the following function signature participates in overload resolution:
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
T& operator->*(B*, T D::*);
onde ambos os operandos podem ser cv qualificado, caso em que o tipo de retorno do cv-qualificação é a união do. cv-qualificação dos operandos.
Original:
where both operands may be cv-qualified, in which case the return type's cv-qualification is the union of the cv-qualification of the operands.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
E1->*E2 A expressão é exatamente equivalente a (*E1).*E2 para tipos built-in.
Original:
The expression E1->*E2 is exactly equivalent to (*E1).*E2 for built-in types.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Para o expr.*ptr, expressão
Original:
For the expression expr.*ptr,
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
1)
Se o tipo de dinâmica de expr não contém o elemento ao qual se refere ptr , o comportamento é indefinido
Original:
If the dynamic type of expr does not contain the member to which ptr refers, the behavior is undefined
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
2)
cv-qualificação regras são as mesmas para operador de acesso de membro, com uma regra adicional:.. um ponteiro para membro que se refere a um mutável membro não pode ser usado para modificar o membro em um objeto const.
Original:
cv-qualification rules are the same as for member access operator, with one additional rule: a pointer to member that refers to a mutable member cannot be used to modify that member in a const object.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
4)
expr Se é rvalue e ptr aponta para uma função de membro com & ref-qualificação, o programa é mal-formado
Original:
If expr is rvalue and ptr points to a member function with & ref-qualifier, the program is ill-formed
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
5)
expr Se é lvalue e pontos ptr para uma função membro com && ref-qualificação, o programa é mal-formado
Original:
If expr is lvalue and ptr points to a member function with && ref-qualifier, the program is ill-formed
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
6)
O resultado expr.*ptr onde ptr é um ponteiro para o membro de dados tem o mesmo valor que a categoria expr.
Original:
The result of expr.*ptr where ptr is a pointer to data member has the same value category as expr.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
7)
O resultado expr.*ptr onde ptr é um ponteiro para função de membro é uma espécie de specail prvalue que só pode ser usado como o argumento do lado esquerdo de uma expressão chamada de função e para nenhum outro fim.
Original:
The result of expr.*ptr where ptr is a pointer to member function is a specail kind of prvalue that may only be used as the left-hand argument of a function call expression and for no other purpose.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
8)
ptr Se é um valor de ponteiro nulo, o comportamento é indefinido
Original:
If ptr is a null pointer value, the behavior is undefined
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
#include <iostream>
struct S
{
    mutable int mi;
    int f(int n) { return mi+n; }
    S(int n) : mi(n) {}
};
struct D : public S {
        D(int n) : S(n) {}
};
 
int main()
{
    int S::* pmi = &S::mi;
    int (S::*mpf)(int) = &S::f;
 
    const S s(7);
//    s.*pmi = 10; // cannot modify through mutable
    std::cout << s.*pmi << '\n';
 
    D d(7); // base pointers work with derived object
    D* dp = &d;
    std::cout << (d.*mpf)(7) << ' '
              << (dp->*mpf)(8) << '\n';
}

Output:

7
14 15

[editar] Biblioteca padrão

Operador de subscrito está sobrecarregado por muitas classes contêineres padrão
Original:
Subscript operator is overloaded by many standard container classes
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
acessa pouco específico
Original:
accesses specific bit
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(of std::bitset função pública membro) [edit]
fornece acesso indexado à matriz gerenciada
Original:
provides indexed access to the managed array
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(of std::unique_ptr função pública membro) [edit]
acesso de caracteres especificada
Original:
access specified character
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(of std::basic_string função pública membro) [edit]
acessar o elemento especificado
Original:
access specified element
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(of std::array função pública membro) [edit]
acessar o elemento especificado
Original:
access specified element
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(of std::deque função pública membro) [edit]
acessar o elemento especificado
Original:
access specified element
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(of std::vector função pública membro) [edit]
acessar o elemento especificado
Original:
access specified element
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(of std::map função pública membro) [edit]
acessar o elemento especificado
Original:
access specified element
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(of std::unordered_map função pública membro) [edit]
acessa um elemento pelo índice
Original:
accesses an element by index
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(of std::reverse_iterator função pública membro) [edit]
obtém rvalue referência ao elemento indexado
Original:
obtains rvalue reference to indexed element
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(of std::move_iterator função pública membro)
get / set elemento valarray, uma fatia ou máscara
Original:
get/set valarray element, slice, or mask
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(of std::valarray função pública membro) [edit]
retornos especificados sub-jogo
Original:
returns specified sub-match
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(of std::match_results função pública membro) [edit]
Os operadores de acesso indireç e membro está sobrecarregado por iteradores muitos e classes ponteiro inteligente
Original:
The indirection and member access operators are overloaded by many iterators and smart pointer classes
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
dereferences ponteiro para o objeto gerenciado
Original:
dereferences pointer to the managed object
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(of std::unique_ptr função pública membro) [edit]
dereferences ponteiro para o objeto gerenciado
Original:
dereferences pointer to the managed object
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(of std::shared_ptr função pública membro) [edit]
acessa o objeto gerenciado
Original:
accesses the managed object
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(of std::auto_ptr função pública membro)
devolve uma referência a esta raw_storage_iterator
Original:
returns a reference to this raw_storage_iterator
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(of std::raw_storage_iterator função pública membro)
dereferences o iterador decrementado subjacente
Original:
dereferences the decremented underlying iterator
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(of std::reverse_iterator função pública membro) [edit]
no-op
(of std::back_insert_iterator função pública membro)
no-op
(of std::front_insert_iterator função pública membro)
no-op
(of std::insert_iterator função pública membro)
acessa o elemento apontou-a
Original:
accesses the pointed-to element
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(of std::move_iterator função pública membro)
obtém uma cópia do atual element
accesses um membro do elemento atual
Original:
obtains a copy of the current element
accesses a member of the current element
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(of std::istream_iterator função pública membro)
no-op
(of std::ostream_iterator função pública membro)

(a partir do C++ 11)
obtém uma cópia do atual character
accesses um membro do personagem atual, se CharT tem membros
Original:
obtains a copy of the current character
accesses a member of the current character, if CharT has members
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(of std::istreambuf_iterator função pública membro)
no-op
(of std::ostreambuf_iterator função pública membro)
acessa os atuais match
accesses um membro do jogo atual
Original:
accesses the current match
accesses a member of the current match
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(of std::regex_iterator função pública membro)
acessa o atual result
accesses um membro do resultado atual
Original:
accesses the current result
accesses a member of the current result
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(of std::regex_token_iterator função pública membro)
{{{1}}}
Original:
{{{2}}}
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[editar] Veja também

Precedência do operador

Common operators
atribuição incrementNJdecrement aritmética lógico comparação memberNJaccess outro

a = b
a = rvalue
a += b
a -= b
a *= b
a /= b
a %= b
a &= b
a |= b
a ^= b
a <<= b
a >>= b

++a
--a
a++
a--

+a
-a
a + b
a - b
a * b
a / b
a % b
~a
a & b
a | b
a ^ b
a << b
a >> b

!a
a && b
a || b

a == b
a != b
a < b
a > b
a <= b
a >= b

a[b]
*a
&a
a->b
a.b
a->*b
a.*b

a(...)
a, b
(type) a
? :

Special operators
static_cast converte um tipo para outro
tipo compatível
Original:
static_cast converts one type to another compatible type
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
dynamic_cast converte classe base virtual para class
derivados
Original:
dynamic_cast converts virtual base class to derived class
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
const_cast converte tipo para tipo compatível com diferentes cv qualifiers
Original:
const_cast converts type to compatible type with different cv qualifiers
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
reinterpret_cast converte tipo de type
incompatíveis
Original:
reinterpret_cast converts type to incompatible type
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
new aloca memory
Original:
new allocates memory
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
delete desaloca memory
Original:
delete deallocates memory
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
sizeof consulta o tamanho de um type
Original:
sizeof queries the size of a type
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
sizeof... consulta o tamanho de um bloco de parâmetros (a partir do C++ 11)
Original:
sizeof... queries the size of a bloco de parâmetros (a partir do C++ 11)
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
typeid consulta o tipo de informação de uma type
Original:
typeid queries the type information of a type
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
noexcept verifica se uma expressão pode lançar uma (a partir do C++ 11)
exceção
Original:
noexcept checks if an expression can throw an exception (a partir do C++ 11)
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
alignof consultas exigências de alinhamento de um (a partir do C++ 11) tipo
Original:
alignof queries alignment requirements of a type (a partir do C++ 11)
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.