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.

Neste tutorial veremos como solucionar o erro “”SqlConnection” não pode ser encontrado no namespace “System.Data.SqlClient“” em uma aplicação C# escrita no Microsoft Visual Studio.

Problema

Durante uma aula de programação com C#, ao tentar criar uma aplicação com GUI usando o Microsoft Visual Studio 19 e o .NET 5.0, os alunos se depararam com o erro a seguir ao codificar a aplicação:

Os objetos SqlConnection, SqlCommand e SqlDataReader não eram reconhecidos mesmo após a inclusão do namespace System.Data.SqlClient na seção de diretivas “using“ do programa.

Ao tentar executar o código, as seguintes mensagens de erro eram mostradas na saída:

Por que esse erro ocorre

O que causa desse erro é o fato do namespace System.Data.SqlClient não ter sido referenciado pelo projeto por padrão, conforme deveria ser feito pelo .NET Framework. Assim, para corrigir esse problema, será necessário adicionar o pacote manualmente ao projeto.

Como resolver o problema

Solução: instalar o pacote System.Data.SqlClient no NuGet para que o projeto possa utilizá-lo. Siga os passos abaixo para realizar essa tarefa.

1. Clique com o botão direito do mouse no nome da solução no painel de soluções do Visual Studio.
2. No menu de contexto, selecione Gerenciar Pacotes NuGet para a Solução…
3. Na janela Gerenciador de Pacotes NuGet, clique na guia Procurar.
4. Na caixa de pesquisa digite System.Data.SqlClient e pressione Enter.
5. Procure o pacote System.Data.SqlClient da Microsoft e o selecione.

   

6. Um pequeno painel será aberto no lado direito da janela. Selecione a versão do pacote a instalar (geralmente a mais recente funcionará) e pressione o botão de instalação. Aguarde a conclusão da instalação. O NuGet irá instalar o pacote selecionado e todas as suas dependências.
7. Após o término da instalação do System.Data.SqlClient retorne ao seu projeto e tente executá-lo novamente. Se tudo correu bem, você não verá o erro ocorrendo outra vez.

Problema solucionado!

O post Erro O nome do tipo “SqlConnection” não pode ser encontrado no namespace “System.Data.SqlClient” (Resolvido) – Visual Studio 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.

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.

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.

Finalmente chegamos ao final do ano de 2020. Para boa parte das pessoas, um ano para esquecer – para mim, sem dúvida, um dos piores períodos em diversos quesitos.

Esperamos que o próximo ano seja melhor – e vamos trabalhar para que isso se concretize. Uma das melhores coisas que podemos fazer é nos prepararmos de forma metódica e planejada, e estudar para enriquecer nosso currículo profissional e avançar em nossas carreiras é o caminho a seguir.

Por conta disso trago neste artigo algumas dicas de linguagens de programação que valem a pena estudar durante o ano vindouro, de forma bem objetiva e clara: apenas linguagens com real potencial de trazer benefícios ao estudante / profissional.

Escolher uma linguagem de programação

Aprender uma nova linguagem de programação não é uma tarefa simples, principalmente se você for iniciante. O processo pode ser demorado, complicado e frustrante – e no final você pode acabar usando seu tempo precioso para estudar uma linguagem de programação que não terá tanta utilidade em suas vida profissional.

Por isso é importante saber escolher qual linguagem (ou quais) você irá estudar. As opções são muitas, e algumas linguagens que hoje parecem muito importantes talvez percam relevância no futuro, ao passo que linguagens mais “obscuras” podem se tornar de uso comum e muito procuradas pelos profissionais e pelas empresas.

Existem literalmente centenas de linguagens de programação disponíveis hoje, e a demanda por essas linguagens varia ano a ano, com novas linguagens surgindo, outras se tornando mais populares, e outras tantas sendo menos utilizadas até se tornarem praticamente obsoletas.

Escolher uma linguagem de programação pode ser complicado – afinal, você pode acabar usando seu precioso tempo para aprender uma linguagem que, daqui a um ano (ou alguns meses!) não será mais relevante no mercado. Então, como escolher a linguagem (ou linguagens) mais indicadas para aprendizado, que tenham maior potencial de retorno para sua carreira?

Se você é iniciante no mundo do desenvolvimento de sistemas, a dica é investir nas linguagens mais consagradas, que tem ampla aceitação no mercado e utilização profunda pelas empresas – levando em consideração alguns fatores como crescimento de sua popularidade, nichos de atuação, novos entrantes (novas linguagens) que as possam substituir, quantidade de frameworks e bibliotecas disponíveis, demanda no mercado de trabalho, e outros.

