Variáveis e Tipos em C++

Introdução

Neste laboratório, você aprenderá sobre variáveis e tipos em C++. Você aprenderá como definir variáveis e como usar diferentes tipos de variáveis.

Pré-visualização do Conteúdo

Programas de computador manipulam (ou processam) dados. Uma variável é usada para armazenar um pedaço de dados para processamento. É chamada de variável porque você pode alterar o valor armazenado.

• Variáveis
• Identificadores (Identifiers)
• Declaração de Variáveis (Variable Declaration)
• Constantes
• Expressões
• Atribuição (Assignment)
• Tipos Básicos (Basic Types)
• Literais para Tipos Básicos e String

Variáveis

Uma variável é um local de armazenamento nomeado, que armazena um valor de um determinado tipo de dado. Em outras palavras, uma variável tem um nome, um tipo e armazena um valor.

• Uma variável tem um nome (ou identificador), por exemplo, radius, area, age, height. O nome é necessário para identificar exclusivamente cada variável, a fim de atribuir um valor à variável e recuperar o valor armazenado.
• Uma variável tem um tipo, como int ou double.
• Uma variável pode armazenar um valor desse tipo específico. Uma variável está associada a um tipo e só pode armazenar valores desse tipo específico.
• O tipo determina o tamanho e o layout dos dados, a faixa de seus valores e o conjunto de operações que podem ser aplicadas.

O diagrama a seguir ilustra dois tipos de variáveis: int e double. Uma variável int armazena um inteiro (número inteiro). Uma variável double armazena um número real.

Identificadores

Um identificador é necessário para nomear uma variável (ou qualquer outra entidade, como uma função ou uma classe). C++ impõe as seguintes regras aos identificadores:

• Um identificador é uma sequência de caracteres, composta por letras maiúsculas e minúsculas (a-z, A-Z), dígitos (0-9) e sublinhado "_".
• Espaços em branco (espaço, tabulação, nova linha) e outros caracteres especiais (como +, -, *, /, '@', etc.) não são permitidos.
• Um identificador deve começar com uma letra ou sublinhado. Não pode começar com um dígito. Identificadores que começam com um sublinhado são normalmente reservados para uso do sistema.
• Um identificador não pode ser uma palavra-chave reservada ou um literal reservado (por exemplo, int, double, if, else, for).
• Identificadores são sensíveis a maiúsculas e minúsculas. rose NÃO é Rose e NÃO é ROSE.

Convenção de Nomenclatura de Variáveis

Um nome de variável é um substantivo ou uma frase nominal composta por várias palavras. A primeira palavra está em minúsculas, enquanto as palavras restantes são capitalizadas inicialmente, sem espaços entre as palavras. Por exemplo, thefontSize, roomNumber, xMax e thisIsAVeryLongVariableName, que é conhecido como camel-case.

Recomendações

1. É importante escolher um nome que seja auto-descritivo e reflita de perto o significado da variável, por exemplo, numberOfStudents ou numStudents.
2. Não use nomes sem sentido como a, b, c, d, i, j, k, i1, j99. Evite nomes de um único alfabeto, a menos que sejam nomes comuns como x, y, z para coordenadas, i para índice.
3. É perfeitamente aceitável usar nomes longos, digamos, 30 caracteres, para garantir que o nome reflita com precisão seu significado.
4. Use substantivos singulares e plurais prudentemente para diferenciar entre variáveis singulares e plurais. Por exemplo, use a variável row para se referir a um único número de linha e rows para se referir a muitas linhas.

Declaração de Variáveis

Você precisa primeiro declarar seu nome e tipo antes de usá-lo, em uma das seguintes sintaxes:

Por exemplo

int mark1;           // Declare an int variable called mark1
mark1 = 76;          // Use mark1
int mark2;           // Declare int variable mark2
mark2 = mark1 + 10;  // Use mark2 and mark1
double average;      // Declare double variable average
average = (mark1 + mark2) / 2.0;   // Use average, mark1 and mark2
int mark1;           // Error: Declare twice
mark2 = "Hello";     // Error: Assign value of a different type
int number;             // Declared but not initialized
cout << number << endl; // Used before initialized, no warning/error, but unexpected result.

Observe que:

