Comparison operators - cppreference.com
Espaços nominais
Variantes
    Ações

      Comparison operators

      De cppreference.com

      <metanoindex/>

       
      C++
       
      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)
      Conversões
      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
       
      Compara os argumentos.
      Original:
      Compares the arguments.
      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
      equal to a == b Yes bool T::operator ==(const T2 &b) const; bool operator ==(const T &a, const T2 &b);
      not equal to a != b Yes bool T::operator !=(const T2 &b) const; bool operator !=(const T &a, const T2 &b);
      less than a < b Yes bool T::operator <(const T2 &b) const; bool operator <(const T &a, const T2 &b);
      greater than a > b Yes bool T::operator >(const T2 &b) const; bool operator >(const T &a, const T2 &b);
      less than or equal to a <= b Yes bool T::operator <=(const T2 &b) const; bool operator <=(const T &a, const T2 &b);
      greater than or equal to a >= b Yes bool T::operator >=(const T2 &b) const; bool operator >=(const T &a, const T2 &b);
      '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.
      • Todos os operadores internos bool de retorno, e a maioria das definidas pelo utilizador sobrecargas também retornar bool de modo a que os operadores definidos pelo utilizador podem ser usados ​​da mesma maneira como o ins embutido. No entanto, numa definida pelo utilizador sobrecarga de operador, de qualquer tipo pode ser utilizado como tipo de retorno (incluindo void).
        Original:
        All built-in operators return bool, and most user-defined overloads also return bool 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).
        The text has been machine-translated via Google Translate.
        You can help to correct and verify the translation. Click here for instructions.
      • T2 pode ser de qualquer tipo, incluindo T
        Original:
        T2 can be any type including T
        The text has been machine-translated via Google Translate.
        You can help to correct and verify the translation. Click here for instructions.

      Explicação

      Retorna o resultado booleano de comparação dos valores dos argumentos, que não são modificados.
      Original:
      Returns the boolean result of comparison of the values of the arguments, which are not modified.
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.

      Comparação operadores aritméticos

      Para cada par de tipos aritméticos promovidas L e R, incluindo os tipos de enumeração, as assinaturas de função seguintes participar na resolução de sobrecarga:
      Original:
      For every pair of promoted arithmetic types L and R, including enumeration types, the following function signatures participate 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.
      <tbody> </tbody>
      bool operator<(L, R);
      bool operator>(L, R);
      bool operator<=(L, R);
      bool operator>=(L, R);
      bool operator==(L, R);
      bool operator!=(L, R);
      Se os operandos tem aritmética ou tipo de enumeração (escopo ou sem escopo),' conversões aritméticas usuais são realizadas seguindo as regras para operadores aritméticos. Os valores são comparados, após conversão:
      Original:
      If the operands has arithmetic or enumeration type (scoped or unscoped), usual arithmetic conversions are performed following the rules for operadores aritméticos. The values are compared after conversions:
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.

      Exemplo

      #include <iostream>
int main()
{
    std::cout << std::boolalpha;
    int n = -1;

    int n2 = 1;
    std::cout << " -1 == 1? " << (n == n2) << '\n'
              << "Comparing two signed values:\n"
              << " -1  < 1? " << (n < n2) << '\n'
              << " -1  > 1? " << (n > n2) << '\n';

    unsigned int u = 1;
    std::cout << "Comparing signed and unsigned:\n"
              << " -1  < 1? " << (n < u) << '\n'
              << " -1  > 1? " << (n > u) << '\n';

    unsigned char uc = 1;
    std::cout << "Comparing signed and smaller unsigned:\n"
              << " -1  < 1? " << (n < uc) << '\n'
              << " -1  > 1? " << (n > uc) << '\n';
}

      Saída: 

      -1 == 1? false
Comparing two signed values:
 -1  < 1? true
 -1  > 1? false
Comparing signed and unsigned:
 -1  < 1? false
 -1  > 1? true
