C++ Variáveis ​​e tipos: Int, Char, Float, Double, String e Bool

C++ Tipos de dados variáveis

C++ define todo um conjunto de tipos primitivos

O ESB ( anular type não tem valores associados e pode ser usado apenas em algumas circunstâncias. É mais comumente como o tipo de retorno de funções que não retornam um valor.

O ESB ( tipos aritméticos incluem caracteres, inteiros, valores booleanos e números de ponto flutuante. Tipo aritmético se dividido em 2 categorias

1. Tipos de ponto flutuante. O float (ou tipo flutuante) representa números decimais. O padrão IEEE especifica um número mínimo de dígitos significativos. A maioria dos compiladores geralmente fornece mais precisão do que o mínimo especificado. Normalmente, os floats são representados por 32 bits, os doubles em 64 bits e os long doubles em 96 ou 128 bits.
2. Tipos integrais (que incluem caracteres, números inteiros e tipos booleanos). O Booleano type possui apenas dois tipos de valores: True ou False. Existem vários carbonizar tipos, a maioria dos quais existe para apoiar a internacionalização. O tipo de caractere mais básico é char. Um char tem o mesmo tamanho de um único byte de máquina, o que significa um único byte.

O ESB ( Tipos integrais pode ser assinado ou não assinado.

Tipo assinado: Eles representam números negativos ou positivos (incluindo zero). Em um tipo assinado, o intervalo deve ser dividido igualmente entre os valores +ve e -ve. Assim, um caractere assinado de 8 bits conterá valores de –127 a 127.

Tipo não assinado: em um tipo não assinado, todos os valores são >= 0. Um caractere não assinado de 8 bits pode conter de 0 a 255 (ambos inclusivos).

Nome da variável ou identificadores

Os identificadores podem ser compostos por algumas letras, dígitos e o caractere de sublinhado ou alguma combinação deles. Nenhum limite é imposto ao comprimento do nome.

Os identificadores devem

• comece com uma letra ou um sublinhado ('_').
• E diferenciam maiúsculas de minúsculas; letras maiúsculas e minúsculas são distintas:

//define quatro variáveis ​​int diferentes

int guru99, gurU99, GuRu99, GURU99;

O ESB ( C++ linguagem reservou alguns nomes para seu uso.

Existem muitas convenções aceitas para nomear variáveis ​​em linguagens de programação diferentes. Seguir essas convenções pode melhorar a legibilidade do programa.

• Um identificador deve dar pelo menos alguma indicação do seu significado.
• Os nomes das variáveis ​​geralmente são minúsculos – guru99, não Guru99 ou GURU99.
• As classes que definimos geralmente começam com uma letra maiúscula.
• Os identificadores que contêm múltiplas palavras devem distinguir visualmente cada palavra. Por exemplo, guru99_website e não guru99website.

C++ Declaração e definição de variáveis

A declaração de uma variável torna um nome conhecido ao programa no escopo em que está definido. Exemplo:

int a=5;
int b;
char c='A'; 

int a,b;
a=b=1000;

List initialization
int a(5);
int b{5};

Qualificador Const em C++

Suponha que haja uma variável buffsize que indica o número de entradas a serem obtidas do usuário. Aqui, não queremos alterar o valor do buffsize ao longo do programa. Queremos definir uma variável cujo valor sabemos que não deve mudar.

Nesse caso, use a palavra-chave const

const int bufSize = 512;    // input buffer size

Isso define bufSize como uma constante. Qualquer tentativa de atribuir ou alterar bufSize gera um erro.

Aqui, não podemos alterar o valor de um objeto const depois de criá-lo, ele deve ser obrigatório ser declarado e inicializado. Caso contrário, o compilador gerará um erro.

const int i = get_size();  // ok: initialized at run time
const int j = 42;          // ok: initialized at compile time
const int k;               // error: k is uninitialized const
int i = 42;
const int ci = i;    	   // ok: the value in i is copied into ci 

Escopo das Variáveis ​​em C++

Um escopo é uma extensão de um programa onde uma variável tem um significado. Principalmente o mesmo nome pode ser usado para se referir a diferentes entidades em diferentes escopos. As variáveis ​​são visíveis desde o ponto onde são declaradas até o final do escopo em que aparece sua declaração.

#include <iostream>	
int main()	
{	
    int sum = 0;	
    // sum values from 1 through 10 inclusive	
    for (int val = 1; val <= 10; ++val)	
        sum += val;  // equivalent to sum = sum + val	
    cout << "Sum of 1 to 10 inclusive is "<< sum <<endl;	
    return 0;	
}	 

Este programa define 3 nomes, a saber, principal, soma e val. Ele usa o nome do namespace std, junto com outros dois nomes desse namespace – cout e endl.

• O nome da função “principal” é definido fora das chaves. O nome da função main — como a maioria dos outros nomes definidos fora de uma função — tem um escopo global. O que significa que, uma vez declarados, os nomes que estão no Âmbito global estão acessíveis durante todo o programa.
• A variável sum é definida no escopo do bloco que é o corpo da função principal. Ele pode ser acessado a partir do ponto de declaração e em todo o restante do corpo da função principal. Porém, não fora disso. Isso significa que a variável soma tem escopo de bloco.
• A variável val é definida no escopo da “instrução for”. Pode ser facilmente usado nessa instrução, mas não em outro lugar da função principal. Tem escopo local.

Escopo aninhado

O escopo pode conter outros escopos. O escopo contido (ou aninhado) é chamado de escopo interno. O escopo que contém é o escopo externo.

#include <iostream>	
using namespace std;	
// Program for illustration purposes only: It is bad style for a function	
// to use a global variable and also define a local variable with the same name	
int reused = 42;  // reused has global scope	
int main()	
{	
    int unique = 0; // unique has block scope	
    // output #1: uses global reused; prints 42 0	
    cout << reused << " " << unique << endl;	
    int reused = 0; // new, local object named reused hides global reused	
    // output #2: uses local reused; prints 0 0	
    cout << reused << " " << unique << endl;	
    // output #3: explicitly requests the global reused; prints 42 0	
    cout << ::reused << " " << unique << endl;	
    return 0;	
}	 

Produto # 1 aparece antes da definição local de reutilizado. Assim, esta saída

instrução é aquela que utiliza o nome reutilizado que está definido no escopo global. Esta declaração produz

42 0

Produto # 2 ocorre após a definição local de reutilizado. Agora está no escopo. Portanto, esta segunda instrução de saída simplesmente usa o objeto local denominado reusado em vez do objeto global e gera

0 0

Produto # 3 substitui as regras de escopo padrão usando o operador de escopo. O escopo global não tem nome. Assim, quando o operador de escopo (::) tem um lado esquerdo vazio. Ele interpreta isso como uma solicitação para buscar o nome no lado direito do escopo global. Assim, a expressão usa o global reutilizado e gera

42 0

Conversão de tipo variável

Uma variável de um tipo pode ser convertida em outro. É conhecido como “Conversão de tipo”. Vamos ver as regras para converter diferentes C++ tipos de variáveis:

A atribuição de não-bool a uma variável bool resulta em falso se o valor for 0 e verdadeiro caso contrário.

bool b = 42;            // b is true

Atribuir um bool a um dos outros tipos aritméticos produz 1 se o bool for verdadeiro e 0 se o bool for falso.

bool b = true;
int i = b;              // i has value 1

Atribuir um valor de ponto flutuante a uma variável do tipo int produz o valor que é truncado. O valor armazenado é a parte antes da vírgula decimal.

int i = 3.14;               // i has value 3

A atribuição de um valor int a uma variável do tipo float resulta na parte fracionária se tornando zero. A precisão geralmente é perdida se o número inteiro tiver mais bits do que a variável flutuante pode acomodar.

Int i=3;
double pi = i;          // pi has value 3.0

Se tentarmos atribuir um valor fora do intervalo a uma variável de tipo sem sinal, o resultado será o restante do valor %(módulo)

Por exemplo, um tipo unsigned char de 8 bits pode conter valores de 0 a 255, inclusive. Atribuir um valor fora deste intervalo fará com que o compilador atribua o restante desse valor módulo 256. Portanto, pela lógica acima, a atribuição de –1 a um caractere não assinado de 8 bits dá a esse objeto o valor 255.

unsigned char c = -1;   // assuming 8-bit chars, c has value 255

Se tentarmos atribuir um valor fora do intervalo a um objeto do tipo assinado, o resultado será imprevisível. É indefinido. O programa pode parecer funcionar externamente, ou pode travar, ou pode produzir valores inúteis.

signed char c2 = 256;   // assuming 8-bit chars, the value of c2 is undefined

O compilador aplica esse mesmo tipo de conversão quando usamos um valor de um tipo onde é esperado um valor de outro tipo.

int i = 42;
if (i) // condition will evaluate as true
i = 0; 

Se este valor= 0, então a condição é falsa; todos os outros valores (diferentes de zero) resultam em verdadeiros. Pelo mesmo conceito, quando usamos um bool em uma expressão aritmética, seu valor é sempre convertido em 0 ou 1. Como resultado, usar um bool em uma expressão aritmética geralmente é quase certamente incorreto.

Cuidado: não misture tipos assinados e não assinados

Expressões que misturam sinal e não sinal podem produzir resultados surpreendentes e errados quando o valor do sinal é negativo. Conforme discutido acima, os valores assinados são automaticamente convertidos em não assinados.

Por exemplo, em uma expressão aritmética como

x* y

Se x for -1 e y for 1, e se x e y forem int, então o valor será, como esperado, -1.

Se x for int e y não tiver sinal, então o valor desta expressão depende de quantos bits um inteiro possui na máquina de compilação. Na nossa máquina, esta expressão resulta em 4294967295.

Registrar Variáveis

Variáveis ​​de registro são mais rápidas de acessar em comparação com variáveis ​​de memória. Portanto, variáveis ​​que são frequentemente usadas em um C++ programa pode ser colocado em registradores usando cadastre-se palavra-chave. A palavra-chave registrar diz ao compilador para armazenar a variável fornecida em um registro. É escolha do compilador colocá-lo em um registro ou não. Geralmente, os próprios compiladores fazem várias otimizações que incluem colocar algumas variáveis ​​no registro. Não há limite para o número de variáveis ​​de registro em um C++ programa. Mas o compilador não pode armazenar a variável em um registrador. Isso ocorre porque a memória de registro é muito limitada e geralmente é usada pelo sistema operacional.

Definir:

register int i;

Comentários

Comentários são partes do código ignoradas pelo compilador. Ele permite que o programador faça anotações nas áreas relevantes do código-fonte/programa. Os comentários vêm em forma de bloco ou em linhas únicas. Os comentários do programa são declarações explicativas. Pode ser incluído no C++ código que ajuda qualquer pessoa a ler seu código-fonte. Todas as linguagens de programação permitem alguma forma de comentários. C++ suporta comentários de linha única e de várias linhas.

• Comentários de linha única são aqueles que começam com // e continuam até o final da linha. Se o último caractere de uma linha de comentário for \ então o comentário continuará na próxima linha.
• Comentários de várias linhas são aqueles que começam com /* e terminam com */.

/* This is a comment */
/* C++ comments can  also 
* span multiple lines 
*/

Sequências de Escape

Alguns caracteres, como backspace e caracteres de controle, não possuem imagem visível. Esses caracteres são conhecidos como caracteres não imprimíveis. Outros caracteres (aspas simples e duplas, ponto de interrogação e barra invertida) têm um significado especial em muitas linguagens de programação.

Nossos programas não são capazes de usar nenhum desses caracteres diretamente. Em vez disso, podemos usar uma sequência de escape para representar tal caractere. Uma sequência de escape começa com uma barra invertida.

O ESB ( C++ linguagem de programação define várias sequências de escape:

O que ele faz?	Personagem
Nova linha	\n
Guia vertical	\v
Barra invertida	\\
Retorno de carro	\r
Aba horizontal	\t
Retrocesso	\b
Ponto de interrogação	\?
Formfeed	\f
Alerta (campainha)	\a
Double citar	\ ”
Citação única	\ '

Usamos uma sequência de escape como se fosse um único caractere:

cout << '\n';        // prints a newline
cout << "\tguru99!\n";   // prints a tab followed by "guru99!" and a newline 

Também podemos escrever sequências de escape generalizadas \x seguidas por um ou mais dígitos hexadecimais. Ou usamos um \ seguido por um, dois ou três dígitos octais. A sequência de escape generalizada representa o valor numérico do caractere. Alguns exemplos (assumindo o conjunto de caracteres Latin-1):

\7 (bell)    \12 (newline)      \40 (blank)
\0 (null)    \115 ('M')         \x4d ('M') 

Podemos usar sequências de escape predefinidas, como usamos qualquer outro caractere.

cout << "Hi \x4dO\115!\n";  // prints Hi MOM! followed by a newline
cout << '\115' << '\n';     // prints M followed by a newline 

Resumo

• A C++ variável nos fornece um recurso de armazenamento nomeado.
• C++ tipos de variáveis: int, double, carbonizar, float, string, bool, etc.
• O escopo contido (ou aninhado) é chamado de escopo interno, e o escopo contido é o escopo externo.
• Uma variável de um tipo pode ser convertida em outro. É conhecido como “Conversão de tipo”.
• Variáveis ​​de registro são mais rápidas de acessar em comparação com variáveis ​​de memória.
• Comentários são partes do código ignoradas pelo compilador.
• Alguns caracteres, como backspace e caracteres de controle, não possuem imagem visível.