Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

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 + b

O 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.

Fontes