Comparing signed and smaller unsigned:
 -1  < 1? true
 -1  > 1? false

      Comparação operadores ponteiro

      Para cada tipo de P que é ou ponteiro para objeto ou ponteiro para função ou std::nullptr_t, e para cada MP tipo que é um ponteiro para o objeto membro ou ponteiro para função de membro, as assinaturas de função seguintes participar na resolução de sobrecarga:
      Original:
      For every type P which is either pointer to object or pointer to function or std::nullptr_t, and for every type MP that is a pointer to member object or pointer to member function, the following function signatures participate 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.
      <tbody> </tbody>
      bool operator<(P, P);
      bool operator>(P, P);
      bool operator<=(P, P);
      bool operator>=(P, P);
      bool operator==(P, P);
      bool operator!=(P, P);
      bool operator==(MP, MP);
      bool operator!=(MP, MP);
      Os operadores de comparação pode ser usado para comparar dois ponteiros (ponteiros ou-a-membros, por operator== e operator!= apenas), ou um ponteiro e um ponteiro nulo constante, ou duas constantes de ponteiro nulo (mas apenas desde que pelo menos um deles é std::nullptr_t: comparação de NULL NULL e segue regras de comparação aritmética). Conversões de ponteiro (ponteiro para conversões membros se os argumentos são ponteiros para os membros) e conversões de qualificação são aplicados a ambos os operandos para obter o' tipo composto ponteiro, como segue
      Original:
      Comparison operators can be used to compare two pointers (or pointers-to-members, for operator== and operator!= only), or a pointer and a null pointer constant, or two null pointer constants (but only as long as at least one of them is std::nullptr_t: comparison of NULL and NULL follows arithmetic comparison rules). Conversões de ponteiro (pointer to member conversions if the arguments are pointers to members) and conversões de qualificação are applied to both operands to obtain the composite pointer type, as follows
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
      1)
      Se ambos os operandos são constantes ponteiro nulo, o tipo de ponteiro é composto std::nullptr_t
      Original:
      If both operands are null pointer constants, the composite pointer type is std::nullptr_t
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
      2)
      Se um operando uma constante de ponteiro nulo e o outro é um ponteiro, o tipo de composição é exactamente o tipo de ponteiro
      Original:
      If one operand a null pointer constant and the other is a pointer, the composite type is exactly the pointer type
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
      3)
      Se ambos os operandos são ponteiros para o mesmo tipo, com diferentes cv-qualificação, o compósito é ponteiro para o mesmo tipo com cv-qualificação, que é uma união dos-CV qualificações dos argumentos.
      Original:
      If both operands are pointers to the same type, with different cv-qualification, the composite is pointer to the same type with cv-qualification that is a union of the cv-qualifications of the arguments.
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
      Note-se que isto implica que qualquer indicador pode ser comparado com void*.
      Original:
      Note that this implies that any pointer can be compared with void*.
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
      Os resultados de comparação entre dois ponteiros (após conversão) são determinados como se segue:
      Original:
      Results of comparing two pointers (after conversions) are determined as follows:
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
      1)
      Se os ponteiros de p e q
      Original:
      If the pointers p and q
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
      a)
      apontar para o mesmo objeto ou função
      Original:
      point to the same object or function
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
      b)
      ou um ponto para além da extremidade da mesma matriz
      Original:
      or point one past the end of the same array
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
      c)
      ou são os dois ponteiros nulos
      Original:
      or are both null pointers
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
      em seguida, os ponteiros comparar igual: p==q, p<=q e p>=q retorno true, enquanto p!=q, p<q e p>q retorno false,
      Original:
      then the pointers compare equal: p==q, p<=q, and p>=q return true, while p!=q, p<q, and p>q return false,
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
      2)
      Se um dos operandos é um ponteiro nulo eo outro não é, eles comparam desigual: p==q retornos true, p!=q retornos false, o comportamento de outros operadores é indeterminado.
      Original:
      If one of the operands is a null pointer and the other is not, they compare unequal: p==q returns true, p!=q returns false, the behavior of other operators is unspecified.
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
      3)
      Se os ponteiros de p e q ponto aos membros da mesma matriz e a[i] a[j] ou um após o fim da matriz, que resulta da comparação entre os ponteiros é o mesmo que o resultado da comparação dos índices: i<j==true se então {{{1}}}.
      Original:
      If the pointers p and q point to members of the same array a[i] and a[j] or one past the end of the array, they results of comparing the pointers is the same as the result of comparing the indexes: if i<j==true then {{{1}}}.
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
      4)
      Se os ponteiros p e q ponto para membros não-estáticos de dados dentro de uma mesma classe ou subobjetos base diferentes dentro da mesma classe derivada, ou aos seus membros ou subobjetos, recursivamente, e se os membros apontados / subobjetos ter o controle de acesso à mesma (por exemplo, tanto public:), e da classe não é uma união, em seguida, o ponteiro para o subobjeto depois declarou / membro compara maior do que o ponteiro para o subobjeto anteriormente declarados / membro. Em outras palavras, os membros da classe em cada um dos três modos de acesso são posicionados na memória, a fim de declaração.
      Original:
      If the pointers p and q point to non-static data members within the same class or different base subobjects within the same derived class, or to their members or subobjects, recursively, and if the pointed-to members/subobjects have the same access control (e.g. both public:), and the class is not a union, then the pointer to the later declared subobject/member compares greater than the pointer to the earlier declared subobject/member. In other words, class members in each of the three access modes are positioned in memory in order of declaration.
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
      6)
      Se os ponteiros de p e q ponto aos membros da mesma union, comparam igual (tipicamente uma conversão explícita para void* é necessária para um dos operandos)
      Original:
      If the pointers p and q point to members of the same union, they compare equal (typically an explicit conversion to void* is required for one 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.
      7)
      Se um dos ponteiros é um ponteiro para void e tanto do ponto ponteiros para o mesmo endereço ou são ambos ponteiros nulos, eles comparam igual.
      Original:
      If one of the pointers is a pointer to void and both pointers point to the same address or are both null pointers, they compare equal.
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
      8)
      Se duas constantes ponteiro nulo são comparados, eles comparam igual.
      Original:
      If two null pointer constants are compared, they compare equal.
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
      9)
      Se ambos os operandos são ponteiros para membro (objeto ou função), eles comparam iguais se eles apontam tanto para o mesmo membro da classe derivada mais.
      Original:
      If both operands are pointers to member (object or function), they compare equal if they both point to the same member of the most derived class.
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
      10)
      Caso contrário (se as indicações apontam para objectos em matrizes diferentes, ou com diferentes funções, ou de membros de um objecto com o controlo de acesso diferente, etc), os resultados de p<q, p>q, p<=q e p>=q não são especificadas, e retorna p!=q false.
      Original:
      Otherwise (if the pointers point to objects in different arrays, or to different functions, or to members of some object with different access control, etc), the results of p<q, p>q, p<=q, and p>=q are unspecified, and p!=q returns false.
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.

      Exemplo

      #include <iostream>