As primeiras linguagens de programação com as quais tive contato foram Delphi, C, Basic e Assembly. Destas, apenas a linguagem C ainda é relevante nos dias de hoje – e, curiosamente, uma das mais importantes e estudadas ainda!

Porém as outras três acabaram se tornando obsoletas (Basic, Delphi) ou sendo usadas apenas em nichos muito específicos (Assembly, de novo Delphi). O mesmo deve acontecer com a maioria das linguagens mais novas que temos disponíveis – algumas serão usadas de forma intensiva pelos próximos anos ou até décadas, ao passo que outras são deixadas de lado rapidamente, substituídas por outras linguagens com mais recursos, mais performáticas ou simplesmente mais fáceis de aprender.

Neste artigo listo algumas das linguagens de programação que eu, pessoalmente, acredito que sejam importantes em 2021, e nas quais pode valer a pena investir tempo de estudo (e dinheiro, em alguns casos).

Bem, sem mais delongas, vamos à lista de linguagens para aprender em 2021!

JavaScript

O JavaScript é uma das linguagens mais usadas no mundo, encontrando aplicação em dispositivos móveis, desenvolvimento de jogos, Internet das Coisas e, principalmente, desenvolvimento Web.

Amplamente empregada no desenvolvimento de aplicações front-end para websites, também pode ser usada em aplicações de back-end (lado servidor), com o ambiente de execução NodeJS.

Não é exatamente uma linguagem simples de se aprender, devido à sua sintaxe, comandos e integração com outras linguagens, mas sem dúvida é uma das mais importantes, e você deve estudar JavaScript com certeza absoluta se tem a mínima intenção de trabalhar com desenvolvimento para Web e afins. O JS é executado normalmente em um navegador, oferecendo uma interface bastante responsiva para as aplicações web, sem a necessidade de compilação de código.

C++ (e C)

O C++ é a linguagem mais antiga dessa minha lista, mas não por isso menos importante que as demais.

Na prática, eu listaria C/C++, pois as duas linguagens tem muitos pontos em comum – mas o paradigma orientado a objetos do C++ faz com que seja mais simples (menos complicado?) desenvolver sistemas nesta linguagem. Mas recomendo também a linguagem C, uma das mais usadas no mundo hoje e a mais importante da história da programação.

Desenvolvida por Bjarne Stroustrup em 1985, o C++ é uma das linguagens mais eficientes e flexíveis que existem, permitindo a criação de aplicações de alta performance e alta confiabilidade, sendo empregada em áreas diversas como Programação de Sistemas, Desenvolvimento de Jogos, Aplicações para Web e Desktop, Área Financeira, Sistemas Embarcados, Aplicações de Tempo Real, Veículos Autônomos e Inteligência Artificial, entre outras.

E é justamente essa demanda de sistemas autônomos, embarcados e jogos de alta performance que fazem com que o C/C++ esteja presente nesta lista. São linguagens antigas e ao mesmo tempo suportam as tecnologias do futuro!

Uma das grandes desvantagens do C++ é sua curva de aprendizado acentuada, pois possui uma sintaxe complexa, e seu sistema de orientação a objetos não é tão claro quanto, por exemplo, o da linguagem Java. Também peca em alguns pontos como a alocação de memória dinâmica ou coletor de lixo. Não é recomendada como linguagem de escolha para iniciantes em programação.
Porém, aplicações escritas em C e C++ são extremamente rápidas, sendo insubstituíveis em muitos casos.

Java

Criada por James Gosling em 1995 na Sun Microsystems, é provavelmente a linguagem mais usada atualmente em ambiente empresarial. Totalmente orientada a objetos, aplicações escritas em Java podem rodar em qualquer plataforma, bastando para isso ter alguma implementação de Máquina Virtual Java instalada (JVM). É ideal para aplicações de computação distribuída, além de suportar multithreading.

Suas principais aplicações são no desenvolvimento de aplicações Desktop (como o notório programa da Imposto de Renda!), aplicações Web e Mobile (para Android), e nas áreas de serviços Financeiros e aplicações Científicas, entre outras. O Java possui uma variedade enorme de bibliotecas open source e diversas APIs, que facilitam o desenvolvimento de aplicações que envolvam bancos de dados, conectividade à redes, manipulação de formatos variados de dados e muito mais.

Uma de suas desvantagens é o fato do ambiente Java se relativamente “pesado”, demandando recursos de hardware específicos, além de ser mais lenta (é interpretada) em comparação com aplicações escritas em linguagens como C/C++ (que são compiladas). O gerenciamento de memória também não é excelente.

PHP

