Fala pessoal! No artigo passado escrevemos um programa que permitia converter um número decimal em binário, usando C++. Agora vamos criar um pequeno programa que permite realizar o processo inverso – a conversão de um número binário, fornecido pelo usuário, em seu equivalente decimal, também usando a linguagem C++.

Vamos ao código.

Código – Converter binário em decimal com C++

#include<iostream>
#include<cmath>

using namespace std;

int main() {
  int num, resto, base = 2, soma = 0, i = 0;

  // Solicita ao usuário que digite o número binário a ser convertido
  cout << "CONVERSÃO DE BINÁRIO PARA DECIMAL \n"; 
  cout << "Digite o número em binário e pressione ENTER: ";
  cin >> num;

  // Laço onde é realizada a conversão do número binário em decimal
  while (num > 0) {
    resto = num % 10; // Calcula o dígito binário menos significativo
    soma = soma + (resto * pow(base, i)); // Converte e acumula o dígito binário em decimal
    num = num / 10; // Remove o dígito binário processado
    i += 1; // Incrementa o expoente da base (2)
  }

  // Exibe o número decimal resultante
  cout << "\nNúmero convertido para decimal: " << soma;
  return 0;
}

Resultado

CONVERSÃO DE BINÁRIO PARA DECIMAL 
Digite o número em binário e pressione ENTER: 1001111
Número convertido para decimal: 79

Funcionamento do Código

O programa inicia incluindo as bibliotecas iostream e cmath para permitir entrada/saída de dados e realizar cálculos matemáticos, respectivamente. Também usa using namespace std para evitar a necessidade de usar std:: antes de funções como cin e cout.

O programa então declara algumas variáveis, incluindo num para armazenar o número binário inserido pelo usuário, resto para armazenar o dígito binário atualmente sendo processado, base, que é 2 (pois estamos convertendo de binário para decimal), soma para acumular o valor decimal resultante e i para controlar o expoente da base.

Na sequência é solicitado que o usuário insira o número binário que deseja converter.

O programa entra então em um laço while que continuará até que o número binário (num) seja maior que zero.

Dentro esse laço, ele calcula o dígito binário menos significativo usando a operação num % 10. Isso resulta em 0 ou 1, que é o dígito binário atual.

O dígito binário é convertido em decimal e adicionado à variável soma usando a fórmula soma = soma + (resto * pow(base, i)). Aqui, resto é o dígito binário, base é 2 (base binária) e i é o expoente que começa em 0 e aumenta a cada iteração.

Logo após o número binário (num) é dividido por 10 (num = num / 10) para remover o dígito binário que foi processado.

Então, o expoente da base (i) é incrementado em 1 (i += 1) para lidar com o próximo dígito binário.

Após a conclusão do laço de repetição, o programa exibe o número decimal resultante.

Finalmente, o programa retorna 0, indicando que a execução foi bem-sucedida.

É isso aí! Nos próximos tutoriais veremos outros tipos de conversões de bases numéricas usando a linguagem C++, como a conversão de hexadecimal em decimal e binário e vice-versa.

Até!

O post Programa que converte um número de binário para decimal em C++ apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Fala pessoal! Neste tutorial vamos criar um pequeno programa que permite realizar a conversão de um número decimal, fornecido pelo usuário, em seu equivalente binário, usando a linguagem C++.

Usaremos o método das divisões sucessivas por 2, com o emprego da operação aritmética de módulo (resto da divisão inteira) para realizar essa conversão de bases numéricas.

Vamos ao código.

Código: Converter decimal em binário em C++

#include<iostream>
using namespace std;
int main()
{
  int num, soma[100], i=0;

  // Solicita ao usuário que o número decimal a ser convertido
  cout<< "CONVERSÃO DE UM NÚMERO DECIMAL EM BINÁRIO \n"; 
  cout<<"Digite o número a converter e pressione ENTER: \n";
  cin>>num;

  // Exibe o número decimal que será convertido
  cout<<"Número a converter: "; 
  cout<<num;

  // O loop a seguir realiza a conversão do número decimal em binário
  while (num > 0) {
    soma[i] = num % 2; // Calcula o resto da divisão por 2 (que é 0 ou 1)
    i = i + 1; // Incrementa o índice para armazenar o próximo dígito binário
    num = num / 2; // Divide o número decimal por 2 para continuar a conversão
  }

  // Exibe o número binário convertido
  cout<<"\nNúmero convertido em binário: "; 
  for(int j=i-1;j>=0;j--)
  {
    cout<<soma[j]; // Mostra os dígitos binários na ordem correta
  }
  return 0;
}

