4. Variáveis
Last updated
Last updated
Em programação em geral, variáveis são como caixas, a caixa seria a variável e o conteúdo seria o valor a ser armazenado.
A memória em programação é um local onde as variáveis são armazenadas, como um container cheio de caixas e dentro das caixas temos diferentes valores, assim como temos valores diferentes podemos também ter tipos de caixas diferentes o que seriam os tipos de variáveis. Em C++ temos vários tipos de variáveis, sendo elas:
Variável tipo booleana, ou seja, assume apenas valores 1 ou 0 (TRUE ou FALSE), muito útil quando necessário saber apenas o estado de algo, sem precisar de qualquer nível de precisão. (não presente em c).
A variável tipo bool assume um valor de memória de um byte (8 bits), mas esse valor pode mudar dependendo da máquina em que o código está sendo compilado.
Variável tipo inteiro, ou seja dos números inteiros, e assim não assume valores fracionários, apenas valores inteiros, amplamente usada para declaração de alguma contagem ou para níveis de precisão baixos em alguma medida ou valor.
Percebe-se, portanto, que não é possível colocar um valor de 18.5, por exemplo, isso porque estamos lidando com um tipo de variável inteiro. A variável tipo inteiro assume um valor de memória de 4 bytes e assim seu valor máximo de um inteiro é de -2.147.483.648 a 2.147.483.648.
Existem outros modos específicos de se declarar uma variável int, além de alguns modificadores.
Exemplo:
signed e unsigned define se a variável inteiro irá assumir valores negativos, porém aumentando a faixa de valores positivos.
short, long e long long define se o inteiro terá 16 bits ou 32 bits, sendo 16 bits um short, long sendo 32 bits e long long sendo 64 bits, sendo o default 32 bits.
Porém o long long depende do hardware. podemos também combiná-los e criar, por exemplo, um unsigned long long int.
Além disso existe outro jeito de declarar variáveis inteiras:
O “u” significa unsigned, int remete a variável tipo inteiro, o “16” representa a quantidade de bits.
A diferença entre as definições são que independentemente do hardware do computador que estiver sendo executado esse código, está variável terá 16 bits, nesse caso
As variáveis pointer, ou ponteiros, são capazes de armazenar uma informação de uma variável em um lugar especificado da memória. Essa capacidade de “apontar” traz diversos usos a este elemento.
Sintaxe:
O carácter * indica que a variável declarada aponta para um inteiro, nesse caso.
O carácter retorna o local de memória que será apontado, nesse caso o local de memória da variável inteiro.
Variáveis Float e Double são muito utilizadas em valores decimais e exponenciais, oferecendo mais precisão comparadas ao recurso Int. Enquanto o tipo float é utilizado em aplicações mais simples (4 bytes), o double pode apresentar o dobro de precisão nas casas decimais (8 bytes).
Sintaxe:
Em C++, o tipo de dado char é utilizado para armazenar o valor de uma variável como um único caractere. Esses caracteres podem incluir letras, números ou até mesmo símbolos em alguns casos.
Abaixo temos um exemplo de alguns dos caracteres codificados:
Sintaxe:
deve ser declarada entre aspas simples: ‘ ’
Assim como a variável char, a String armazena letras, números e símbolos, com um único porém, podemos armazenar apenas uma série de caracteres. Por isso, é comum ser chamada e usada na programação como um vetor de Char.
Sintaxe:
Os Arrays e Vetores são como conjuntos, por exemplo: ao invés de usarmos 7 variáveis, uma para cada dia da semana, podemos criar um vetor de inteiros, com 7 valores variáveis, cada um correspondente a um dia da semana. Vale lembrar que o primeiro número do vetor tem a coordenada 0.
Exemplo:
A diferença entre Array e Vetores é apenas o jeito em que o processador lida com essas variáveis. O Array é usado em C e tem algumas diferenças como: ter que indicar o tamanho máximo do Array, e algumas diferenças de Sintaxe na inicialização, a sua grande vantagem é por ser mais otimizado em relação a alocação de memórias, enquanto o vetor é mais fácil de usar e implementar em códigos.
Pilhas são arrays que são ordenados como uma pilha de livros, o último dado colocado na pilha, deve ser o primeiro dado a sair, portanto segue o padrão FILO (First in Last Out).
● Exemplo em código:
Neste corpo de código, estamos executando 3 funções na nossa variável pilha:
.push();
Adiciona um elemento ao topo da pilha.
.empty();
Retorna true se a pilha estiver vazia, e false em caso contrário.
.top();
Retorna o elemento do topo da pilha.
.pop();
Retira o elemento do topo da pilha.
Filas são arrays que são ordenados como uma fila do dia a dia, o primeiro dado colocado na pilha, deve ser o primeiro dado a sair, portanto segue o padrão FIFO(First in First Out)
Neste corpo de código, estamos executando 3 funções na nossa variável fila:
.push();
Adiciona um elemento ao final da fila.
.empty();
Retorna true se a fila estiver vazia, e false em caso contrário.
.front();
Retorna o elemento do começo da fila.
.pop();
Retira o elemento do começo da fila.
Conjuntos em C++ são uma extensão dos conjuntos matemáticos, portanto, não assumem valores repetidos e são sempre ordenados do menor para o maior valor.
● Exemplo em código:
Os conjuntos possuem várias funções dentro das bibliotecas, entre elas:
.begin();
Retorna o primeiro elemento do conjunto.
.end();
Retorna o último elemento do conjunto.
.size();
Retorna o tamanho do conjunto.
Listas são arrays que se pode mudar o tamanho máximo, ao invés de ser dado um tamanho fixo previamente conhecido ao array, nas listas não é necessário passar um valor previamente conhecido, já que esse valor pode ser alterado a qualquer momento, dependendo da necessidade.
● Exemplo em código:
Esse código lida com valores em uma lista, adicionando valores, retirando e somando os valores da lista. Importante notar que quando a lista é criada, não é passada o tamanho dela, com o tamanho variando ao longo do código.
O resultado desse código é o seguinte:
Podemos ver que no final a lista tem dois elementos, ou seja, o tamanho final dela é 2, ao longo do código, esse tamanho vai de 0 a 4, até ficar em 2.
● Diferença de lista em C e em C++:
Facilidade de uso: Em C é preciso implementar manualmente a estrutura de dados e as funções para usar a lista, em C++ já existe a biblioteca STL, que possui tudo pronto dentro.
Segurança e eficiência: Em C a manipulação de memória deve ser feita manualmente, com risco de erros, em C++ essa manipulação é automática.
Uma struct é como uma estrutura de variáveis, onde essa estrutura pode ser formada por várias variáveis, como um grupo de variáveis. Um exemplo para simplificar, uma pessoa possui idade, sexo e peso, esses três são as variáveis, eu posso agrupar essas variáveis em um grupo “pessoa”, esse grupo é a struct. É possível criar uma struct e variáveis dentro dessa struct, ao invés de cria-la de forma global, por exemplo.
● Exemplo em código:
Esse código está criando duas “pessoas”, duas structs “pessoa”, que possuem as variáveis “idade”, “sexo” e “peso”. Os valores de cada variável estão sendo associados à essas “pessoas”, e depois os valores são exibidos no console.
● Diferença de struct em C e em C++:
Funções-Membro: Struct em C não suporta funções-membro dentro de structs, já em C++, suporta funções-membro, incluindo construtores, destrutores e outras funções. OO(Orientação a Objeto): Em C, structs são usadas apenas para agrupar dados, já em C++, structs podem usar recursos de OO como herança e polimorfismo.
Inicialização: Em C structs não suportam inicializadores de membros, já em C++, suportam inicializadores de membro (via construtores).
Herança: Em C structs não suportam heranças, já em C++, suportam herança de classes e structs.
Um enumerador é um tipo de dado que consiste em um conjunto de valores, que recebem nomes, também chamados de enumeradores, e possuem valores fixos, que normalmente são em uma sequência. É usado justamente para atribuir os valores dessa sequência a nomes, tornando o código mais fácil de ler.
Um enumerador é criado basicamente da seguinte forma:
enum “nome” : “tipo” {enum1, enum2…, enumN};
Os valores dos enumeradores é em ordem crescente, a partir de “0”, como não foi associado um valor manualmente ao criar os enumeradores, então enum1 = 0, enum2 = 1, enumN = N-1.
Se quisermos mudar o valor dos enumeradores, também podemos, da seguinte forma:
enum “nome” : “tipo” {enum1 = 4, enum2, enum3 = 9, enum4};
Manualmente foi associado o valor de enum1 e de enum3, enum1 é igual a 4,
como enumeradores seguem uma sequência, enum2 = 5, e como enum3 = 9,
enum4 = 10.
Ao criarmos um enumerador, podemos criar um escopo para ele, criando uma “classe”, após criarmos o enumerador com esse escopo, só é possível acessar os valores dos enumeradores chamando através dessa “classe”. Ou seja, sem escopo os enumeradores são públicos, com escopo, os enumeradores são privados à “classe” do enumerador.
● Exemplo em código:
São criados os enumeradores com e sem escopo, e também é criada uma função que será chamada para usar os enumeradores sem escopo, ou seja, os enumeradores públicos.
Aqui é criada uma função para usar os enumeradores com escopo, ou seja, é preciso chamar os enumeradores através da “classe”.
O resto do código, onde são chamadas as funções, passando os valores deles, e os exibidos no console.
Vemos que o resultado quando usamos os enumeradores com e sem escopo é o mesmo, a diferença de usar com ou sem escopo, é de onde você acessa os enumeradores, e “quem” pode acessar eles, “quem” sendo outras funções, por exemplo.
● Diferença de enumerador em C e em C++:
Tipo Subjacente: Em C o tipo do enum sempre vai ser int, em C++ ele pode
ser especificado usando enum class : “tipo”.
Conversão implícita: Em C é possível fazer conversão implícita, isso é, o compilador converte um tipo de dado em outro tipo, sem ser feito manualmente no código, então é possível fazer algo como por exemplo:
enum Color MyColor
= Green; int colorValue = myColor;
Em C++ isso só é possível se usar um “enum clássico”, ou seja, ele não é um “enum class”, se for um “enum class”, esse tipo de associação não é permitida.
Escopo: Em C os escopos são somente globais ou de bloco, em C++ esses escopos podem ser restringidos também ao próprio “enum”.
A representação desses caracteres é viabilizada pela existência da tabela , que atribui a cada caractere uma codificação específica.