Podem fazer memes e falarem o que quiserem, mas o PHP ainda é linguagem dominante em aplicações Web Back End. Quase 1/4 dos websites na Internet usam PHP de alguma forma, sendo empregada primariamente na criação de websites dinâmicos e blogs, como os criados usando a plataforma WordPress.

Linguagem multiparadigma (funcional, imperativa, orientada a objetos) lançada em 1995, o PHP possui um vasto ecossistema de aplicações e bibliotecas, e uma grande comunidade para suporte, alé de diversos frameworks que facilitam o desenvolvimento de aplicações na linguagem (como o Laravel).

O PHP hoje sofre competição de linguagens como o Python e o JavaScript (Node), mas ainda impera no quesito linguagem server-side para web. Sua facilidade de aprendizado e a grande quantidade de bibliotecas e frameworks a tornam uma linguagem ideal para quem está iniciando em desenvolvimento web e deseja se inserir no mercado de trabalho sem necessariamente trabalhar com front end (HTML/CSS).

As maiores criticas ao PHP recaem sobre características de segurança e gerenciamento de erros um pouco deficiente, que demandam um maior cuidado ao desenvolver sistemas e aplicações que tratam dados mais sensíveis. Além disso não é tão veloz quanto se espera de uma linguagem de back end.

Python

Python, desenvolvida por Guido van Rossum em Amsterdam, na Holanda em 1990, é minha escolha número um para 2021. Uma das linguagens mais versáteis que existem atualmente, pode ser empregada no desenvolvimento de aplicações para inúmeras áreas, sendo dominante em Ciência de Dados, Machine Learning e Automação em geral. Mas o Python também pode ser utilizado para desenvolver aplicações Web, Desktop, para servidores de Rede, IoT (Internet das Coisas) e muito mais.

Além disso, sua sintaxe muito clara e organizada permite que seja aprendida com bastante facilidade, e em menor tempo que as outras linguagens, sendo por isso muito recomendada para iniciantes em programação em geral. É uma das linguagens mais utilizadas no mundo atualmente, além de ser altamente extensível com o emprego de suas inúmeras bibliotecas, como Matplotlib, Pandas, NumPy e diversas outras.

De acordo com o índice TIOBE de linguagens de programação, o Python é a terceira linguagem mais popular no mundo, atrás apenas das linguagens C e Java (desta última por uma pequena margem de menos de 0,4%):

Índice TIOBE – 12/2020. Fonte: www.tiobe.com/tiobe-index/

Sua maior desvantagem é que o Python é relativamente lento em comparação com outras linguagens, pois se trata de uma linguagem interpretada, de modo que para algumas aplicações, como sistemas de tempo real, não é a tecnologia mais indicada.

Outras linguagens

Além das cinco linguagens de programação citadas anteriormente, destaco mais duas (dessa vez, apostas) que podem ter impacto em seu currículo e em sua carreira. Uma delas é a linguagem Go (Golang), que vem crescendo paulatinamente, e a outra é a linguagem R, de nicho mais específico (ciência de dados / análise estatística), bastante utilizada no meio profissional.

Linguagem Go

Linguagem de programação criada pelo Google, também conhecida como Golang. Uma de suas principais características é o excelente suporte a multithreading, sendo ideal para o desenvolvimento de aplicações para sistemas distribuídos de grande porte.

É uma linguagem relativamente simples de aprender, devido à sua sintaxe clara e objetiva, mas ainda assim não tão fácil quanto o Python. Porém é bem rápida, sendo compilada em código de máquina, e se você trabalha em projetos de software de grande porte, que emprega processamento pesado em paralelizado, a linguagem Go é uma ótima escolha.

Linguagem R

A linguagem R, desenvolvida por Robert Gentleman e Ross Ihaka na Universidade de Auckland (Nova Zelândia) em 1992, é uma linguagem de código aberto para análise de dados estatística, amplamente empregada nas áreas de Ciência de Dados, Computação Estatística, Big Data e Aprendizado de Máquina. Seu aprendizado não é tão simples quanto o da linguagem Python, porém possui um rico ecossistema de pacotes, bibliotecas e ferramentas, incluindo bibliotecas para visualização gráfica de dados de alto padrão.

Permite o desenvolvimento de algoritmos para aprendizado de máquina altamente complexos e poderosos, e por conta dessas características é usada por muitas organizações atualmente.

Entre os pontos fracos do R podemos citar o gerenciamento de memória, não tão eficiente, e a falta de padrões de segurança mais elevados. Mas isso acaba não afetando o uso da linguagem, pois seu rico conjunto de ferramentas compensa facilmente essas deficiências.

Conclusão