Teste

CONVERSÃO DE UM NÚMERO DECIMAL EM BINÁRIO 
Digite o número a converter e pressione ENTER: 
1650
Número a converter: 1650
Número convertido em binário: 11001110010

Funcionamento do Código

1. O programa inicia com a inclusão da biblioteca iostream para permitir entrada e saída no console (cin e cout), usando o namespace std para evitar a necessidade de usar std:: antes das funções cin e cout.
2. Na sequência declaramos algumas variáveis, incluindo num para armazenar o número decimal inserido pelo usuário, um vetor (array)  soma para armazenar os dígitos binários e i para controlar o índice de soma.
3. O programa então solicita que o usuário insira o número decimal que deseja converter.
4. O programa entra em um laço while que continuará iterando até que o número decimal (num) seja maior que zero.
5. Dentro desse laço, é calculado o resto da divisão (módulo) do número decimal por 2 usando num % 2. Isso resulta em 0 ou 1, que é o dígito binário correspondente ao dígito menos significativo do número decimal.
6. O dígito binário calculado é armazenado no array soma[i], onde i é o índice atual do array. O índice é então incrementado para armazenar o próximo dígito binário.
7. O número decimal (num) é dividido por 2 (num = num / 2) para continuar a conversão, removendo o dígito menos significativo.
8. Após a conclusão do loop, o programa exibe o número binário resultante. Ele faz isso percorrendo o array soma na ordem reversa (do dígito mais significativo para o menos significativo) e exibindo cada dígito binário.
9. O programa finalmente retorna 0, indicando que a execução foi bem-sucedida.

É isso aí! No próximo artigo faremos o processo inverso: faremos a conversão de um valor binário fornecido pelo usuário em sua representação decimal com C++.

Até!

O post Programa que converte um número de decimal para binário em C++ apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

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.

As Variáveis, em programação, são identificadores que criamos para armazenar valores ou referências a objetos no código. Na prática, uma variável é um local nomeado na memória RAM do computador, onde valores são armazenados para processamento.

Quando criamos uma variável em C++, devemos informar o tipo de dado que ela armazenará. Podemos atribuir um valor à variável na hora em que a criamos (na sua declaração) ou posteriormente, em outro ponto do código.

Chamamos a esse processo de  “inicializar a variável”. Mesmo sendo possível inicializar uma variável em um momento posterior à sua declaração, o tipo de dado deve ser sempre atribuído quando a definimos.

O C++ não permite que utilizemos uma variável não inicializada para ajudar a impedir que dados não desejados (lixo de memória) sejam usados indevidamente na aplicação.

Como declarar uma variável em C++

O trecho de código a seguir demonstra a declaração de uma variável e a atribuição de um valor a ela. Em C++ temos duas formas de inicializar uma variável:

int var1 = 0;
int var2{1};

Basicamente, a sintaxe é a seguinte:

tipo identificador [= valor_inicialização]

Onde:

• tipo é o tipo de dado que será armazenado na variável
• identificador é o nome da variável
• valor_inicialização é o valor a ser atribuído à variável (os colchetes denotam que o valor é opcional na declaração da variável, pois pode ser atribuído posteriormente).

Regras para identificadores

O C++ possui algumas restrições com relação a identificadores (nomes das variáveis e outros elementos) que é importante conhecer.

Primeiramente, os identificadores são case-sensitive porque a linguagem C++ é case-sensitive. Isso significa que identificadores como var1, Var1, e VAR1, são considerados identificadores diferentes (variáveis distintas).

Os identificadores somente podem ter letras (maiúsculas ou minúsculas), dígitos numéricos e o caractere underline. O identificador somente pode começar com uma letra ou um caractere underline _, não podendo começar com um número.
Assim, var1 e _var1 são nomes de variáveis válidos, mas 1var não é, pois começa com um dígito numérico.

