Um operador aritmético, como o nome sugere, é um operador que permite criar expressões aritméticas para a realização de cálculos matemáticos em u programa, geralmente com a elaboração e aplicação de fórmulas matemáticas comuns.

A linguagem C++ possui suporte aos tipos básicos de operadores aritméticos, que cobrem as quatro operações fundamentais da matemática (soma, subtração, multiplicação e divisão), mais um operador para o cálculo do módulo, entendido em programação como o resto de uma divisão inteira (não confundir com módulo matemático, que se refere ao valor absoluto de um número, que é, basicamente, o número sem sinal).

A tabela a seguir mostra os operadores aritméticos em C++, suas operações relacionadas e um exemplo de expressão aritmética:

Esses operadores são todos operadores binários, ou seja, que recebem e processam dois operandos, com associatividade da esquerda para a direita.

O operador de divisão / realiza uma operação de divisão inteira caso ambos os operadores sejam números inteiros, e uma operação de divisão comum (de números reais) se ao menos um dos operadores for um número de ponto flutuante (com casas decimais). Veja o exemplo a seguir:

int a = 9;
int b = 2;
float c = 2.0;
cout << a / b << endl;
cout << a / c << endl;

Resultado:

4
4.5

No primeiro exemplo o resultado foi um numero inteiro, pois a divisão foi realizada entre dois inteiros, a e b. Já a segunda divisão retornou o número 4,5, um valor de ponto flutuante, pois um dos operandos envolvidos (variável c) era do tipo float.

É importante sempre levar em consideração a ordem de precedência dos operadores, que determina como uma expressão com mais de um operador será avaliada. Este é o assunto da lição seguinte, que pode ser acessada clicando no link acima.

O post Operadores Aritméticos em C++ apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

A linguagem C++ avalia expressões aritméticas em uma sequência precisa, que é determinada pelas regras de precedência matemáticas e associatividade de operadores.

A tabela a seguir mostra os operadores em ordem decrescente de precedência:

Os parênteses ( ) podem ser usados para agrupar expressões e alterar a ordem de execução (precedência) dos operadores em uma expressão.

Desta forma, uma expressão como:

x = 5 * 2 + 3

a qual resulta em 13, é avaliada de forma diferente da expressão

x = 5 * (2 + 3)

que resulta no valor 25, pois neste segundo caso os parênteses alteram a ordem de execução dos operadores, efetuando a soma primeiro e depois a multiplicação com o resultado desta soma.

Associatividade em C++

A associatividade diz respeito à forma como a expressão é avaliada. Por exemplo, a expressão a + b + c é avaliada como se tivesse sido escrita (a + b) + c, pois os operadores aditivos (e aritméticos em geral) são associativos da esquerda para a direita – então, os operandos da esquerda são avaliados primeiro.

Já o operador de atribuição = é associativo da direita para a esquerda, de modo que a expressão a = b = 10 é avaliada como se tivesse sido escrita a = (b = 10), ou seja, como se fossem duas instruções separadas e sequenciais sendo executadas:

b = 10;
a = b;

Primeiramente o valor 10 é atribuído à variável b, e então o conteúdo da variável b é atribuído à variável a.

No exemplo a seguir combinamos regras de precedência com associatividade:

b = 10;
a = 3;
c = a * 3 + (b + 10) / 2

No exemplo, o ramos do lado direito será avaliado primeiro, e depois seu resultado atribuído à variável c (associatividade da atribuição). Porém, o ramo direito é em si uma expressão aritmética, e será avaliado da esquerda para a direita, respeitando a ordem de precedência dos operadores, exceto quando houver parênteses alterando-a.

Assim, teremos:

• o valor da variável a é multiplicado por 3, resultando em 9
• o valor de b somado a 10, resultando em 20 (parênteses em ação aqui)
• o resultado anterior é dividido por 2, resultando em 10 (ordem de precedência de operadores em c++)
• o resultado da multiplicação de a com as operações sobre b é a soma desses valores, resultando em 19
• e então  o resultado da expressão é atribuído à variável c.

É isso aí! Nas próximas lições vamos explorar mais a fundo os diversos tipos de operadores disponíveis em linguagem C++.

Até!

O post Associatividade e Precedência de Operadores em C++ apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Por Fábio dos Reis

A linguagem C++ é uma linguagem fortemente tipada. Isso significa que cada variável no programa possui um tipo associado a ela, que define o que ela pode armazenar. O compilador realiza verificação rígida dos tipos ao compilar um programa em C++ para assegurar que o tipo correto esteja sendo usado e que os tipos sejam compatíveis quando combinados entre si (por exemplo, em cálculos).

