Operadores C++

Introdução

Neste laboratório, você aprenderá como usar operadores em C++. Você aprenderá como usar operadores aritméticos, operadores relacionais, operadores lógicos e operadores bitwise (bitwise operators).

Pré-visualização do Conteúdo

Para dados numéricos e lógicos básicos, usamos operadores para operar com eles. Como outras linguagens, C++ oferece suporte completo para operadores. Comece a aprendê-los.

• Operações Aritméticas
• Operações de Tipos Mistos
• Operadores de Atribuição Composta
• Type-Casting (Conversão de Tipos)
• Operadores Relacionais e Lógicos

Operações Aritméticas

C++ suporta os seguintes operadores aritméticos para números:

Todos os operadores acima são operadores binários, eles recebem dois operandos. A multiplicação, divisão e resto têm precedência sobre adição e subtração.

É importante notar que int/int produz um int, com o resultado truncado, 1/2 → 0 (não 0.5).

Operações de Tipos Mistos

Se ambos os operandos de uma operação aritmética pertencerem ao mesmo tipo, a operação é realizada nesse tipo, e o resultado pertence a esse tipo. No entanto, se os dois operandos pertencerem a tipos diferentes, o compilador promove o valor do tipo menor para o tipo maior (conhecido como implicit type-casting). A operação é então realizada no tipo maior.

Por exemplo

/* Testing mix-type arithmetic operations */
#include <iostream>
#include <iomanip>   // needed for formatting floating-point numbers
using namespace std;

int main() {
   int i1 = 2, i2 = 4;
   double d1 = 2.5, d2 = 5.0;

   // floating-points in fixed format with 1 decimal place
   cout<<fixed<<setprecision(1);

   cout << i1 << " + " << i2 << " = " << i1+i2 << endl;  // 6
   cout << d1 << " + " << d2 << " = " << d1+d2 << endl;  // 7.5
   cout << i1 << " + " << d2 << " = " << i1+d2 << endl;  // 7.0  <==

   cout << i1 << " - " << i2 << " = " << i1-i2 << endl;  // -2
   cout << d1 << " - " << d2 << " = " << d1-d2 << endl;  // -2.5
   cout << i1 << " - " << d2 << " = " << i1-d2 << endl;  // -3.0 <==

   cout << i1 << " * " << i2 << " = " << i1*i2 << endl;  // 8
   cout << d1 << " * " << d2 << " = " << d1*d2 << endl;  // 12.5
   cout << i1 << " * " << d2 << " = " << i1*d2 << endl;  // 10.0 <==

   cout << i1 << " / " << i2 << " = " << i1/i2 << endl;  // 0    <==
   cout << d1 << " / " << d2 << " = " << d1/d2 << endl;  // 0.5
   cout << i1 << " / " << d2 << " = " << i1/d2 << endl;  // 0.4  <==
   return 0;
}

Saída:

2 + 4 = 6
2.5 + 5.0 = 7.5
2 + 5.0 = 7.0
2 - 4 = -2
2.5 - 5.0 = -2.5
2 - 5.0 = -3.0
2 * 4 = 8
2.5 * 5.0 = 12.5
2 * 5.0 = 10.0
2 / 4 = 0
2.5 / 5.0 = 0.5

Overflow / Underflow

// Range of int is [-2147483648, 2147483647]
   int i1 = 2147483647;      // max int
   cout << i1 + 1 << endl;   // -2147483648 (overflow)
   cout << i1 * i1 << endl;  // 1

   int i2 = -2147483648;     // min int
   cout << i2 - 1 << endl;   // 2147483647 (underflow)
   cout << i2 * i2 << endl;  // 0

Em operações aritméticas, o valor resultante se repete (wraps around) se exceder seu intervalo. O tempo de execução do C++ não emite uma mensagem de erro/aviso, mas produz um resultado incorreto. É importante notar que a verificação de overflow/underflow é responsabilidade do programador.

Operadores de Atribuição Composta

C++ também fornece os chamados operadores de atribuição composta, conforme listados:

x = 5;
cout << x++ << endl;  // Save x (5); Increment x (=6); Print old x (5).
x = 5;
cout << ++x << endl;  // Increment x (=6); Print x (6).

Conversão de Tipos Implícita vs. Casting Explícito

Quando você atribui um valor de um tipo fundamental (embutido) a uma variável de outro tipo fundamental, C++ converte automaticamente o valor para o tipo receptor, se os dois tipos forem compatíveis. Por exemplo,

• Se você atribuir um valor int a uma variável double, o compilador automaticamente converte o valor int para um double (por exemplo, de 1 para 1.0) e o atribui à variável double.
• Se você atribuir um valor double a uma variável int, o compilador automaticamente converte o valor double para um valor int (por exemplo, de 1.2 para 1) e o atribui à variável int. A parte fracionária seria truncada e perdida. Alguns compiladores emitem um aviso/erro "possível perda de precisão"; outros não.

 int i;
 double d;

 i = 3;
 d = i;    // Assign an int value to double
 cout << "d = " << d << endl;  // 3.0

 d = 5.5;
 i = d;    // Assign a double value to int
 cout << "i = " << i << endl;  // 5 (truncated, no warning!)

Você pode realizar explicitamente o type-casting por meio do chamado operador de type-casting unário na forma de (new-type) operand ou new-type (operand). O operador de type-casting recebe um operando no tipo específico e retorna um valor equivalente no novo tipo. Observe que é uma operação que produz um valor resultante, semelhante a uma operação de adição, embora a adição envolva dois operandos. Por exemplo,

cout << (double)5 << endl;  // int 5 → double 5.0
cout << (int)5.5 << endl;   // double 5.5 → int 5

double aDouble = 5.6;
int anInt = (int)aDouble; // return 5 and assign to anInt. aDouble does not change!

// C++ also supports function-style type cast.
cout << double(5) << endl;     // 5.0
cout << int(5.5) << endl;      // 5
cout << int(aDouble) << endl;  // 5

Operadores Relacionais e Lógicos

Muitas vezes, você precisa comparar dois valores antes de decidir a ação a ser tomada. C++ fornece seis operadores de comparação (ou operadores relacionais):

As tabelas-verdade são as seguintes:

// Return true if x is between 0 and 100 (inclusive)
(x >= 0) && (x <= 100)
// wrong to use 0 <= x <= 100

// Return true if x is outside 0 and 100 (inclusive)
(x < 0) || (x > 100)   //or
!((x >= 0) && (x <= 100))

// Return true if year is a leap year
// A year is a leap year if it is divisible by 4 but not by 100, or it is divisible by 400.
((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0)

Resumo

Esta parte é relativamente fácil, você deve relacioná-la com a seção anterior. Não há necessidade de memorizá-los, mas sim de entender sua lógica.