Operadores de atribuição e incremento: o que são e como usar

Neste artigo

1. O que é o operador de atribuição?
2. O que são os operadores de atribuição com operação?
3. O que são os operadores de incremento e decremento?
4. Como usar os operadores de atribuição em Python, PHP e C?
5. Aí você pergunta: qual é a diferença entre = e ==?
6. Quais são os erros mais comuns com a atribuição?
7. Agora é com você!

Operadores de atribuição são os sinais que guardam um valor em uma variável. O principal é o sinal de igual (=). Os operadores de incremento e decremento, ++ e –, somam ou subtraem 1 da variável.

No artigo sobre o laço for, o i++ aparecia no passo do laço sem muita explicação. Hoje você vai ver de onde ele vem. E, se você chegou pelo artigo da tabela verdade, pode ficar tranquilo: aqui a conversa volta a ser com números.

Algumas pessoas, quando leem ou escutam a palavra matemática, já começam a suar frio. Já vou te acalmando: em programação, quem faz a conta é a linguagem. Você só dá as ordens, com os sinais que já conhece: + para somar, – para subtrair, * para multiplicar, / para dividir e % para o resto da divisão. Quanto é 13 vezes 53, mais 789, menos 12 dividido por 4? Não precisa tentar resolver. O programa deste artigo resolve na última linha: 1475.

O que falta é a outra metade: onde guardar o resultado. Pense em uma gaveta com etiqueta. Atribuir é colocar um valor nessa gaveta. O que estava lá antes sai, e o valor novo fica.

O que é o operador de atribuição?

É o sinal de igual. Mas ATENÇÃO: na programação, ele não quer dizer “é igual a”. Ele quer dizer “recebe”. A variável do lado esquerdo recebe o valor da expressão do lado direito, e a ação acontece da direita para a esquerda.

Por isso o lado esquerdo tem de ser uma variável. Escrever 5 = a não faz sentido, e as linguagens recusam. Testei aqui: o GCC parou com o erro “lvalue required as left operand of assignment”, e o Python com “SyntaxError: cannot assign to literal here”.

O que são os operadores de atribuição com operação?

São atalhos para uma situação que se repete muito: fazer uma conta com a variável e guardar o resultado nela mesma. Em vez de escrever valor = valor + 5, você escreve valor += 5.

Na primeira versão deste artigo, eu somava uma variável com ela mesma, linha por linha, e avisei que aquilo parecia não fazer sentido nenhum. Agora dá para ver o sentido: com dobro += dobro dentro de um laço, o valor vai de 1 para 2, 4, 8 e 16. É assim que um programa acumula resultados.

ATENÇÃO: cuidado com a divisão. No Python, o teste com /= transformou 36 em 9.0, um número com casa decimal. Por isso o programa em Python usa //=, a divisão inteira. No PHP, 36 /= 4 deu o inteiro 9, mas 10 /= 4 deu 2.5.

O que são os operadores de incremento e decremento?

O ++ soma 1 à variável, e o — subtrai 1. Eles existem no C e no PHP e podem vir depois ou antes da variável:

• Pós-incremento (a++): entrega o valor atual e depois soma 1.
• Pré-incremento (++a): soma 1 e depois entrega o valor já aumentado.

Sozinhos em uma linha, os dois têm o mesmo efeito. A diferença só aparece quando o resultado é usado na mesma linha, como em b = a++.

Ver a animação do pós-incremento e do pré-incremento

No Python, o caminho é a += 1. Testei as duas escritas do C: a++ parou com “SyntaxError: invalid syntax”. Já ++a é pior, porque não dá erro nenhum e também não soma nada: o a continuou valendo 5.

Como usar os operadores de atribuição em Python, PHP e C?

Python:

# Operadores de atribuição e incremento: guardar e atualizar valores

valor = 10
print("Atribuição simples: valor = %d" % valor)