struct Foo  { int n1; int n2; };
union Union { int n; double d; };
int main()
{
    std::cout << std::boolalpha;

    char a[4] = "abc";

    char* p1 = &a[1];
    char* p2 = &a[2];
    std::cout << "Pointers to array elements: p1 == p2 " << (p1 == p2)
              << ", p1 < p2 "  << (p1 < p2) << '\n';

    Foo f;
    int* p3 = &f.n1;
    int* p4 = &f.n2;
    std::cout << "Pointers to members of a class: p3 == p4 " << (p3 == p4)
              << ", p3 < p4 "  << (p3 < p4) << '\n';

    Union u;
    int* p5 = &u.n;
    double* p6 = &u.d;
    std::cout << "Pointers to members of a union: p5 == (void*)p6 " << (p5 == (void*)p6)
              << ", p5 < p6 "  << (p5 < (void*)p6) << '\n';
}

      Saída: 

      Pointers to array elements: p1 == p2 false, p1 < p2 true
Pointers to members of a class: p3 == p4 false, p3 < p4 true
Pointers to members of a union: p5 == (void*)p6 true, p5 < p6 false

      Notas

      Porque estes grupo de operadores da esquerda para a direita, o a<b<c expressão é analisada (a<b)<c, e não a<(b<c) ou (a<b)&&(b<c).
      Original:
      Because these operators group left-to-right, the expression a<b<c is parsed (a<b)<c, and not a<(b<c) or (a<b)&&(b<c).
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
      Um requisito comum para definido pelo usuário operator< é ordenação fraca rigorosa. Em particular, isso é exigido pelos algoritmos padrão e recipientes que trabalham com tipos LessThanComparable: std::sort, std::max_element, std::map, etc
      Original:
      A common requirement for user-defined operator< is ordenação fraca rigorosa. In particular, this is required by the standard algorithms and containers that work with LessThanComparable types: std::sort, std::max_element, std::map, etc.
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
      Embora os resultados da comparação entre os ponteiros de origem aleatória (por exemplo, nem todos os membros de apontar para a mesma matriz) é indeterminado, muitas implementações fornecer total de estrita ordenação de ponteiros, eg se forem implementadas como endereços dentro do espaço de endereços contínuo virtual. Essas implementações que não (por exemplo, em que nem todos os bits de ponteiro são parte de um endereço de memória e tem que ser ignoradas para efeitos de comparação, ou um cálculo adicional é necessária ou ponteiro e é um número inteiro não relação de 1 para 1), proporcionam uma especialização de std::less para ponteiros que tem essa garantia. Isto torna possível a utilização de todos os ponteiros de origem aleatória como chaves em recipientes padrão associativos, tais como std::set ou std::map.
      Original:
      Although the results of comparing pointers of random origin (e.g. not all pointing to members of the same array) is unspecified, many implementations provide total de estrita ordenação of pointers, e.g. if they are implemented as addresses within continuous virtual address space. Those implementations that do not (e.g. where not all bits of the pointer are part of a memory address and have to be ignored for comparison, or an additional calculation is required or otherwise pointer and integer is not a 1 to 1 relationship), provide a specialization of std::less for pointers that has that guarantee. This makes it possible to use all pointers of random origin as keys in standard associative containers such as std::set or std::map.
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
      Esta seção está incompleta
      Motivo: equivalence vs. equality

      Biblioteca padrão

      Os operadores de comparação são sobrecarregados para muitas classes da biblioteca padrão.
      Original:
      Comparison operators are overloaded for many classes in the standard library.
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.
      		 checks whether the objects refer to the same type
      (of std::type_info função pública membro) [edit]
      compara dois error_codes
      Original:
      compares two error_codes
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.

      (função)
      compara error_conditions e error_codes
      Original:
      compares error_conditions and error_codes
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.

      (função)
      lexicographically compara os valores do par
      Original:
      lexicographically compares the values in the pair
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.

      (modelo de função) [edit]
      lexicographically compara os valores na tupla
      Original:
      lexicographically compares the values in the tuple
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.

      (modelo de função) [edit]
      compara o conteúdo
      Original:
      compares the contents
      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]
      compara duas instâncias alocador
      Original:
      compares two allocator instances
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.

      (of std::allocator função pública membro) [edit]
      compara a outra ou com unique_ptr nullptr
      Original:
      compares to another unique_ptr or with nullptr
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.

      (modelo de função) [edit]
      compara com outro ou com shared_ptr nullptr
      Original:
      compares with another shared_ptr or with nullptr
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.

      (modelo de função) [edit]
      compara com um std::function std::nullptr
      Original:
      compares an std::function with std::nullptr
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.

      (modelo de função)
      compara duas durações
      Original:
      compares two durations
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.

      (modelo de função)
      compara dois pontos de tempo
      Original:
      compares two time points
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.

      (modelo de função)
      compara duas instâncias scoped_allocator_adaptor
      Original:
      compares two scoped_allocator_adaptor instances
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.

      (of std::scoped_allocator_adaptor função pública membro) [edit]
      compara os objetos std::type_info subjacentes
      Original:
      compares the underlying std::type_info objects
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.

      (of std::type_index função pública membro) [edit]
      lexicographically compara duas strings
      Original:
      lexicographically compares two strings
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.

      (modelo de função) [edit]
      comparação de igualdade entre os objetos de localidade
      Original:
      equality comparison between locale objects
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.

      (of std::locale função pública membro) [edit]
      lexicographically compara os valores na array
      Original:
      lexicographically compares the values in the array
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.

      (modelo de função) [edit]
      lexicographically compara os valores na deque
      Original:
      lexicographically compares the values in the deque
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.

      (modelo de função) [edit]
      lexicographically compara os valores na forward_list
      Original:
      lexicographically compares the values in the forward_list
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.

      (modelo de função) [edit]
      lexicographically compara os valores na list
      Original:
      lexicographically compares the values in the list
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.

      (modelo de função) [edit]
      lexicographically compara os valores na vector
      Original:
      lexicographically compares the values in the vector
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.

      (modelo de função) [edit]
      lexicographically compara os valores na map
      Original:
      lexicographically compares the values in the map
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.

      (modelo de função) [edit]
      lexicographically compara os valores na multimap
      Original:
      lexicographically compares the values in the multimap
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.

      (modelo de função) [edit]
      lexicographically compara os valores na set
      Original:
      lexicographically compares the values in the set
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.

      (modelo de função) [edit]
      lexicographically compara os valores na multiset
      Original:
      lexicographically compares the values in the multiset
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.

      (modelo de função) [edit]
      compara os valores na unordered_map
      Original:
      compares the values in the unordered_map
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.

      (modelo de função) [edit]
      compara os valores na unordered_multimap
      Original:
      compares the values in the unordered_multimap
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.

      (modelo de função) [edit]
      compara os valores na unordered_set
      Original:
      compares the values in the unordered_set
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.

      (modelo de função) [edit]
      compara os valores na unordered_multiset
      Original:
      compares the values in the unordered_multiset
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.

      (modelo de função) [edit]
      lexicographically compara os valores na queue
      Original:
      lexicographically compares the values in the queue
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.

      (modelo de função) [edit]
      lexicographically compara os valores na stack
      Original:
      lexicographically compares the values in the stack
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.

      (modelo de função) [edit]
      compara dois reverse_iterators para a igualdade
      Original:
      compares two reverse_iterators for equality
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.

      (modelo de função)
      reverse_iterators ordens
      Original:
      orders reverse_iterators
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.

      (modelo de função)
      compara dois move_iterators
      Original:
      compares two move_iterators
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.

      (modelo de função)
      compara dois istream_iterators
      Original:
      compares two istream_iterators
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.

      (modelo de função)
      compara dois istreambuf_iterators
      Original:
      compares two istreambuf_iterators
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.

      (modelo de função)
      compara dois números complexos ou um complexo e um escalar
      Original:
      compares two complex numbers or a complex and a scalar
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.

      (modelo de função) [edit]
      compara dois valarrays ou um valarray com um valor
      Original:
      compares two valarrays or a valarray with a value
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.

      (modelo de função) [edit]
      compara os estados internos de dois motores de números pseudo-aleatórios
      Original:
      compares the internal states of two pseudo-random number engines
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.

      (função) [edit]
      compara dois objetos de distribuição
      Original:
      compares two distribution objects
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.

      (função) [edit]
      lexicographically compara os valores no recipiente
      Original:
      lexicographically compares the values in the container
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.

      (função) [edit]
      lexicographically compara os valores em dois o resultado da partida
      Original:
      lexicographically compares the values in the two match result
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.

      (modelo de função)
      compara dois regex_iterators
      Original:
      compares two regex_iterators
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.

      (modelo de função)
      compara dois regex_token_iterators
      Original:
      compares two regex_token_iterators
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.

      (modelo de função)
      compara dois objetos thread::id
      Original:
      compares two thread::id objects
      The text has been machine-translated via Google Translate.
      You can help to correct and verify the translation. Click here for instructions.

      (função)
      		automatically generates comparison operators based on user-defined operator== and operator<
      (modelo de função) [edit]

      Veja também

      Precedência do operador