• Em C++, você precisa declarar o nome de uma variável antes que ela possa ser usada.
• C++ é uma linguagem "fortemente tipada". Uma variável assume um tipo. Uma vez que o tipo de uma variável é declarado, ela só pode armazenar um valor pertencente a esse tipo específico.
• Cada variável só pode ser declarada uma vez.
• Em C++, você pode declarar uma variável em qualquer lugar dentro do programa, desde que seja declarada antes de ser usada.
• O tipo de uma variável não pode ser alterado dentro do programa.
• Uma variável recém-declarada, mas não inicializada, contém lixo. C/C++ não emite nenhum aviso/erro se você usar uma variável antes de inicializá-la - o que levará a alguns resultados inesperados.

Constantes (const)

Constantes são variáveis não modificáveis, declaradas com a palavra-chave const. Seus valores não podem ser alterados durante a execução do programa. Além disso, const deve ser inicializado durante a declaração. Por exemplo:

const double PI = 3.1415926;  // Need to initialize

Convenção de Nomenclatura de Constantes: Use palavras em maiúsculas, unidas por sublinhado. Por exemplo, MIN_VALUE.

Expressões

Uma expressão é uma combinação de operadores (como '+', '-', '*', '/') e operandos (variáveis ou valores literais), que pode ser avaliada para produzir um único valor de um determinado tipo. Por exemplo,

1 + 2 * 3           // give int 7

int sum, number;
sum + number        // evaluated to an int value

double principal, interestRate;
principal * (1 + interestRate)  // evaluated to a double value

Atribuição (=)

Uma declaração de atribuição:

1. atribui um valor literal (do lado direito - RHS) a uma variável (do lado esquerdo - LHS); ou
2. avalia uma expressão (do RHS) e atribui o valor resultante a uma variável (do LHS).

O RHS deve ser um valor; e o LHS deve ser uma variável (ou endereço de memória).

A sintaxe para a declaração de atribuição é:

A declaração de atribuição deve ser interpretada da seguinte forma: A expressão no lado direito (RHS) é primeiro avaliada para produzir um valor resultante (chamado de rvalue ou valor direito). O rvalue é então atribuído à variável no lado esquerdo (LHS) (ou lvalue, que é um local que pode conter um rvalue).

Tipos Básicos

A tabela abaixo mostra o tamanho típico, o mínimo e o máximo para os tipos primitivos. Novamente, observe que os tamanhos dependem da implementação.

O Operador sizeof

C/C++ fornece um operador unário sizeof para obter o tamanho do operando (em bytes). O seguinte programa usa o operador sizeof para imprimir o tamanho dos tipos fundamentais (salve o código a seguir em test.cpp em /home/labex/Code).

/*
 * Print Size of Fundamental Types.
 */
#include <iostream>
using namespace std;

int main() {
   cout << "sizeof(char) is " << sizeof(char) << " bytes " << endl;
   cout << "sizeof(short) is " << sizeof(short) << " bytes " << endl;
   cout << "sizeof(int) is " << sizeof(int) << " bytes " << endl;
   cout << "sizeof(long) is " << sizeof(long) << " bytes " << endl;
   cout << "sizeof(long long) is " << sizeof(long long) << " bytes " << endl;
   cout << "sizeof(float) is " << sizeof(float) << " bytes " << endl;
   cout << "sizeof(double) is " << sizeof(double) << " bytes " << endl;
   cout << "sizeof(long double) is " << sizeof(long double) << " bytes " << endl;
   cout << "sizeof(bool) is " << sizeof(bool) << " bytes " << endl;
   return 0;
}

Saída:

sizeof(char) is 1 bytes
sizeof(short) is 2 bytes
sizeof(int) is 4 bytes
sizeof(long) is 4 bytes
sizeof(long long) is 8 bytes
sizeof(float) is 4 bytes
sizeof(double) is 8 bytes
sizeof(long double) is 12 bytes
sizeof(bool) is 1 bytes

A Declaração typedef

Digitar unsigned int muitas vezes pode ser irritante. A declaração typedef pode ser usada para criar um novo nome para um tipo existente. Por exemplo, você pode criar um novo tipo chamado "uint" para "unsigned int" da seguinte forma. Você deve colocar o typedef imediatamente após #include. Use typedef com cuidado porque torna o programa difícil de ler e entender.

typedef unsigned int uint;

Muitos compiladores C/C++ definem um tipo chamado size_t, que é um typedef de unsigned int.

typedef unsigned int size_t;

Literais para Tipos Básicos e String

Literais inteiros (integer literals)

Um número inteiro, como 123 e -456, é tratado como um int, por padrão. Por exemplo,

int number = -123;
int sum = 4567;