valor = valor + 5
print("valor = valor + 5 -> %d" % valor)

valor += 5
print("valor += 5 -> %d" % valor)
valor -= 8
print("valor -= 8 -> %d" % valor)
valor *= 3
print("valor *= 3 -> %d" % valor)
valor //= 4
print("valor /= 4 -> %d" % valor)
valor %= 5
print("valor %%= 5 -> %d" % valor)

# somar a variável com ela mesma: 1, 2, 4, 8, 16
dobro = 1
for i in range(4):
    dobro += dobro
    print("Dobrando: %d" % dobro)

# contador e acumulador
vendas = [20, 15, 25]
quantidade = 0
total = 0
for venda in vendas:
    quantidade += 1
    total += venda
print("Vendas contadas: %d, total: %d" % (quantidade, total))

# o Python não tem ++, então as duas etapas ficam escritas
a = 5
b = a       # pós-incremento: primeiro copia o valor...
a += 1      # ...depois soma 1
print("Pós-incremento: b recebeu %d e a ficou com %d" % (b, a))

a += 1      # pré-incremento: primeiro soma 1...
c = a       # ...depois copia o valor
print("Pré-incremento: c recebeu %d e a ficou com %d" % (c, a))

# a atribuição copia o valor: mudar x depois não muda y
x = 10
y = x
x = 99
print("Depois de mudar x: x = %d, y = %d" % (x, y))

# trocar dois valores com uma variável auxiliar
primeiro = 1
segundo = 2
auxiliar = primeiro
primeiro = segundo
segundo = auxiliar
print("Depois da troca: primeiro = %d, segundo = %d" % (primeiro, segundo))

conta = 13 * 53 + 789 - 12 // 4
print("13 * 53 + 789 - 12 / 4 = %d" % conta)

PHP:

<?php
// Operadores de atribuição e incremento: guardar e atualizar valores

$valor = 10;
printf("Atribuição simples: valor = %d\n", $valor);

$valor = $valor + 5;
printf("valor = valor + 5 -> %d\n", $valor);

$valor += 5;
printf("valor += 5 -> %d\n", $valor);
$valor -= 8;
printf("valor -= 8 -> %d\n", $valor);
$valor *= 3;
printf("valor *= 3 -> %d\n", $valor);
$valor /= 4;
printf("valor /= 4 -> %d\n", $valor);
$valor %= 5;
printf("valor %%= 5 -> %d\n", $valor);

// somar a variável com ela mesma: 1, 2, 4, 8, 16
$dobro = 1;
for ($i = 0; $i < 4; $i++) {
    $dobro += $dobro;
    printf("Dobrando: %d\n", $dobro);
}

// contador e acumulador
$vendas = [20, 15, 25];
$quantidade = 0;
$total = 0;
foreach ($vendas as $venda) {
    $quantidade++;
    $total += $venda;
}
printf("Vendas contadas: %d, total: %d\n", $quantidade, $total);

$a = 5;
$b = $a++;  // pós-incremento: primeiro copia o valor, depois soma 1
printf("Pós-incremento: b recebeu %d e a ficou com %d\n", $b, $a);

$c = ++$a;  // pré-incremento: primeiro soma 1, depois copia o valor
printf("Pré-incremento: c recebeu %d e a ficou com %d\n", $c, $a);

// a atribuição copia o valor: mudar x depois não muda y
$x = 10;
$y = $x;
$x = 99;
printf("Depois de mudar x: x = %d, y = %d\n", $x, $y);

// trocar dois valores com uma variável auxiliar
$primeiro = 1;
$segundo = 2;
$auxiliar = $primeiro;
$primeiro = $segundo;
$segundo = $auxiliar;
printf("Depois da troca: primeiro = %d, segundo = %d\n", $primeiro, $segundo);

$conta = 13 * 53 + 789 - intdiv(12, 4);
printf("13 * 53 + 789 - 12 / 4 = %d\n", $conta);

