Série “Iniciando em C++” – Instruções

Neste artigo da série Iniciando em C++ você aprenderá o que são instruções e expressões e como se trabalha com operadores.

por Fabiano Maciel

Neste artigo da série Iniciando em C++ você aprenderá o que são instruções e expressões e como se trabalha com operadores.

Instruções

Na verdade, um programa nada mais é do que um conjunto de comandos executados em seqüência. Uma instrução controla a seqüência de execução, avalia uma expressão ou não faz nada (a instrução null). Todas as instruções em C++ terminam com um ponto-e-vírgula.

Uma instrução simples e comum é uma atribuição:

x = a + b;

Ao contrário da álgebra, essa instrução não significa que x é igual a a+b. Na verdade, ela é lida da seguinte maneira: "Atribua o valor da soma de a e b a x." ou "atribua a x, a + b". Muito embora essa instrução faça duas coisas, ela é uma instrução e, portanto, tem um ponto-e-vírgula. O operador de atribuição atribui qualquer coisa que esteja à direita de qualquer coisa que esteja à esquerda.

Espaço em branco

Os espaços, juntamente com as tabulações e as novas linhas, são chamados de espaços em branco. Em geral, o espaço em branco extra é ignorado pelo compilador; qualquer lugar no qual você veja um espaço pode colocar uma tabulação ou uma nova linha sem maiores problemas. A única finalidade de se incluir um espaço em branco é tornar o programa mais legível para os humanos; o compilador não perceberá a sua existência.

A instrução de atribuição poderia ter sido digitada como

x=a+b;

ou como

x = a+ b;

DICA: Use espaços em branco para tornar o código mais legível. Embora essa última variação seja aceita sem o menor problema, ela também é uma grande tolice. O espaço em branco deve ser usado para tornar os programas mais legíveis e fáceis de manter, mas também pode ser usado para criar um código indecifrável. Nesse caso, como em tudo o mais, a C++ fornece o poder; o julgamento é você quem faz.

Instruções compostas

Qualquer que seja o lugar no qual você coloque uma instrução simples, coloca também uma instrução composta. Instrução composta é uma instrução que comece com uma chave de abertura ({) e termine com uma chave de fechamento (}).

Embora todas as instruções em uma instrução composta devam terminar com um ponto e vírgula, a instrução composta em si não termina com um ponto-e-vírgula. Por exemplo:

{
    temp = a;
    a = b;
    b = temp;
}

Essa instrução composta alterna os valores nas variáveis a e b.

Expressões

Qualquer coisa que retorne um valor é uma expressão em C++.

Operadores

Um operador é um símbolo que faz com que o compilador execute uma ação.

Operador de atribuição

O operador de atribuição (=) faz o operando à esquerda do operador de atribuição ter seu valor alterado para o valor à direita do operador de atribuição. A expressão

x = a + b;

atribui o valor que resulta da adição de a e b ao operando x.

Um operando que pode estar legalmente à esquerda de um operador de atribuição é chamado de um valor e (esquerda). O que pode estar à direita é chamado (como pode imaginar) de valor d.

As constantes são valores d; elas não podem ser valores e. Dessa maneira, você pode digitar

x = 35; // OK

mas não pode digitar

35 = x; // erro, isso não é um valor e!

Valores E e valores D - Um valor E é um operando que pode estar à esquerda de uma expressão. Um valor D é um operando que pode estar à direita de uma expressão. Observe que todos os valores E são valores D, mas nem todos os valores D são valores E. Um exemplo de valor D que não é um valor E é uma literal. Desse modo, você pode digitar x = 5;, mas não pode digitar 5 = x;

Operadores matemáticos

Existem cinco operadores matemáticos: adição (+), subtração (-), multiplicação (*), divisão (/) e módulo (%). Adição, subtração e multiplicação agem como você está acostumado. O mesmo não acontece com a divisão.

A divisão de um inteiro apresenta algumas diferenças em relação à divisão cotidiana. Quando você divide 21 por 4, o resultado é um número real (um número com fração). Os inteiros não aceitam frações e, por essa razão, o "resto" é descartado. O valor retornado por 21 / 4 é 5.