A linguagem C++ possui também um conjunto de palavras reservadas que são usadas pela linguagem. Não podemos usar essas palavras reservadas como identificadores no código. É até possível empregar palavras reservadas em caso distinto (em maiúsculas, por exemplo), pois o C++ é case-sensitive, mas essa não é uma abordagem recomendada.

A lista a seguir mostra as palavras reservadas que você não deve usar para criar identificadores de nenhum tipo em C++.

Lista de palavras reservadas em C++

alignas continue friend register true alignof decltype goto reinterpret_cast tryasm default if return typedef auto delete inline short typeid bool do int signed typename break double long sizeof union case dynamic_cast mutable static unsignedcatch else namespace static_assert usingchar enum new static_cast virtualchar16_t explicit noexcept struct voidchar32_t export nullptr switch volatile class extern operator template wchar_tconst false private this while constexpr float protected thread_localconst_cast for public throw

A lista de palavras reservadas pode ser alterada ao longo do tempo, conforma a linguagem vai evoluindo e novos padrões são publicados. Para se manter atualizado com relação às palavras reservadas em C++, sempre verifique a documentação mais atual padrão do C++, que pode ser acessada aqui: https://isocpp.org/files/papers/N3690.pdf

Exemplos de declaração de variáveis em C++

Vejamos alguns exemplos de declaração e atribuição de variáveis em C++ agora.

#include <iostream>

using namespace std;

int main() {
  int a;
  int b;
  a = 10;
  b = 20;
  cout << "Valor de a: " << a;
  cout << "\n";
  cout << "Valor de b: " << b << endl;

  int res;
  res = a + b;
  cout << "Valor de res: " << res << endl;

  int c(15);
  int d(30);
  int result {c + d};
  cout << "Valor de result: " << result << endl;

  return 0;
}

Resultado:

É isso aí! Nas próximas lições veremos como usar funções de entrada e saída de dados em C++ (como a função cout mostrada no exemplo), além de empregar operadores diversos para manipular valores armazenados em variáveis.

O post Declaração de Variáveis 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.

Tarefas de pré-processamento são tarefas que ocorrem antes que um programa seja efetivamente compilado. No pré-processamento, as principais operações realizadas antes da compilação incluem:

• Definição de Constantes Simbólicas
• Inclusão de outros arquivos no arquivo a ser compilado
• Definição de Macros
• Compilação condicional de código
• Execução condicional de diretivas

As tarefas de pré-processamento são definidas por diretivas de pré-processamento no C++. Todas as diretivas de pré-processador se iniciam com o símbolo #, e não podemos ter nenhum caractere antes de uma diretiva em uma linha, exceto espaços em branco.

Como as diretivas de pré-processamento não são declarações do C++ (comandos), elas não terminam com ponto-e-vírgula ;. Colocar o símbolo ; no final de uma diretiva de pré-processamento é, na verdade, um erro de programação comum.

Diretivas de pré-processador em C++

São instruções direcionadas ao compilador. podemos fornecer algumas instruções ao compilador de modo que antes de iniciar o processo de compilação essas instruções são executadas.

Alguns exemplos de diretivas de pré-processador incluem:

• #define – define constantes simbólicas (que não ocupam espaço na memória RAM do sistema)
• #ifndef – define um item se ele não tiver sido definido anteriormente
• #include – inclusão de cabeçalhos – ver a seguir.

Todo código em C++ inicia com a diretiva #include<>. A diretiva instrui o pré-processador a incluir uma parte do código padrão do C++ ou outro código pronto no programa atual. Vejamos algumas dessas diretivas com mais detalhes agora.

Diretiva de pré-processamento #include

A diretiva de pré-processamento #include faz com que uma cópia de um arquivo específico seja incluído no código, no lugar da diretiva. É empregada geralmente para incluir arquivos de cabeçalho padrão como por exemplo o <iostream>.

Há duas formas de se escrever uma diretiva #include:

#include <arquivo>
#include "arquivo"

