Retorna o resultado de uma operação aritmética específica.
| Nome do operador |
Sintaxe |
Sobrecarregável |
Exemplos de protótipos (para classe T) |
| Definição de classe interna |
Definição de classe externa |
| unário mais |
+a |
Sim |
T Toperador+() const; |
T operador+(const T &a); |
| unário menos |
-a |
Sim |
T TT: operador-() const; |
T operator-(const T &a); |
| adição |
a + b |
Sim |
T::operador+(const T2 &b) const; |
T operador+(const T &a, const T2 &b); |
| subtração |
a - b |
Sim |
T T::operador-(const T2 &b) const; |
T operador-(const T &a, const T2 &b); |
| multiplicação |
a * b |
Sim |
T T:operador*(const T2 &b) const; |
T operador*(const T &a, const T2 &b); |
| divisão |
a / b |
Sim |
T T:operador/(const T2 &b) const; |
T operador/(const T &a, const T2 &b); |
| modulo |
a % b |
Sim |
T T::operador%(const T2 &b) const; |
T operador%(const T &a, const T2 &b); |
| bitwise NOT |
~a |
Sim |
T TT : operator~() const; |
T operator~(const T &a); |
| bitwise AND |
a & b |
Yes |
T T::operador&(const T2 &b) const; |
T operador&(const T &a, const T2 &b); |
| bitwise OU |
a | b |
Sim |
T T:operador|(const T2 &b) const; |
T operador|(const T &a, const T2 &b); |
| bitwise XOR |
a ^ b |
Yes |
T T::operador^(const T2 &b) const; |
T operador^(const T &a, const T2 &b); |
| bitwise left shift |
a << b |
Yes |
T T::operador<<(const T2 &b) const; |
T operador<<(const T &a, const T2 &b); |
| bitwise right shift |
a >> b |
Sim |
T:operador>>(const T2 &b) const; |
T operador>>(const T &a, const T2 &b); |
Notas
- Todos os operadores incorporados retornam valores, e a maioria das sobrecargas definidas pelo usuário também retornam valores para que os operadores definidos pelo usuário possam ser usados da mesma forma que os built-ins. Entretanto, em uma sobrecarga de operador definida pelo usuário, qualquer tipo pode ser usado como tipo de retorno (incluindo void). Em particular, as sobrecargas de inserção e extração de fluxo de
operator<< e operator>> retorno T&.
-
T2 pode ser qualquer tipo incluindo T
|
- 1 Explicação
- 1.1 Conversões
- 1.2 Overflows
>
- 1.3 Ambiente de ponto flutuante
- 1.4 Contração do ponto flutuante
- 1.5 Operadores aritméticos unários
- 1.6 Operadores aditivos
>
- 1.7 Operadores multiplicativos
>
- 1.8 Operadores lógicos bitwise
>
- 1.9 Operadores bitwise shift
- 2 Biblioteca padrão
- 2.1 Operadores aritméticos unitários
- 2.2 Operadores aditivos
- 2.3 Operadores multiplicativos
- 2.4 Operadores lógicos bitwise
- 2.5 Operadores bitwise shift
- 2.6 Operadores de inserção/extração de fluxo
- 3 Relatórios de defeitos
- 4 Veja também
Explicação
Todos os operadores aritméticos computam o resultado de uma operação aritmética específica e retornam o seu resultado. Os argumentos não são modificados.
Conversões
Se o operando passado a um operador aritmético é do tipo enumeração integral ou não, então antes de qualquer outra ação (mas após a conversão lvalue-to-rvalue, se aplicável), o operando passa por uma promoção integral. Se um operando tiver tipo de array ou função, conversões aritméticas para ponto e função para ponto são aplicadas.
Para os operadores binários (exceto turnos), se os operandos promovidos tiverem tipos diferentes, um conjunto adicional de conversões implícitas é aplicado, conhecido como conversões aritméticas usuais com o objetivo de produzir o tipo comum (também acessível através do traço do tipo std::common_type). Se, antes de qualquer promoção integral, um operando for do tipo de enumeração e o outro do tipo de ponto flutuante ou de um tipo de enumeração diferente, este comportamento é depreciado. (desde C++20)
- Se um ou outro operando tiver um tipo de enumeração de escopo, não é efectuada qualquer conversão: o outro operando e o tipo de retorno devem ter o mesmo tipo
- Caso contrário, se um dos operandos for duplo longo, o outro operando é convertido para duplo longo
- Caso contrário, se um dos operandos for duplo, o outro operando é convertido para duplo
- Caso contrário, se um dos operandos é float, o outro é convertido em float
- Caso contrário, o operando tem tipo inteiro (porque bool, char, char8_t, char16_t, char32_t, wchar_t, e enumeração não copiada foram promovidos neste ponto) e conversões integrais são aplicadas para produzir o tipo comum, como se segue:
- Se ambos os operandos são assinados ou ambos não são assinados, o operando com menor grau de conversão é convertido para o operando com maior grau de conversão inteiro
- Caso contrário, se o grau de conversão do operando não assinado for maior ou igual ao grau de conversão do operando assinado, o operando assinado é convertido para o tipo do operando não assinado.
- Caso contrário, se o tipo do operando não assinado pode representar todos os valores do operando não assinado, o operando não assinado é convertido para o tipo do operando assinado
- Caso contrário, ambos os operandos são convertidos para o tipo do operando não assinado.
O grau de conversão acima aumenta em ordem bool, char assinado, curto, int, longo, longo. A classificação de qualquer tipo não assinado é igual à classificação do tipo correspondente assinado. O rank do char é igual ao rank do char assinado e do char não assinado. Os graus de char8_t, char16_t, char32_t e wchar_t são iguais aos graus dos seus tipos subjacentes.
Overflows
Aritmética de números inteiros não assinados é sempre executada modulo 2n
onde n é o número de bits nesse número inteiro em particular. Por exemplo, para int não assinado, adicionar um a UINT_MAX dá 0, e subtrair um de 0 dá UINT_MAX.
Quando a operação aritmética inteira assinada transborda (o resultado não cabe no tipo de resultado), o comportamento é indefinido, – as possíveis manifestações de tal operação incluem:
- envolve-se de acordo com as regras da representação (tipicamente o complemento de 2),
- trava – em algumas plataformas ou devido a opções de compilação (e.g.
-ftrapv em GCC e Clang),
- satura-se ao valor mínimo ou máximo (em muitos DSPs),
- é completamente optimizado pelo compilador.
Ambiente de ponto flutuante,
Se #pragma STDC FENV_ACCESS for suportado e definido para ON, todos os operadores aritméticos de ponto flutuante obedecem à direção atual de arredondamento do ponto flutuante e relatam erros aritméticos de ponto flutuante como especificado em matemática_errhandling a menos que parte de um inicializador estático (neste caso, as exceções de ponto flutuante não são levantadas e o modo de arredondamento está mais próximo)
Contração do ponto flutuante
Unless #pragma STDC FP_CONTRACT é suportado e ajustado para OFF, todas as aritméticas de ponto flutuante podem ser realizadas como se os resultados intermediários tivessem alcance e precisão infinitos, ou seja, são permitidas otimizações que omitem erros de arredondamento e exceções de ponto flutuante. Por exemplo, C++ permite a implementação de (x*y) + z com uma única instrução de CPU com múltiplos fusíveis ou otimização de a = x*x*x*x; como tmp = x *x; a = tmp*tmp.
Não relacionado à contratação, resultados intermediários da aritmética de ponto flutuante podem ter alcance e precisão diferentes dos indicados pelo seu tipo, ver FLT_EVAL_METHOD
Formalmente, o padrão C+++ não garante a precisão das operações de ponto flutuante.
Operadores aritméticos unários
As expressões dos operadores aritméticos unários têm a forma
| |
+ expressão |
(1) |
|
|
- expressão |
(2) |
|
|
1) unário mais (promoção).
Para o operador incorporado, a expressão deve ter aritmética, enumeração não copiada, ou tipo ponteiro. A promoção integral é realizada no operando se este tiver tipo de enumeração integral ou não e determina o tipo do resultado.
2) unário menos (negação).
Para o operador incorporado, a expressão deve ter tipo de enumeração aritmética ou não. A promoção integral é feita no operando e determina o tipo do resultado.
O operador unário mais embutido retorna o valor do seu operando. A única situação onde não é um no-op é quando o operando tem tipo integral ou tipo de enumeração não copiado, que é alterado por promoção integral, por exemplo, ele converte gráfico para int ou se o operando está sujeito a conversão de lvalue-to-rvalue, array-to-pointer, ou função-para-ponteiro.
O operador unário embutido menos calcula o negativo do seu operando promovido. Para não assinado a, o valor de -a é 2b
-a, onde b é o número de bits após a promoção.
Na resolução de sobrecarga contra operadores definidos pelo usuário, para cada tipo aritmético promovido A e para cada tipo T, as seguintes assinaturas de função participam da resolução de sobrecarga:
Um operador+(A)
|
|
T* operador+(T*)
|
|
Um operador-(A)
|
|
|
> |
|
#include <iostream>int main(){ char c = 0x6a; int n1 = 1; unsigned char n2 = 1; unsigned int n3 = 1; std::cout << "char: " << c << " int: " << +c << '\n' << "-1, where 1 is signed: " << -n1 << '\n' << "-1, where 1 is unsigned char: " << -n2 << '\n' << "-1, where 1 is unsigned int: " << -n3 << '\n'; char a; std::cout << "size of array: " << sizeof a << '\n' << "size of pointer: " << sizeof +a << '\n';}
Saída:
char: j int: 106-1, where 1 is signed: -1-1, where 1 is unsigned char: -1-1, where 1 is unsigned int: 4294967295size of array: 3size of pointer: 8
Operadores aditivos
As expressões dos operadores aritméticos aditivos binários têm a forma
|
lhs + rhs |
(1) |
|
|
lhs - rhs |
(2) |
|
|
1) adição
Para a construção…em operador, lhs e rhs deve ser uma das seguintes:
- ambos têm tipo de enumeração aritmética ou não. Neste caso, as conversões aritméticas usuais são realizadas em ambos os operandos e determinam o tipo do resultado.
- um é um ponteiro para tipo de objeto completamente definido, o outro tem tipo de enumeração integral ou não-copiada. Neste caso, o tipo de resultado tem o tipo do ponteiro.
2) subtração
Para o operador incorporado, lhs e rhs devem ser um dos seguintes:
- ambos têm tipo de enumeração aritmética ou não-copiada. Neste caso, as conversões aritméticas usuais são realizadas em ambos os operandos e determinam o tipo do resultado.
- lhs é um ponteiro para tipo de objeto completamente definido, rhs tem tipo de enumeração integral ou não. Neste caso, o tipo de resultado tem o tipo do ponteiro.
- ambos são ponteiros para os mesmos tipos de objetos completamente definidos, ignorando os cv-qualifiers. Neste caso, o tipo de resultado é std::ptrdiff_t.
Com operandos do tipo aritmético ou enumeração, o resultado do mais binário é a soma dos operandos (após as habituais conversões aritméticas), e o resultado do operador menos binário é o resultado de subtrair o segundo operando do primeiro (após as habituais conversões aritméticas), excepto que, se o tipo suportar aritmética de ponto flutuante IEEE (ver std::numeric_limits::is_iec559),
- se um operando for NaN, o resultado é NaN
- infinito menos infinito é NaN e FE_INVALID é elevado
- infinito mais o infinito negativo é NaN e FE_INVALID é elevado
Se algum dos operandos for um ponteiro, aplicam-se as seguintes regras:
- Um ponteiro para um objecto não-arranjado é tratado como um ponteiro para o primeiro elemento de um array com tamanho 1.
- Se o ponteiro
P aponta para o elemento i de um array, então as expressões P+n, n+P, e P-n são apontadores do mesmo tipo que apontam para o elemento i+nth, i+nth, e i-nth do mesmo array, respectivamente. O resultado da adição de ponteiro também pode ser um ponteiro de uma parte (ou seja, ponteiro P, de tal forma que a expressão P-1 aponta para o último elemento do array). Quaisquer outras situações (isto é, tentativas de gerar um ponteiro que não esteja apontando para um elemento do mesmo array ou um além do fim) invocam comportamento indefinido.
- Se o ponteiro
P aponta para o elemento i de um array, e o ponteiro Q aponta para o elemento j do mesmo array, a expressão P-Q tem o valor i-j, se o valor cabe em std::ptrdiff_t. Ambos os operandos devem apontar para os elementos do mesmo array (ou um além do fim), caso contrário o comportamento é indefinido. Se o resultado não cabe em std::ptrdiff_t, o comportamento é indefinido.
- Em qualquer caso, se o pointed-totype for diferente do tipo de elemento do array, desconsiderando as qualificações cv, em todos os níveis se os elementos são apontadores, o comportamento da aritmética do ponteiro é indefinido. Em particular, aritmética de ponteiro com ponteiro para base, que está apontando para um elemento de um array de objetos derivados é indefinido.
- Se o valor 0 é adicionado ou subtraído de um ponteiro, o resultado é o ponteiro, inalterado. Se dois ponteiros apontam para o mesmo objeto ou ambos são um além do fim do mesmo array, ou ambos são ponteiros nulos, então o resultado da subtração é igual a (std::ptrdiff_t)0.
Estes operadores aritméticos de ponteiro permitem ponteiros para satisfazer os requisitos do LegacyRandomAccessIterator.
Em resolução de sobrecarga contra operadores definidos pelo usuário, para cada par de tipos aritméticos promovidos L e R e para cada tipo de objeto T, as seguintes assinaturas de funções participam da resolução de sobrecarga:
LR operator+(L, R)
|
|
LR operator-(L, R)
|
|
T* operator+(T*, std::ptrdiff_t)
|
|
T* operator+(std::ptrdiff_t, T*)
|
|
T* operator-(T*, std::ptrdiff_t)
|
|
std::ptrdiff_t operator-(T*, T*)
|
|
|
> |
|
Onde LR é o resultado do habitual conversões aritméticas em L e R
#include <iostream>int main(){ char c = 2; unsigned int un = 2; int n = -10; std::cout << " 2 + (-10), where 2 is a char = " << c + n << '\n' << " 2 + (-10), where 2 is unsigned = " << un + n << '\n' << " -10 - 2.12 = " << n - 2.12 << '\n'; char a = {'a', 'b', 'c', 'd'}; char* p = &a; std::cout << "Pointer addition examples: " << *p << *(p + 2) << *(2 + p) << *(p - 1) << '\n'; char* p2 = &a; std::cout << "Pointer difference: " << p2 - p << '\n';}
Output:
>
2 + (-10), where 2 is a char = -8 2 + (-10), where 2 is unsigned = 4294967288 -10 - 2.12 = -12.12Pointer addition examples: bddaPointer difference: 3
Operadores multiplicativos
As expressões dos operadores aritméticos multiplicativos binários têm a forma
|
lhs * rhs |
(1) |
> |
|
lhs / rhs |
(2) |
|
|
lhs % rhs |
(3) |
|
|
1) multiplicação
Para a construção…em operador, lhs e rhs devem ter ambos tipo de enumeração aritmética ou não.
2) divisão
Para o operador incorporado, a ESL e a ERS devem ambos ter tipo de enumeração aritmética ou não.
3) restante
Para o operador embutido, lhs e rhs devem ambos ter tipo de enumeração integral ou não-copiada
Para os três operadores, as conversões aritméticas usuais são realizadas em ambos os operandos e determinam o tipo do resultado.
O operador binário * efectua a multiplicação dos seus operandos (após as habituais conversões aritméticas), excepto que, para a multiplicação por vírgula flutuante,
- multiplicação de um NaN por qualquer número dá NaN
- multiplicação do infinito por zero dá NaN e FE_INVALID é elevado
O operador binário / divide o primeiro operando pelo segundo (após as habituais conversões aritméticas).
Para operandos integrais, produz o quociente algébrico.
|
O quociente é arredondado na direcção definida pela implementação.
|
(até C++11) |
|
O quociente é truncado para zero (parte fracionária é descartada).
|
(desde C+++11) |
Se o segundo operando for zero, o comportamento é indefinido, excepto que se a divisão de vírgula flutuante estiver a ocorrer e o tipo suportar a aritmética de vírgula flutuante IEEE (ver std:Limites_ numéricos::is_iec559), depois:
- se um operando for NaN, o resultado é NaN
- dividindo um número diferente de zero por ±0.0 dá o infinito corretamente assinado e FE_DIVBYZERO é elevado
- dividindo 0,0 por 0,0 dá NaN e FE_INVALID é elevado
O operador binário % rende o resto da divisão inteira do primeiro operando pelo segundo (após as conversões aritméticas usuais; observe que os tipos de operando devem ser tipos integrais). Se o quociente a/b for representavel no tipo de resultado, (a/b)*b + a%b == a. Se o segundo operando for zero, o comportamento é indefinido. Se o quociente a/b não é representavel no tipo de resultado, o comportamento de ambos a/b e a%b é indefinido (isto significa que INT_MIN%-1 é indefinido em sistemas complementares de 2)
Note: Até C++11, se um ou ambos os operandos para o operador binário % eram negativos, o sinal do resto era definido pela implementação, pois depende do sentido de arredondamento da divisão inteira. A função std::div forneceu comportamento bem definido nesse caso.
Nota: para o resto do ponto flutuante, ver std::restante e std::fmod.
Em resolução de sobrecarga contra operadores definidos pelo usuário, para cada par de tipos aritméticos promovidos LA e RA e para cada par de tipos integrais promovidos LI e RI as seguintes assinaturas de funções participam da resolução de sobrecarga:
operador LRA*(LA, RA)
|
|
operador LRA/(LA, RA)
|
|
operador LRI%(LI, RI)
|
|
|
> |
|
Onde LRx é o resultado do habitual conversões aritméticas em Lx e Rx
#include <iostream>int main(){ char c = 2; unsigned int un = 2; int n = -10; std::cout << "2 * (-10), where 2 is a char = " << c * n << '\n' << "2 * (-10), where 2 is unsigned = " << un * n << '\n' << "-10 / 2.12 = " << n / 2.12 << '\n' << "-10 / 21 = " << n / 21 << '\n' << "-10 % 21 = " << n % 21 << '\n';}
Output:
2 * (-10), where 2 is a char = -202 * (-10), where 2 is unsigned = 4294967276-10 / 2.12 = -4.71698-10 / 21 = 0-10 % 21 = -10
Os operadores lógicos bitwise
As expressões dos operadores aritméticos bitwise têm a forma
|
~ rhs |
(1) |
|
|
lhs & rhs |
(2) |
|
|
lhs | rhs |
(3) |
|
|
lhs ^ rhs |
(4) |
|
|
1) bitwise NOT
2) bitwise AND
3) bitwise OR
4) bitwise XOR
Para a construção…nos operadores, lhs e rhs devem ter ambos tipo de enumeração integral ou não. As conversões aritméticas usuais são realizadas em ambos os operandos e determinam o tipo do resultado.
O resultado do operador~ é o valor bitwise NOT (one’s complement) do argumento (após promoção). O resultado do operador& é o valor bitwise AND dos operandos (após as habituais conversões aritméticas). O resultado do operador| é o valor bitwise OR dos operandos (após as conversões aritméticas usuais). O resultado do operador^ é o valor bitwise XOR dos operandos (após as conversões aritméticas usuais)
Na resolução de sobrecarga contra operadores definidos pelo usuário, para cada par de tipos de integrais promovidos L e R as seguintes assinaturas de funções participam da resolução de sobrecarga:
operador de R~(R)
|
|
operador de LR&(L, R)
|
|
LR operator^(L, R)
|
|
LR operator|(L, R)
|
|
|
> |
|
Onde LR é o resultado do habitual conversões aritméticas em L e R
#include <iostream>int main(){ std::cout << std::hex << std::showbase; uint16_t mask = 0x00f0; uint32_t a = 0x12345678; std::cout << "Value: " << a << " mask: " << mask << '\n' << "Setting bits: " << (a | mask) << '\n' << "Clearing bits: " << (a & ~mask) << '\n' << "Selecting bits: " << (a & mask) << '\n';}
Output:
Value: 0x12345678 mask: 0xf0Setting bits: 0x123456f8Clearing bits: 0x12345608Selecting bits: 0x70
Operadores de turno bitwise
As expressões dos operadores de turno bitwise têm a forma
|
lhs << rhs |
(1) |
|
|
lhs >> rhs |
(2) |
|
|
1) deslocamento à esquerda de lhs por bits de rhs
2) deslocamento à direita de lhs por bits de rhs
Para a construção…nos operadores, lhs e rhs devem ter ambos tipo de enumeração integral ou não. As promoções integrais são realizadas em ambos operandos.
O tipo de retorno é o tipo do operando esquerdo após as promoções integrais.
|
Para não assinado a, o valor de a << b é o valor de a * 2b
, modulo reduzido 2N
onde N é o número de bits no tipo de retorno (ou seja, o deslocamento à esquerda do bit é realizado e os bits que são deslocados para fora do tipo de destino são descartados).
Para assinado e não-negativo a, se a * 2b
é representavel na versão não assinada do tipo de retorno, então esse valor, convertido em assinado, é o valor de a << b (isto torna legal criar INT_MIN como 1<<31); caso contrário o comportamento é indefinido.
Para negativo a, o comportamento de a << b é indefinido.
Para não assinado a e para assinado e não-negativo a, o valor de a >> b é a parte inteira de a/2b
.
Para negativo a, o valor de a >> b é definido pela implementação (na maioria das implementações, isto realiza um deslocamento aritmético para a direita, de modo que o resultado permaneça negativo).
|
(até C++20) |
|
O valor de a << b é o valor único congruente a um * 2b
modulo 2N
onde N é o número de bits no tipo de retorno (ou seja, o deslocamento bit a bit para a esquerda é realizado e os bits que são deslocados para fora do tipo de destino são descartados).
O valor de a >> b é a/2b
, arredondado para baixo (em outras palavras, deslocamento à direita no sinal a é deslocamento aritmético à direita).
|
(desde C++20) |
Em qualquer caso, se o valor do operando direito for negativo ou for maior ou igual ao número de bits no operando esquerdo promovido, o comportamento é indefinido.
Em resolução de sobrecarga contra operadores definidos pelo usuário, para cada par de tipos de integral promovidos L e R, as seguintes assinaturas de funções participam da resolução de sobrecarga:
L operador<<(L, R)
|
|
L operador>>(L, R)
|
|
|
> |
|
#include <iostream>enum {ONE=1, TWO=2};int main(){ std::cout << std::hex << std::showbase; char c = 0x10; unsigned long long ull = 0x123; std::cout << "0x123 << 1 = " << (ull << 1) << '\n' << "0x123 << 63 = " << (ull << 63) << '\n' // overflow in unsigned << "0x10 << 10 = " << (c << 10) << '\n'; // char is promoted to int long long ll = -1000; std::cout << std::dec << "-1000 >> 1 = " << (ll >> ONE) << '\n';}
Saída:
>
0x123 << 1 = 0x2460x123 << 63 = 0x80000000000000000x10 << 10 = 0x4000-1000 >> 1 = -500
Biblioteca padrão
Operadores aritméticos estão sobrecarregados para muitos tipos de biblioteca padrão.
Operadores aritméticos unários
implementos unários + e unários –
(função de membro público de std::chrono::duration<Rep,Period>) |
aplica operadores unários a números complexos
(modelo de função) |
aplica um operador aritmético unário a cada elemento do valarray
(função de membro público de std::valarray<T>) |
Operadores aditivos
executa operações de adição e subtração envolvendo um ponto temporal
(function template) |
implementa operações aritméticas com durações como argumentos
(function template) |
adiciona ou subtrai um year_month_day e alguns número de anos ou meses
(função de membro público de std::chrono::year_month_day) |
concatena duas cordas ou uma string e um char
(modelo de função) |
avança ou decreta o iterador
(função de membro público de std::reverse_iterator<Iter>) |
avança ou decreta o iterador
(função de membro público de std::move_iterator<Iter>) |
executa aritmética de números complexos em dois valores complexos ou um complexo e um escalar
(modelo de função) |
aplica operadores binários a cada elemento de dois valarrays, ou um valarray e um valor
(function template) |
operadores multiplicativos
implementa operações aritméticas com durações como argumentos
(function template) |
executa aritmética de números complexos em dois valores complexos ou um complexo e um escalar
(function template) |
aplica operadores binários a cada elemento de dois valarrays, ou um valarray e um valor
(function template) |
Operadores lógicos Bitwise
executa binários AND, OR, XOR e NOT
(função de membro público de std::bitset<N>) |
realiza operações lógicas binárias em bitsets
(function template) |
aplica um operador aritmético unário a cada elemento do valarray
(função de membro público de std::valarray<T>) |
aplica operadores binários a cada elemento de dois valarrays, ou um valarray e um valor
(function template) |
Operadores Bitwise shift
aplica operadores binários a cada elemento de dois valarrays, ou um valarray e um valor
(function template) |
executa deslocamento binário para a esquerda e deslocamento para a direita
(public member function of std::bitset<N>) |
Operadores de inserção/extração de fluxo
Através da biblioteca padrão, os operadores de deslocamento bitwise são comumente sobrecarregados com fluxo I/O (std:ios_base& ou uma das classes derivadas dela) tanto como operando à esquerda como como tipo de retorno. Tais operadores são conhecidos como operadores de inserção e extração de fluxo:
extrai dados formatados
(função de membro público de std::basic_istream<CharT,Traits>) |
extrai caracteres e matrizes de caracteres
(function template) |
insere dados formatados
(função de membro público de std::basic_ostream<CharT,Traits>) |
insere dados de caracteres
(function template) |
serializa e desserializa um número complexo
(function template) |
executa entrada e saída de stream de bits
(function template) |
executa entrada e saída de stream em strings
(function template) |
executa entrada e saída de stream em pseudo-motor de número aleatório
(function template) |
executa a entrada e saída do fluxo na distribuição de números pseudo-aleatória
(function template) |
Relatórios de defeitos
Os seguintes relatórios de defeitos com mudança de comportamento foram aplicados retroativamente aos padrões C++ anteriormente publicados.
| DR |
Aplicado a |
Comportamento como publicado |
Comportamento correcto |
| CWG 1457 |
C+++98 |
deslocando o mais à esquerda 1 um bit de um valor de sinal positivo para o bit de sinal foi UB |
feito bemdefinido |
Ver também
Prioridade do operador
Sobrecarga do operador
| Operadores comuns |
| atribuição |
incremento
adiminuição |
aritmética |
lógica |
comparação |
membro
acesso |
outros |
|
a = b
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 <a >>> b
|
>
!a
a && b
a || b
|
a == b
a != b
a < b
a > b
a <= b
a >= b
a <=> b
> |
a
*a
&a
a->b
a.b
a->*b
a.*b
|
a(…)
a, b
? :
|
| Operadores especiais |
|
static_cast converte um tipo para outro tipo relacionado
dinamic_cast converte dentro de hierarquias de herança
const_cast adiciona ou remove qualificadores de cv
reinterpret_cast converte tipo para tipo não relacionado
c fundido estilo C converte um tipo para outro por uma mistura de static_cast, const_cast, e reinterpret_cast
novo cria objetos com duração de armazenamento dinâmico
apagar destrói objetos previamente criados pela nova expressão e libera a área de memória obtida
dimensão de consultas do tamanho de um tipo
dimensão de…. consulta o tamanho de um pacote de parâmetros (desde C++11)
size of queries the size of a type information of a type
noexceto verifica se uma expressão pode lançar uma exceção (desde C++11)
alignof queries alignment requirements of a type (since C+++11)
|
documentação C para operadores aritméticos