C:

/* Operadores de atribuição e incremento: guardar e atualizar valores */
#include <stdio.h>

int main(void) {
    int valor = 10;
    printf("Atribuição simples: valor = %d\n", valor);

    valor = valor + 5;
    printf("valor = valor + 5 -> %d\n", valor);

    valor += 5;
    printf("valor += 5 -> %d\n", valor);
    valor -= 8;
    printf("valor -= 8 -> %d\n", valor);
    valor *= 3;
    printf("valor *= 3 -> %d\n", valor);
    valor /= 4;
    printf("valor /= 4 -> %d\n", valor);
    valor %= 5;
    printf("valor %%= 5 -> %d\n", valor);

    /* somar a variável com ela mesma: 1, 2, 4, 8, 16 */
    int dobro = 1;
    for (int i = 0; i < 4; i++) {
        dobro += dobro;
        printf("Dobrando: %d\n", dobro);
    }

    /* contador e acumulador */
    int vendas[] = {20, 15, 25};
    int quantidade = 0;
    int total = 0;
    for (int i = 0; i < 3; i++) {
        quantidade++;
        total += vendas[i];
    }
    printf("Vendas contadas: %d, total: %d\n", quantidade, total);

    int a = 5;
    int b = a++;  /* pós-incremento: primeiro copia o valor, depois soma 1 */
    printf("Pós-incremento: b recebeu %d e a ficou com %d\n", b, a);

    int c = ++a;  /* pré-incremento: primeiro soma 1, depois copia o valor */
    printf("Pré-incremento: c recebeu %d e a ficou com %d\n", c, a);

    /* a atribuição copia o valor: mudar x depois não muda y */
    int x = 10;
    int y = x;
    x = 99;
    printf("Depois de mudar x: x = %d, y = %d\n", x, y);

    /* trocar dois valores com uma variável auxiliar */
    int primeiro = 1;
    int segundo = 2;
    int auxiliar = primeiro;
    primeiro = segundo;
    segundo = auxiliar;
    printf("Depois da troca: primeiro = %d, segundo = %d\n", primeiro, segundo);

    int conta = 13 * 53 + 789 - 12 / 4;
    printf("13 * 53 + 789 - 12 / 4 = %d\n", conta);
    return 0;
}

Saída:

Atribuição simples: valor = 10
valor = valor + 5 -> 15
valor += 5 -> 20
valor -= 8 -> 12
valor *= 3 -> 36
valor /= 4 -> 9
valor %= 5 -> 4
Dobrando: 2
Dobrando: 4
Dobrando: 8
Dobrando: 16
Vendas contadas: 3, total: 60
Pós-incremento: b recebeu 5 e a ficou com 6
Pré-incremento: c recebeu 7 e a ficou com 7
Depois de mudar x: x = 99, y = 10
Depois da troca: primeiro = 2, segundo = 1
13 * 53 + 789 - 12 / 4 = 1475

Foque no conceito, e não na linguagem! Três trechos do programa merecem um olhar com calma:

• Contador e acumulador: o contador soma 1 a cada venda (quantidade++), e o acumulador soma o valor da venda (total += venda). No fim, 3 vendas e total 60.
• A cópia não acompanha: y = x copia o valor. Quando o x muda para 99, o y continua com 10.
• Troca de valores: o programa usa uma terceira variável para guardar um dos valores enquanto o outro é copiado.

Aí você pergunta: qual é a diferença entre = e ==?

Um sinal de igual guarda. Dois sinais de igual comparam. Trocar um pelo outro dentro de um if muda tudo, e cada linguagem reage de um jeito. Testei if (x = 5), com o x valendo 3:

• C: compilou e rodou. O programa entrou no if e o x virou 5. Com a opção -Wall, o GCC avisa: “suggest parentheses around assignment used as truth value”.
• PHP: rodou do mesmo jeito, sem aviso nenhum.
• Python: recusou, com “SyntaxError: invalid syntax. Maybe you meant ‘==’ or ‘:=’ instead of ‘=’?”.