A primeira forma, com <>, é empregada para a inclusão de arquivos de cabeçalho da biblioteca padrão C++. O pré-processador procura o arquivo especificado em pastas pré-definidas no computador.

Já na segunda forma, com o nome do arquivo entre aspas “”, o pré-processador procura o arquivo primeiramente na mesma pasta (diretório) onde se encontra o arquivo a ser compilado, e então nos diretórios pré-definidos pela implementação do sistema. No geral, usamos essa forma quando queremos incluir arquivos de cabeçalho definidos pelo usuário (criados por nós mesmos).

Por exemplo, a diretiva

#include<iostream>

inclui o cabeçalho de nome iostream para dar suporte a operações de entrada e saída de dados, por exemplo disponibilizando funções para ler dados da tela e escrever no console.

Diretivas de pré-processamento #define

Com uma diretiva #define criamos Constantes Simbólicas, que são constantes representadas como símbolos, e Macros, que são pequenas operações funcionais. Escrevemos uma diretiva #define da seguinte forma:

#define identificador valor_substituto

Com esta declaração, todas as ocorrências do identificador no código são substituídas pelo valor_substituto informado. Por exemplo, considere a constante simbólica a seguir:

#define distancia 150

Toda vez que aparecer o identificador distância no código (exceto se estiver entre aspas), ele será substituído pelo valor 150. Note que NÃO usamos o operador de atribuição = aqui, pois não se trata de uma atribuição de valores, e sim de uma substituição de nomes.

Uma constante simbólica não aloca espaço na memória RAM do sistema e não armazena dado nenhum. No geral, é preferível criar constantes “comuns” em C++ com a palavra-chave const, em vez de usar constantes simbólicas, pois isso facilita o debugging do código – mas as constantes comuns ocupam espaço na memória, o que também deve ser levado em consideração.

Vejamos outro exemplo da diretiva #define, desta vez criando uma macro.

Uma macro é uma operação (pequena função) definida em uma diretiva de pré-processamento, e que podem ou não receber argumentos. O exemplo a seguir mostra a definição de uma macro que realiza o cálculo da área de um triângulo retângulo, dada por A = 1/2 * b * h (base * altura / 2):

#define AREA_TRIAN(b, h) ((b * h)/2)

Toda vez que AREA_TRIAN(b, h) aparecer no código, os valores de b e h serão substituídos pelos valores fornecidos como argumentos, e será retornado o valor calculado da área do triângulo retângulo. Assim, se em algum ponto do código tivermos:

area = AREA_TRIAN(10,15)

a variável area receberá o retorno da execução da macro, ou seja: 10 * 15 / 2 = 75.

Uma vantagem do uso de macros em relação à declaração de funções comuns no código é que o código é inserido diretamente no programa, diminuindo a sobrecarga associada à criação de funções. Porém, em C++ é muito comum que as macros sejam substituídas por outras formas de declaração de funções, como templates e funções inline ou funções lambda. As macros são empregadas mais extensivamente em linguagem C.

Compilação Condicional

Com uma estrutura de compilação condicional podemos controlar a execução das diretivas de pré-processamento e, assim, a compilação do código-fonte como um todo. Com uma diretiva de pré-processamento condicional, as expressões são avaliadas e será determinado se o código associado será compilado ou não. O exemplo mais comum de diretiva condicional é a diretiva #ifndef (“IF NOT DEFINED”). Veja o exemplo a seguir:

#ifndef NULL
  #define NULL 0
#endif

Esta diretiva verifica se uma constante simbólica NULL não está definida. Se estiver definida, nada ocorre, mas se ainda não estiver definida, a constante simbólica será criada com o valor 0.

Note que a diretiva #ifndef deve ser fechada (terminada) com #endif. Também existe uma diretiva que verifica se uma constante já está definida, que é a constante #ifdef (“IF DEFINED”), a qual, como se espera, funciona de forma inversa à #ifndef.

Namespaces e diretivas using

Todos os programas em C++ iniciam sua execução a partir de uma função especial chamada de main(), independente de onde ela esteja declarada no código do programa. Seu formato é o seguinte:

int main() {
    // Código principal do programa
}

As chaves indicam onde inicia e onde termina o bloco de código que é executado pela função.

Diretivas using