Existem sete tipos de dados básicos ou fundamentais em C++, chamados de Tipos Primitivos. A tabela a seguir mostra os tipos básicos primitivos em C++, com a palavra-chave usada em sua declaração e o tamanho em bytes ocupado por cada elemento do tipo na memória RAM:

Os tipos numéricos ou aritméticos que usamos em C++ são divididos em duas grandes categorias: tipos inteiros (números inteiros) e tipos de ponto flutuante (números fracionários). Existem diversos tipos de dados em cada uma dessas categorias, cada um com uma faixa de valores permitida (quantidade de valores possíveis) que o tipo pode armazenar.

Modificadores de Tipo

Um modificador é uma palavra-chave acrescentada ao nome de um tipo em sua declaração, que permite modificar seu comportamento de duas formas:

• Estendendo a faixa de valores suportada pelo tipo
• Permitindo ou não o emprego de números negativos (com sinal).

Alguns dos tipos básicos podem ser estendidos usando os seguintes modificadores e suas combinações:

• Long
• Short
• Unsigned
• Signed

Basicamente, esses modificadores expandem os valores mínimo e máximo da faixa de valores de cada tipo e determinam se os valores podem ser negativos ou somente positivos.

Tipos com sinal – signed

Um tipo com sinal (“signed”) é um tipo que permite a representação de valores positivos e negativos. É empregado quando precisamos armazenar valores negativos em um programa.

Um exemplo é o armazenamento de temperaturas – podemos armazenar tanto valores positivos como +32°C (temperatura real no momento em que escrevo esse artigo!) quanto temperaturas negativas como -15°C.

Por exemplo, o tipo int permite a faixa de valores de –2.147.483.648 a +2.147.483.647. A tabela a seguir mostra os tipos inteiros disponíveis em C++ incluindo a aplicação dos modificadores:

Na tabela acima, temos os nomes de tipos na coluna à esquerda e, como podemos ver, alguns nomes são compostos por mais de uma palavra. Sempre que possível usamos o nome mais curto disponível para o tipo em questão.

Assim, é muito comum usar, por exemplo, “long” do que “signed long int”, que representa o mesmo tipo (porém de forma mais explícita e melhor documentada).

O modificador signed para números inteiros é, na verdade, opcional. Se for omitido, o valor terá sinal por padrão.

Tipos sem sinal – unsigned

Já um tipo sem sinal (“unsigned”) somente permite a representação de números positivos, no mesmo espaço de armazenamento, tendo portanto uma faixa de valores positivos estendida. É usado, como podemos imaginar, quando não há a necessidade de armazenar números negativos no programa.

Um exemplo é o armazenamento da idade de uma pessoa – as idades são sempre números positivos; você pode ter 30 anos de idade, mas nunca -30 anos!

A tabela a seguir mostra os tipos inteiros em C++ sem sinal:

Para criar um tipo sem sinal devemos obrigatoriamente usar a palavra-chave unsigned antes do nome do tipo em si, como no exemplo a seguir:

unsigned short int // Tipo inteiro curto sem sinal

Números de Ponto Flutuante

Números de ponto flutuante permitem representar valores fracionários, positivos e negativos, como 3.1415 ou -9.345464576, além de permitirem o armazenamento de valores muito grandes (ou muito pequenos), em faixas de valores bem maiores que as possíveis com números inteiros.

Um número de ponto flutuante normalizado consiste em duas partes: uma mantissa e um expoente. A magnitude de um número é o valor da mantissa multiplicado por 10 elevado à potência do expoente.

Por exemplo, o número de dias em um ano típico, 365, pode ser escrito como um valor de ponto flutuante de precisão fixa em notação E (exponencial / científica) da seguinte forma:

3.650000E02

Aqui, a mantissa tem sete valores decimais (float – precisão fixa) e o expoente possui dois. A letra ‘E‘ significa “vezes dez elevado a“, significando que o valor 3.650000 multiplica 10 elevado a 02 (10²). Ou seja:

3.650000 x 10 x 10 = 3.650000 x 100 = 365 (ignorando os zeros).

Note que o valor do expoente – 02 –  é um valor positivo. Por padrão, não precisamos especificar o sinal do expoente se for positivo, como fizemos no exemplo. Mas se o valor for negativo, é obrigatório indicar seu sinal – e podemos indicar se for positivo também, para maior clareza de representação. Veja os exemplos do mundo real:

Carga elementar (elétron): 1.602 × 10^-19  = 1.602E-19

Constante de Avogadro: 6.022 x 10²³ = 6.022E23