Além dos inteiros padrão na base 10, você pode usar um prefixo '0x' para um valor em hexadecimal e o prefixo '0b' para um valor binário (em alguns compiladores), por exemplo,

int number1 = 1234;       // Decimal
int number2 = 01234;      // Octal 1234, Decimal 2322
int number3 = 0x1abc;     // hexadecimal 1ABC, decimal 15274
int number4 = 0b10001001; // binary (may not work in some compilers)

Um literal long é identificado por um sufixo 'L' ou 'l' (evite minúsculas, que podem ser confundidas com o número um). Um long long int é identificado por um sufixo 'LL'. Você também pode usar o sufixo 'U' para unsigned int, 'UL' para unsigned long e 'ULL' para unsigned long long int. Por exemplo,

long number = 12345678L;     // Suffix 'L' for long
long sum = 123;              // int 123 auto-casts to long 123L
long long bigNumber = 987654321LL;  // Need suffix 'LL' for long long int

Nenhum sufixo é necessário para literais short. Mas você só pode usar valores inteiros no intervalo permitido. Por exemplo,

short midSizeNumber = -12345;

Literais de ponto flutuante (floating-point literals)

Um número com um ponto decimal, como 55.66 e -33.44, é tratado como um double, por padrão. Você também pode expressá-los em notação científica, por exemplo, 1.2e3, -5.5E-6, onde e ou E denota o expoente na potência de 10. Você pode preceder a parte fracionária ou o expoente com um sinal de mais (+) ou menos (-). O expoente deve ser um inteiro.

Você DEVE usar um sufixo de 'f' ou 'F' para literais float, por exemplo, -1.2345F. Por exemplo,

float average = 55.66;      // Error! RHS is a double. Need suffix 'f' for float.
float average = 55.66f;

Use o sufixo 'L' (ou 'l') para long double.

Literais bool (bool literals)

Existem apenas dois literais bool, ou seja, true e false. Por exemplo,

bool done = true;
bool gameOver = false;
int i;
if (i == 9) {   // returns either true or false
   ......
}

Literais de caractere (character literals)

Um literal char imprimível é escrito envolvendo o caractere com um par de aspas simples, por exemplo, 'z', '$' e '9'. Em C++, os caracteres são representados usando o código ASCII de 8 bits e podem ser tratados como inteiros com sinal de 8 bits em operações aritméticas. Em outras palavras, char e inteiro com sinal de 8 bits são intercambiáveis. Você também pode atribuir um inteiro no intervalo de [-128, 127] a uma variável char; e [0, 255] a um unsigned char. Por exemplo,

char letter = 'a';             // Same as 97
char anotherLetter = 98;       // Same as the letter 'b'
cout << letter << endl;        // 'a' printed
cout << anotherLetter << endl; // 'b' printed instead of the number
anotherLetter += 2;            // 100 or 'd'
cout << anotherLetter << endl; // 'd' printed
cout << (int)anotherLetter << endl;  // 100 printed

Literais de string (string literals)

Um literal String é composto por zero ou mais caracteres cercados por um par de aspas duplas, por exemplo, "Olá, mundo!", "A soma é ", "". Por exemplo,

String directionMsg = "Turn Right";
String greetingMsg = "Hello";
String statusMsg = "";             // empty string

Exemplo (Literais)

/* Testing Primitive Types */
#include <iostream>
using namespace std;

int main() {
   char gender = 'm';             // char is single-quoted
   bool isMarried = true;         // true(non-zero) or false(0)
   unsigned short numChildren = 8; // [0, 255]
   short yearOfBirth = 1945;      // [-32767, 32768]
   unsigned int salary = 88000;   // [0, 4294967295]
   double weight = 88.88;       // With fractional part
   float gpa = 3.88f;           // Need suffix 'f' for float

   // "cout <<" can be used to print value of any type
   cout << "Gender is " << gender << endl;
   cout << "Is married is " << isMarried << endl;
   cout << "Number of children is " << numChildren << endl;
   cout << "Year of birth is " << yearOfBirth << endl;
   cout << "Salary is " << salary << endl;
   cout << "Weight is " << weight << endl;
   cout << "GPA is " << gpa << endl;
   return 0;
}

Saída:

Gender is m
Is married is 1    // true
Number of children is 8
Year of birth is 1945
Salary is 88000
Weight is 88.88
GPA is 3.88

Resumo

Nesta parte, apresentamos vários tipos fundamentais. Você deve saber como representar uma variável e como operar nela. Tenha em mente qual é o tamanho de cada tipo na memória e o intervalo para cada tipo.