As diretivas using habilitam um programa a usar todos os nomes em qualquer cabeçalho C++ padrão, como por exemplo o cabeçalho <iostream>. Assim, podemos incluir em um programa o namespace std da seguinte forma:

using namespace std;

E desta forma iremos poupar digitação de código posteriormente quando precisarmos utilizar as funções e métodos deste namespace, pois não será necessário referenciá-lo a todo instante. 

Por conta disso, em vez de escrevermos:

std::cout << "Mensagem"

podemos escrever simplesmente:

cout << "Mensagem"

Pois o compilador já saberá que a função cout pertence ao namespace std, declarado por meio da diretiva using.

Namespaces em C++

Um namespace (espaço de nomes) é uma forma de organização de funções e outros elementos de um programa. São úteis para remover conflitos de nomes entre recursos distintos, como arquivos de cabeçalho que possuam funções ou métodos de mesmo nome, mas com funcionalidades distintas.

Exemplo de namespaces em C++

No exemplo a seguir

#include <iostream>
#include <locale>

namespace ex1 {
    void func() {
        std::cout << "Bóson ";
    }
}
namespace ex2 {
    void func() {
        using namespace std;
        cout << "Treinamentos" << endl;
    }
}

using namespace ex1;
using namespace std;

int main() {
    setlocale(LC_ALL, "");    
    func();
    ex2::func();
}

Saída obtida:

Bóson Treinamentos

A palavra “Bóson” vem do retorno da função func() definida no namespace ex1, e apalavra “Treinamentos” vem da função de mesmo nome, func(), porém do namespace ex2. Incluímos o cabeçalho locale e a declaração setlocale(LC_ALL, “”); para termos suporte aos caracteres especiais da língua portuguesa (e outros) no console, como a letra o acentuada da palavra “Bóson”.

Podemos manter os namespaces em arquivos de cabeçalho separados, e incluir esses cabeçalhos no código para ter acesso às suas funções quando necessário, a partir de outra parte do programa.

std: Biblioteca Padrão (standard). Indica o namespace padrão da linguagem, que trata de uma série de comandos, funções e declarações distintas.
Pode ser declarado no início do código, logo após as diretivas #include, com o uso da declaração using:

#include<iostream>
using namespace std;

Ou ainda usado diretamente no código do programa, precedendo os nomes das funções a serem invocadas (método mais trabalhoso):

std::cout << "Olá\n";

• O símbolo :: é o operador de resolução de escopo.
• cout é uma função que pertence ao namespace padrão (std). significa Character OUTput (saída de caracteres), e permite escrever dados na saída padrão do computador (tela).
• << é o operador de inserção, que permite inserir o que é colocado à sua direita no elemento que está à sua esquerda. No caso, a palavra Olá é “inserida” no objeto cout – ou seja, enviada para a tela.

Conclusão

Estudamos nesta lição as diretivas de pré-processamento principais do C++, como as diretivas #include, #define e #ifndef, e aprendemos os conceitos de constante simbólica, macro e arquivo de cabeçalho.

Também vimos o que é um namespace e a diretiva using, e entendemos que um programa em C++ sempre inicia com a função main().

É isso aí! A partir da próxima lição vamos iniciar os estudos da sintaxe do C++, aprendendo sobre tipos de dados e declaração e atribuição de variáveis. Até!

O post Diretivas de pré-processamento e namespaces em C++ apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Uma das linguagens de programação mais importantes e utilizadas no mundo, a linguagem C++ evoluiu a partir da linguagem C, a qual foi desenvolvida por Dennis Ritchie nos laboratórios Bell, no final dos anos 60.

Sendo uma extensão do C, de acordo com Bjarne Stroustrup, que é o criador do C++, ela pode ser definida de forma sucinta como:

“… uma linguagem de programação de propósito geral com uma tendência para programação de sistemas que

• é um C melhorado
• suporta abstração de dados
• suporta programação orientada a objetos
• suporta programação genérica”

A linguagem C++ começou a ser desenvolvida em 1979 e era originalmente conhecida como C com Classes. Essencialmente, isso significava que os arquivos de classe (usados na programação orientada a objetos), foram simplesmente adicionados à linguagem C. Em 1983 ela foi renomeada para C++.