Podemos usar essa notação ao definir constantes de ponto flutuante ou ainda valores literais em um programa (diretamente no código-fonte). A letra E pode ser maiúscula ou minúscula, não importando seu caso.

Os tipos de ponto flutuante disponíveis em C++ são:

O tipo float possui 7 dígitos de precisão (tamanho da mantissa), ao passo que o tipo double possui 15 dígitos de precisão (ou seja, precisão dupla). O arquivo de cabeçalho float.h informa os valores de bytes, expoente e precisão para os tipos de ponto flutuante do sistema em particular que você está usando.

Para descobrir os limites das faixas de valores dos tipos float, double e long double em seu sistema, você pode rodar o seguinte programa C++:

#include <iostream>
#include <limits>
using namespace std;
int main()
{
cout << "Tipo\t\tValor Min\tValor Max\n\n"
 << "Float" << '\t' << '\t' << std::numeric_limits<float>::min() << '\t'
   << std::numeric_limits<float>::max() << '\n'
 << "Double" << '\t' << '\t' << std::numeric_limits<double>::min() << '\t'
   << std::numeric_limits<double>::max() << '\n'
 << "Long Double" << '\t'<< std::numeric_limits<long double>::min() << '\t'
   << std::numeric_limits<long double>::max() << '\n';
return 0;
}

Veja o resultado do código anterior em meu sistema:

A escolha do tipo correto de dados é importante em seus programas para garantir que seja possível representar os dados de maneira eficiente e correta. Alguns exemplos disso incluem:

• usar o tipo short em vez de int se o intervalo de dados permitir
• usar double em vez de float para obter maior precisão para valores monetários (que representam dinheiro)
• usar um wchar_t para dados de caractere que não estão incluídos no conjunto de caracteres ASCII padrão, como por exemplo o Kanji japonês

Outros tipos de dados em C++ incluem os tipos de dados definidos pelo usuário (enum, structure, union e class) e tipos de dados derivados (array, ponteiro, referência), entre outros, que estudaremos em um momento oportuno.

Nas próximas lições vamos abordar de forma mais aprofundada conceitos como valores literais, os tipos char, wchar_t e bool, constantes, variáveis e outros.

Referências

• HORTON, I.; VAN WEERT, P. Beginning C++ 17 From Novice to Professional. 5ª edição. 2018. Editora Apress.
• PRATA, S. C++ Primer Plus. 6ª edição. 2012. Editora Addison-Wesley.

O post Tipos de Dados em C++ apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Usamos os operadores relacionais para estabelecer uma relação entre dois valores (operandos). Por exemplo, com um operador relacional podemos verificar se dois valores (contidos ou não em variáveis) são iguais ou diferentes entre si.

As expressões construídas com operadores relacionais sempre retornam um valor lógico (verdadeiro ou falso)

Operador de atribuição

Não confunda o operador de igualdade com um operador de atribuição, que possui função distinta – atribuir valores a variáveis – apesar de ambos empregarem o sinal de igual (=)

A tabela a seguir lista os operadores relacionais e de igualdade usados em programação com linguagem C++, com exemplos.

Precedência e associatividade dos operadores

Os operadores relacionais tem maior precedência que os de igualdade, mas tem precedência igual entre si.

A associatividade de todos esses operadores é sempre da esquerda para a direita.

Exemplos

Os operadores relacionais e de igualdade são operadores binários que retornam um valor lógico, verdadeiro ou falso, representados respectivamente pelos valores numéricos 1 ou 0. Veja o exemplo a seguir:

int d = 15;
int e = 15;
cout << "d > e? " << (d > e) << endl;
cout << "d >= e? " << (d >= e) << endl;
cout << "d < e? " << (d < e) << endl;
cout << "d <= e? " << (d <= e) << endl;
cout << "d == e? " << (d == e) << endl;
cout << "d != e? " << (d != e) << endl;

Resultado:

d > e? 0
d >= e? 1
d < e? 0
d <= e? 1
d == e? 1
d != e? 0

Os valores 0 e 1 retornados nos exemplos indicam, respectivamente, os valores lógicos False (falso) e True (verdadeiro). Com isso, é possível tomar decisões baseadas no resultado das comparações realizadas, principalmente quando associamos esses operadores com estruturas de decisão condicional e estruturas de repetição, que estudaremos nas próximas lições.

É isso aí! Vimos nessa lição os operadores relacionais e os operadores de igualdade em C++. Vamos estudar operadores lógicos e aritméticos nas próximas lições.

Até!

O post Operadores Relacionais e de Igualdade em C++ apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.