Quais são os erros mais comuns com a atribuição?

• Ler o = como “igual”. Em valor = valor + 5, a leitura certa é “valor recebe valor mais 5”.
• Usar = no lugar de == dentro do if. No C e no PHP, o programa roda e ainda muda a variável.
• Inverter os lados. O valor sempre vai da direita para a esquerda.
• Esperar que a cópia acompanhe a original. Depois de y = x, mudar o x não muda o y.
• Trocar dois valores sem a variável auxiliar. Com primeiro = segundo e depois segundo = primeiro, os dois terminam com o mesmo valor.
• Misturar pós e pré-incremento em uma conta. Com o a valendo 5, b = a++ guarda 5. Com o a valendo 6, c = ++a guarda 7.
• Usar ++ no Python. O a++ dá erro, e o ++a não faz nada.

Agora é com você!

No papel:

• O valor começa em 8. Depois de valor += 2, valor *= 3, valor -= 5 e valor %= 4, quanto ele vale?
• Em C, o a começa em 3. Depois de b = a++ e de c = ++a, quanto valem a, b e c?
• O x vale 4. Depois de y = x e de x += 1, quanto vale o y?

No computador:

• Conte quantas notas de um vetor são maiores que 6 e some todas as notas, usando um contador e um acumulador.
• Comece com o número 1 e dobre o valor 10 vezes, usando *=.
• Faça um rodízio com três variáveis: a primeira recebe o valor da segunda, a segunda o da terceira, e a terceira o da primeira.

Tente sozinho, sem pedir a resposta pronta para ninguém, nem para a IA!

No próximo artigo, o assunto é o escopo: onde cada variável existe dentro do programa. Até lá!

Confiança Sempre!!!

Fontes:

• PHP, manual oficial, operadores de atribuição, com o aviso de que o sinal não significa “é igual a”, os operadores combinados e a cópia do valor na atribuição.
• PHP, manual oficial, operadores de incremento e decremento, com o efeito do pré-incremento, do pós-incremento, do pré-decremento e do pós-decremento.
• Python, documentação oficial, referência da linguagem, Augmented assignment statements, com a atribuição que combina uma operação e a lista de operadores, como +=, -=, *=, /=, //= e %= (em inglês).
• Universidade Federal de Pernambuco, Centro de Informática, aula de Introdução à Programação sobre operadores, com o operador de atribuição executado da direita para a esquerda, diferente do igual da matemática, e os operadores de incremento prefixado e pós-fixado (PDF, slides de aula).
• Curso de C do CPDEE/UFMG, Operadores Aritméticos e de Atribuição, com os operadores aritméticos do C e os operadores ++ e –, pré-fixados e pós-fixados (cópia hospedada na PUC-SP).
• Unicamp, Instituto de Computação, MC102, aula 4, com os operadores de atribuição combinados e os operadores pós-fixados e pré-fixados (PDF, notas de aula).
• Universidade Federal de Campina Grande, Introdução à Programação, Programação com a Linguagem C, com o operador de incremento usado de maneira pós-fixada e pré-fixada (documento de aula).
• USP, e-Disciplinas, Linguagem C, com o pré-incremento, que incrementa antes e usa o valor depois, e o pós-incremento, que usa o valor primeiro e incrementa depois (PDF, slides de aula).
• IFRN, Fundamentos de Programação, aula 3, operadores e expressões, com o aviso para não confundir o operador de atribuição com o símbolo de igualdade e os exemplos de atribuições inválidas (PDF, slides de aula).
• USP, e-Disciplinas, notas sobre operadores, com o operador de atribuição, a atribuição associada a uma operação e os operadores de auto-incremento e auto-decremento.
• Os exemplos foram executados em Python 3.13, PHP 8.3 e GCC 13.