O C++ existe sob a tutela de um comitê de padrões e se tornou um padrão ISO em 1998 com uma revisão em 2011 e outras revisões em 2014, 2017 e 2020, que é a mais atual (C++20). Ela continua a ser atualizada como parte do trabalho do comitê de padrões, sendo que a próxima revisão está prevista para 2023 (C++23).

Algumas características do C++

O C++ é uma linguagem que diferencia maiúsculas de minúsculas (é case-sensitive). Isso significa que suas palavras-chave e declarações de variáveis devem corresponder a maiúsculas e minúsculas. Por exemplo, uma palavra-chave C++ para um tipo de constante é const. Se digitarmos Const ou CONST, o compilador não saberá que sua intenção é usar a palavra-chave const.

Além da distinção entre maiúsculas e minúsculas, C++ também tem um esboço definido para o código do programa e “elementos” específicos encontrados em uma aplicação C++ típica. Esses elementos consistem em:

• Diretivas de pré-processador que são usadas para fazer com que o compilador execute tarefas antes de compilar o código-fonte
• Diretivas using – diretivas que são utilizadas para indicar quais namespaces incluir em um arquivo de código-fonte
• um cabeçalho de função que consiste em um tipo de retorno, nome de função e parâmetros
• um corpo de função contendo o código que executa as ações exigidas dessa função
• declarações que estão contidas no arquivo de código-fonte C ++
• comentários para documentar o código-fonte para que os programadores entendam o que o código pretende fazer
• uma instrução de retorno que envia dados de volta ao chamador da função
• chaves para incluir o corpo das declarações. Normalmente usados para denotar o corpo de uma função ou uma instrução de controle de fluxo, como um loop for

O código-fonte C ++ também permite o uso criterioso de espaços em branco (tabulações, espaços, novas linhas) para criar um código mais fácil de ler. O compilador ignora completamente o espaço em branco, com uma pequena exceção em relação às instruções if que vamos abordar posteriormente. É altamente recomendável usar o espaço em branco para identar e separar as linhas de código para ajudar na legibilidade dos arquivos de código-fonte.

Um programa em C++ é composto de vários componentes, como funções, métodos, classes, etc. As instruções que fazem parte de um programa C++ normalmente residem dentro de funções ou métodos. Essas funções são compostas de instruções C++. Você se verá usando vários tipos de instruções em seu código C++, conforme listadas a seguir:

• declarações – são usadas para declarar variáveis e constantes que serão usadas no programa
• atribuições – são usadas para atribuir valores a variáveis em seu código de aplicativo
• diretivas de pré-processador – abordadas no tópico sobre formatação de código
• comentários – usados para documentar seu código
• declarações de função – abordado no tópico sobre formatação de código
• instruções executáveis – são usadas para realizar operações e executar instruções. Um exemplo seria cout << “Olá Bóson!”; que produz a frase Olá Bóson! na saída do console.

Vamos usar esses tipos de instrução durante todo nosso curso de C++.

Estrutura de um programa em C++

Um programa C++ tem uma estrutura muito específica em termos de como o código é escrito e alguns elementos-chave que usamos nos programas em C++. 

Os programas em C++ consistem de partes modulares chamadas de classes e funções. Podemos criar nossas próprias classes e funções, quando necessário, e também fazemos uso extensivo de uma rica coleção de classes e funções existente, chamada de Biblioteca Padrão do C++.

Desta forma, aprender a programar em C++ consiste em aprender duas partes coligadas: a linguagem em si, com suas estruturas e sintaxe, e aprender a usar o conteúdo da biblioteca padrão C++.

O código-fonte de um programa extremamente simples em C++ é mostrado a seguir.

1 #include <iostream>
2 // Função principal que inicia a execução do programa
3 int main()
4 {
5    std::cout << "Ola Boson!\n";
6    return 0;
7 }

Neste programa simples, notamos alguns elementos importantes. Os números das linhas são usados apenas para referência e não fazem parte do código do programa.

Vejamos o que faz cada linha.