Mostrei neste artigo cinco linguagens de programação para aprender em 2021 (que eu acredito serem relevantes em 2021), e nas quais vale a pena investir seu tempo de estudo. Não há nenhuma novidade ou grande surpresa na lista, pois afinal as linguagens apresentadas são as dominantes no mercado em seus nichos específicos, e todas tem grande potencial de te ajudar a alavancar sua carreira em tecnologia. 

É evidente que, se você pretende trabalhar, por exemplo, com desenvolvimento Web, deve dar preferência ao estudo de JavaScript e PHP em vez de C/C++ ou R; já se pretende trabalhar com ciência de dados, deve focar seus esforços no Python e linguagem R (e outras, como a linguagem Julia – assunto para um outro artigo!).

É isso aí! Bom final de ano a todos (e que o ano termine logo), e nos vemos em 2021. Abraço!

O post 5 Linguagens de Programação para aprender em 2021 apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Uma lista em C# é um objeto que armazena dados de um determinado tipo em uma ordem específica. Representa uma lista fortemente tipada de objetos que podem ser acessados por meio de um número de índice. O tipo de dado que a lista armazena é definido usando a sintaxe de genéricos. Por exemplo, vamos definir uma lista genérica de nome valores que irá armazenar números inteiros:

List<int> valores = new List<int>();

As listas em C# fazem parte do namespace System.Collection.Generic.

Diferença entre lista e array em C#

A diferença entre listas e arrays é a de que as listas possuem tamanho dinâmico (ajustável), ao passo que os arrays possuem tamanho fixo. Por conta disso, as listas são indicadas para quando não sabemos de antemão a quantidade de dados que serão armazenados. Uma lista armazena itens de um tipo especificado e cresce automaticamente quando novos itens (do mesmo tipo) são adicionados.

As listas são ideais para o armazenamento e recuperação de grandes números de elementos, como retornos de consultas a bancos de dados, por exemplo. Sua capacidade máxima em um sistema de 64 bits é de 2 bilhões de elementos. A capacidade de uma lista pode ser acessada ou ajustada por meio da propriedade Capacity.

Vamos estudar algumas operações que podem ser realizadas em listas em C#, usando Windows Forms e o Visual Studio para codificar nossos testes.

Propriedades e métodos da classe List<T>

A seguir temos algumas das principais propriedades e métodos da classe List<T> em C#:

Propriedades

• Items – Obtém ou grava o elemento na posição de índice especificada
• Count – Retorna o número total de elementos que existem na lista.

Métodos

• Add – Adiciona um elemento ao final da lista
• AddRange – Adiciona elementos de uma coleção especificada ao final da lista
• Clear – Remove todos os elementos de uma lista
• Contains – Verifica se um elemento especificado existe ou não em uma lista
• Insert – Insere um elemento em uma posição (índice) especificada na lista
• Remove – Remove a primeira ocorrência de um elemento especificado
• RemoveAt – Remove o elemento em uma posição especificada na lista
• Sort – Ordena os elementos da lista 

Inserir items em uma lista

Após inicializar uma lista, podemos inserir valores invocando o método Add():

List<int> valores = new List<int>();
valores.Add(16);
valores.Add(18);
valores.Add(23);
valores.Add(12);

Alternativamente, podemos inserir um array de itens de uma só vez usando o método AddRange():

List<int> valores = new List<int>();
int[] numeros = new int[] {16, 18, 23, 12};
valores.AddRange(numeros);

Contar os elementos da lista

Com o método Count podemos determinar quantos elementos uma lista possui:

List<int> valores = new List<int>();
int[] numeros = new int[] { 16, 18, 23, 12 };
valores.AddRange(numeros);
MessageBox.Show("A lista tem " + valores.Count() + " itens.");

Acessar um elemento na lista

Podemos acessar um elemento em uma lista genérica usando seu número de índice, que inicia em 0 (zero). Por exemplo, para acessar o primeiro elemento da lista do exemplo anterior podemos adicionar a seguinte linha de código:

MessageBox.Show("Primeiro item da lista: " + valores[0]);

Perceba a notação de colchetes usada para especificar o elemento 0 da lista: [0].

Remover itens de uma lista em C#

Usamos os métodos Remove e RemoveAt para remover itens de uma lista. O método Remove remove a primeira ocorrência do item especificado, ao passo que o método RemoveAt remove o item em uma posição de índice desejada.
Vamos aos exemplos.

1 – Remover a primeira ocorrência de um item. Vamos remover a primeira ocorrência do valor 18 em uma lista na qual esse valor aparece armazenado em duas posições distintas:

