CKTIS / C++
Operador de adição +
O operador binário + soma números ou desloca um ponteiro um número inteiro de elementos. Conheça as conversões de tipos, os limites da aritmética de ponteiros e os riscos de overflow.
Versão: C++23; repository compiler flag, production runtime not attested
Sintaxe
a + bO operador binário integrado + na expressão a + b calcula a soma de valores numéricos; não modifica, por si só, os operandos. As conversões aritméticas habituais determinam um tipo comum para os operandos e o resultado: por exemplo, 7 + 0.5 tem o tipo double e o valor 7.5. Os tipos inteiros pequenos são promovidos, pelo que a soma de dois valores short produz um resultado do tipo int.
Os operadores aditivos agrupam-se da esquerda para a direita: a + b + c significa (a + b) + c. A multiplicação tem precedência superior, pelo que a + b * c significa a + (b * c). O agrupamento não determina a ordem de avaliação dos operandos. O overflow do resultado de um tipo inteiro com sinal provoca comportamento indefinido. Os cálculos cujo resultado é um tipo inteiro sem sinal são efetuados módulo 2^N, em que N é a largura desse tipo; ao combinar tipos com e sem sinal, é necessário ter cuidado com as conversões.
Para um ponteiro p para um elemento de um array e um inteiro n, tanto p + n como n + p deslocam o ponteiro n elementos, não bytes. O tipo para o qual p aponta tem de ser um tipo de objeto completo e ser semelhante ao tipo dos elementos do array. Se p apontar para um elemento de um array declarado com extern cujo tipo de elemento ainda esteja incompleto no ponto em que se escreve a adição, p + 1 é uma expressão malformada, mesmo que o tipo para o qual p aponta e o tipo dos elementos sejam idênticos. O resultado tem de apontar para um elemento do mesmo array ou para a posição imediatamente a seguir ao seu fim; esta última posição não pode ser desreferenciada. Sair deste intervalo ou usar um ponteiro para um tipo que não seja semelhante ao dos elementos provoca comportamento indefinido. Por exemplo, somar 1 a um unsigned int* que aponta para um elemento de um array do tipo int[] provoca comportamento indefinido, mesmo que o elemento seguinte esteja dentro dos limites do array. Não é permitido somar dois ponteiros.
O operador unário +a é distinto e não corresponde à soma de dois valores. Os tipos definidos pelo utilizador podem definir operator+, cujo comportamento depende da sobrecarga selecionada; as regras acima descrevem o operador integrado. O exemplo mostra uma soma de inteiros, uma soma do tipo double, o deslocamento de um ponteiro e os valores inalterados de a e b. A fonte indicada é um rascunho de trabalho em evolução, não um texto C++23 definitivo.
Exemplos
#include <iostream>
int main() {
int a = 7;
int b = 5;
int values[] = {10, 20, 30};
int* p = values;
std::cout << a + b << '\n';
std::cout << a + 0.5 << '\n';
std::cout << *(p + 1) << '\n';
std::cout << a << ' ' << b << '\n';
}
Resultado
12 7.5 20 7 5
O código apresentado e o resultado declarado foram verificados num ambiente isolado pelo método registado na prova de verificação desta versão exata.