Linha 1: Iniciada com o caractere #, é uma diretiva de pré-processador. Processada antes do programa ser efetivamente compilado. No exemplo, ela instrui o compilador a localizar e incluir o arquivo que contém o código de uma biblioteca conhecida como iostream. Esta biblioteca contém código que permite a entrada e saída para fluxos de dados, como a janela do console.

Linha 2: Linha de comentário. Toda linha iniciada com os caracteres // é uma linha destinada a comentários, usados para documentar os programas e ajudar outros programadores a entendê-los. Os comentários são ignorados quando o programa é compilado ou executado.

// Esta linha é um comentário!

Também temos comentários de múltiplas linhas, ou de bloco, que iniciam com os caracteres /* e finalizam com */.

/*
Este bloco de texto inteiro
é um bloco de comentários, que ocupa várias linhas
*/

Linha 3: Todo programa escrito em C++ deve ter uma função principal chamada de main(). É o ponto de entrada da aplicação quando iniciamos a execução do programa no computador, mesmo que não seja a primeira função presente no código. A palavra int indica o tipo de retorno do método u função – no caso, um número inteiro.

Os parênteses vazios () após o nome do método indicam que esta é uma função e que não leva argumentos, ou seja, não há parâmetros para a passagem de valores.

Os programas em C++ são constituídos de diversas funções e classes, e uma delas é sempre a função main.

Linha 4: Os corpos dos métodos e funções em C++ começam com a abertura de um par de chaves {. Ao finalizar o código do método ou função, a chave é fechada }.

Linha 5: Este código usa um método conhecido como cout (pronuncia-se “sí áut”) para enviar o texto Ola Boson! para o console de saída e exibição na tela. O prefixo std:: para este comando é uma forma de indicar que cout faz parte de um namespace conhecido como std.

Outras funções pertencentes ao namespace std incluem cerr e cin, que estudaremos posteriormente.

Assim, o símbolo :: é usado para indicar que cout faz parte do namespace std. Nem sempre usaremos essa notação – veremos como empregar as diretivas using para declarar os namespaces empregados em um programa em breve.

Note também que essa linha termina com um ponto e vírgula, e a linha toda constitui uma declaração em C++. Assim, as declarações em C++ são terminadas com ponto e vírgula, conhecido como “terminador de declarações”.

Erro comum em programação: Esquecer de inserir os ponto-e-vírgula no final de uma declaração é um erro extremamente comum em programação, não apenas em linguagem C++, mas em várias outras linguagens que utilizam essa sintaxe, como C e Java.

O símbolo << é o operador de inserção (de fluxo). Ao executar um programa, o valor que está à direita desse operador (operando direito) é inserido ou enviado ao elemento que está à esquerda do operador – no caso, a frase “Ola Boson!” é enviada para cout. O operador aponta na direção para onde vão os dados.

\n é uma sequência de escape – um caractere especial, que não é especificamente impresso na tela, mas produz algum efeito, como por exemplo mudar o cursor para o início da próxima linha (que é o caso). Outras sequências de escape existem, e as veremos em breve.

Linha 6: A instrução return é usada para encerrar ou sair de uma função ou método, e se espera que um valor seja enviado de volta a um processo chamador (que “chama” a instrução). Nesse caso, o chamador é o sistema operacional e o valor retornado é um valor inteiro 0. Se o programa chegar a essa instrução sem apresentar erros, o retorno de um valor 0 indica ao sistema operacional que o código foi executado com êxito.

Antigamente, os programadores retornavam 0 para indicar uma execução bem-sucedida e valores diferentes de zero para indicar que ocorreu um erro em algum lugar do programa.

Linha 7: Esta linha fecha o corpo da função main() (fechando a chave aberta no início) e é necessária para que o compilador saiba onde a função ou método termina, mas também é usada para outros propósitos que serão cobertos posteriormente no curso, como escopo e visibilidade de variáveis.

É isso aí! Neste tutorial apresentamos o que é o C++  e os principais elementos da linguagem, com um exemplo bem simples de código, explicando linha por linha as declarações.

Na próxima lição vamos abordar mais algumas características importantes da linguagem C++, tais como a Portabilidade e o processo de Compilação de Código.

O post Introdução à Linguagem de Programação C++ apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.