O operador de módulo (%) retorna o valor do resto da divisão do inteiro.

Portanto, 21 % 4 é 1, pois 21/4 é 5 com um resto de 1.

Surpreendentemente, a descoberta do módulo tem lá sua utilidade. Por exemplo, pode ser que você deseje imprimir uma instrução a cada dez ações.

Sabe-se, no entanto, que qualquer número % 10 retornará 0 se o número for um múltiplo de 10. Assim, 20 % 10 é zero. 30 % 10 é zero. Combinando os operadores de atribuição e matemáticos

Não é raro querer adicionar um valor a uma variável e, em seguida, atribuir o resultado à variável. Em C++, você pode digitar

minhaIdade += 2;

Essa instrução aumenta o valor em minhaIdade por 2.

Incremento e decremento

O valor mais comum a ser adicionado (ou subtraído) e, em seguida, retribuído a uma variável é 1. Em C++, a adição de 1 a um valor é chamada de incrementação e a subtração de 1 é chamada de decrementação. Há operadores especiais para executar essas ações.

O operador de incremento (++) acrescenta 1 ao valor da variável e o operador de decremento (--) subtrai 1. Dessa forma, se você tem uma variável C, e deseja incrementa-la, tem que usar esta instrução:

C++; // começa com C e a incrementa em 1

Prefixo e sufixo

Tanto o operador de incremento (++) como o operador de decremento (--) têm duas versões: prefixo e sufixo. Prefixo - O operador é digitado antes do nome da variável (++minhaIdade). Sufixo - O operador é digitado depois do nome da variável (minhaIdade++).

Em uma instrução simples, faz pouca diferença usar um ou outro, mas, em uma instrução complexa, quando você incrementa (ou decrementa) uma variável e em seguida atribui o resultado a outra variável, tal ordem é de grande importância. O operador de prefixo é avaliado antes da atribuição e o sufixo é avaliado depois.

A semântica do prefixo é esta: incrementa o valor e, em seguida, o recupera. A semântica do sufixo é diferente: recupera o valor e, em seguida incrementa o original.

Isso em princípio pode parecer confuso, mas se X for um inteiro cujo valor é 5 e você digitar

int a = ++x;

estará instruindo o compilador a incrementar X (tornando-o 6) e, em seguida, recuperar o valor e atribuí-lo a A. Sendo assim, A agora é 6 e X agora é 6.

Se, depois disso, você digitar:

int b = x++;

estará instruindo o compilador a recuperar o valor de X (6) e atribuí-lo a B, e em seguida, retornar e incrementar X. Assim, B agora é 6, mas X agora é 7. O código abaixo demonstra o uso e as implicações de ambos os tipos.

Nas linhas 8 e 9, duas variáveis de inteiro são declaradas e cada uma delas é inicializada com o valor 39. O valor delas é impresso nas linhas 11 e 12.

Na linha 14, minhaIdade é incrementada usando o operador de incremento de sufixo, e na linha 15, suaIdade é incrementada usando o operador de incremento de prefixo. Os resultados são impressos nas linhas 18 e 19 e são idênticos (ambos são 40).

Na linha 21, minhaIdade é incrementada como parte da instrução de impressão, usando o operador de incremento de sufixo. Como é o sufixo, o incremento acontece depois da impressão e, portanto, o valor 40 é impresso novamente. Por outro lado, na linha 22, suaIdade é incrementada por meio do uso do operador de incremento de prefixo. Portanto, ele é incrementado antes de ser impresso e o valor é exibido como 41.

Finalmente, nas linhs 24 e 25, os valores são impressos novamente. Como a instrução de incremento foi concluída, o valor em minhaIdade agora é 41, pois esse é o valor em suaIdade. E este valor não é a minha idade real. J

Precedência

Na instrução complexa,

x = 5 + 3 * 8;

o que é executado primeiro, a adição ou a multiplicação? Se a adição for executada primeiro, a resposta será 8 * 8, ou seja, 64. Se a multiplicação for executada primeiro, a resposta será 5 + 24, ou seja, 29.