List<int> valores = new List<int>();
int[] numeros = new int[] { 16, 18, 23, 12, 22, 11, 18 };
valores.AddRange(numeros);
string strValores = String.Empty;

foreach (int item in valores)
{
  strValores += "\n" + item.ToString();
}

MessageBox.Show("Lista de valores: " + strValores);

valores.Remove(18); // Remove a primeira ocorrência do valor 18

strValores = String.Empty;
foreach (int item in valores)
{
  strValores += "\n" + item.ToString();
}

MessageBox.Show("Lista de valores: " + strValores);

2 – Agora vamos remover o quarto item da lista (índice 3).

List<int> valores = new List<int>();
int[] numeros = new int[] { 16, 18, 23, 12, 22, 11, 18 };
valores.AddRange(numeros);
string strValores = String.Empty;

foreach (int item in valores)
{
strValores += "\n" + item.ToString();
}

MessageBox.Show("Lista de valores: " + strValores);

valores.RemoveAt(3); // Remove o item no índice 3 (quarto item)
strValores = String.Empty;
foreach (int item in valores)
{
strValores += "\n" + item.ToString();
}
MessageBox.Show("Lista de valores: " + strValores);

Note que o valor 12, que é o quarto valor em nossa lista inicial, foi eliminado.

Inserir itens em uma lista em posição específica

Podemos inserir um elemento em uma lista em uma posição especificada usando o método Insert. Sua sintaxe é como segue:

Lista.Insert(Índice, Valor);

Esse método aceita dois argumentos:

• Índice – Posição na qual o item será inserido
• Valor – Valor do item a ser inserido na lista

Vejamos um exemplo. Vamos inserir o valor 13 na posição #2 (índice 1) de uma lista que já continha valores armazenados:

List<int> valores = new List<int>();
int[] numeros = new int[] { 16, 18, 23, 12 };
valores.AddRange(numeros);

MessageBox.Show("Segundo item da lista: " + valores[1]);

valores.Insert(1, 13); // Inserimos o valor 13 na segunda posição da lista
MessageBox.Show("Segundo item da lista: " + valores[1]);

Iterar pelos itens de uma lista

Podemos iterar pelos itens em uma lista genérica usando um laço foreach. Veja no exemplo a seguir, codificado em um botão usando Windows Forms no Visual Studio:

List<int> valores = new List<int>();

valores.Add(16);
valores.Add(18);
valores.Add(23);
valores.Add(12);

string strValores = String.Empty;

foreach(int item in valores)
{
  strValores += "\n" + item.ToString();
}

MessageBox.Show("Lista de valores: " + strValores);

Procurar um item em uma lista genérica

Com o método Contains podemos descobrir se um valor especificado existe em uma lista, o seja, se esse item está armazenado na lista. Ele retorna o booleano true se o valor for encontrado, e false se não for encontrado na lista. Por exemplo, queremos saber se o valor 16 está presente em uma lista:

List<int> valores = new List<int>();
int[] numeros = new int[] { 16, 18, 23, 12, 22, 11, 18 };
valores.AddRange(numeros);
string strValores = String.Empty;

int valorProcurado = 16;
bool valorExiste;

valorExiste = valores.Contains(valorProcurado);

if (valorExiste)
{
  MessageBox.Show("O item foi encontrado na lista");
}
else
{
  MessageBox.Show("Item inexistente na lista");
}

O método Contains da lista valores retorna true neste exemplo, pois o valor 16 está presente na lista genérica.

Preencher um ListBox com itens de uma lista

Suponha um controle ListBox de nome lstList, o qual queremos preencher com os elementos armazenados em uma lista genérica.

List<string> lugares = new List<string>();

lugares.Add("Fortaleza");
lugares.Add("Buenos Aires");
lugares.Add("Cairo");
lugares.Add("Sydney");
lugares.Add("Lima");
lugares.Add("Toronto");

foreach (string item in lugares)
{
  lstLista.Items.Add(item);
}

A caixa de listagem também pode ser preenchida usando-se o método ToArray da lista, em vez de usar um laço foreach, para passar seus elementos de uma vez à ListBox:

lstLista.Items.AddRange(lugares.ToArray());

Classificar Listas

Podemos classificar (ordenar) uma lista em C# empregando o método Sort(). Por exemplo, para ordenar a lista de valores usada nos exemplos anteriores, basta executarmos:

valores.Sort();

E os itens dentro desta lista estarão ordenados, em ordem numérica crescente.

É isso aí! Nos próximos tutoriais vamos abordar outras estruturas de armazenamento em C#, tais como Filas e Pilhas. Até!

O post Listas em C# – A classe genérica List<T> apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.