A multiplicação tem uma precedência maior do que a adição e, portanto, o valor da expressão acima é 29.

Quando dois operadores matemáticos têm a mesma precedência, eles são executados da esquerda para a direita. Dessa forma, em:

x = 5 + 3 + 8 * 9 + 6 * 4;

a multiplicação é a primeira operação a ser avaliada, da esquerda para a direita. Assim, 8*9 = 72, e 6*4 = 24. Agora a expressão é esta:

x = 5 + 3 + 72 + 24;

Agora a adição, da esquerda para a direita, é 5 + 3 = 8; 8 + 72 = 80; 80 + 24 = 104.

Tome cuidado com isso. Alguns operadores, como o de atribuição, são avaliados da direita para a esquerda! Em qualquer caso, e se a ordem de procedência não atender a suas necessidades? Considere a expressão

TotalSegundos = NumMinutosEsperar + NumMinutosTipo * 60;

Nessa expressão, você não deseja multiplicar a variável NumMinutosdoTipo por 60 e, em seguida adiciona-la a NumMinutosEsperar. Você deseja incluir as duas variáveis de modo a obter o número total de minutos e, em seguida, multiplicar esse número por 60 para obter o total de segundos.

Nesse caso, você usa parênteses para alterar a ordem de precedência. Os itens entre parênteses são avaliados como tendo uma precedência maior do que qualquer outro operador matemático. Dessa forma,

TotalSegundos = (NumMinutosEsperar + NumMinutosTipo) * 60;

apresentará o resultado desejado.

Aninhando parênteses

Em operações complexas, você precisará aninhar parênteses um dentro do outro. Por exemplo, pode necessitar computar o total de segundos e, em seguida, computar o número total de pessoas que estão envolvidas antes de multiplicar os segundos pelas pessoas:

TotalPessoasSegundos = (((NumMinutosEsperar + NumMinutosdoTipo) * 60) * (PessoasNoTrabalho + PessoasDeFerias));

Essa complicada expressão é lida de dentro para fora. Primeiro, NumMinutosEsperar é adicionado a NumMinutosdoTipo, pois esses são os parênteses mais internos. Em seguida, essa soma é multiplicada por 60; PessoasNoTrabalho é adicionado a PessoasDeFerias. Finalmente, o número total de pessoas encontrado é multiplicado pelo número total de segundos.

Esse exemplo suscita uma questão importante. Essa expressão é fácil de o computador entender, mas muito difícil de uma pessoa ler, entender ou modificar. Veja a seguir a mesma expressão digitada de uma outra maneira, usando algumas variáveis de inteiro temporárias:

TotalMinutos = NumMinutosEsperar + NumMinutosDoTipo;
TotalSegundos = TotalMinutos * 60;
TotalPessoas = PessoasNoTrabalho + PessoasDeFerias;
TotalPessoasSegundos = TotalPessoa * TotalSegundos;

Esse exemplo demanda mais tempo para ser digitado e usa mais variáveis temporárias do que o exemplo anterior, mas é bem mais fácil de entender. Preceda-o com um comentário para explicar o que o código faz e mude o 60 para uma constante simbólica. Assim terá um código que é fácil de entender e manter.

A natureza da verdade

Nas versões anteriores de C++, todas as verdades e falsidades eram representadas por inteiros, mas o novo padrão ISO/ANSI introduziu um novo tipo: bool. Esse novo tipo tem dois valores possíveis, false ou true.

Todas as expressões podem ser avaliadas conforme sua verdade ou falsidade. As expressões que matematicamente são avaliadas como zero retornarão false e todas as outras retornarão true.

Operadores relacionais

Os operadores relacionais são usados para determinar se dois números são iguais ou se um é maior ou menor que o outro. Todas as expressões relacionais retornam true ou false.

Existem seis operadores relacionais: igualdade (==), menor que (<), maior que (>), maior ou igual a (>=), menor ou igual a (<=) e diferente (!=).

Nesta lição você aprendeu o que são instruções, expressões e como se trabalha com operadores. O código acima pode ser baixado clicando aqui.