Resumo da Aula 2

Sumário

Estrutura básica de um programa
Variáveis
- Sintaxe da definição de variáveis
- Exemplos
Tipos básicos
Caracteres
- Exemplos
Valores literais
- Exemplos
Constantes
- Exemplos
Operadores
Canais: leitura do teclado e escrita no ecrã
- Exemplo de escrita no ecrã (ou inserção no canal cout)
- Exemplo de leitura do teclado (ou extracção do canal cin)
Instruções condicional if e de selecção if else
- Sintaxe
  - Instrução de selecção
  - Instrução condicional
- Exemplos
Instruções de iteração
- A instrução de iteração while
  - Sintaxe
  - Exemplo
- A instrução de iteração for
Utilização do depurador gdb no editor XEmacs

1 Estrutura básica de um programa

// Inclusão de ficheiros de interface de bibliotecas e módulos (a explicar mais tarde):
#include <iostream>
// Directiva de utilização do espaço nominativo std (a explicar mais tarde):
using namespace std;
int main()
{
... // Aqui é onde se escreve o programa.
}

Nota: Todas as frases precedidas de // ou entre /* e */ são comentários, sendo ignorados pelo compilador.

2 Variáveis

Uma variável tem três características: um nome, um tipo e um valor. As duas primeiras características são fixas durante a vida da variável. A terceira característica é variável.
A definição de uma variável indica o seu tipo, o seu nome e o seu valor inicial.
A definição de uma variável pode em geral omitir a indicação do seu valor inicial. No caso das variáveis de tipos básicos (ver abaixo), tal omissão conduz a que contenham valores arbitrários, i.e., lixo (excepto se forem variáveis globais, mas isso será assunto para aulas posteriores).
Por abuso de linguagem, muitas vezes chama-se inicialização à primeira atribuição feita a uma variável não inicializada.

2.1 Sintaxe da definição de variáveis

tipo nome = valor;//definição de uma variável.
tipo nome(valor); // idem.

tipo nome; // definição de uma variável sem inicialização.

2.2 Exemplos

double y = 2.1; // definição de uma variável do tipo double denominada y e
                 //com valor inicial 2,1.

int x;           // definição de uma variável do tipo int denominada x e
                 //não inicializada (contém lixo).
x = 2;           // atribuição do valor 2 à variável x (não é uma inicialização).

3 Tipos básicos

Tipo	Descrição	Gama de valores (típica)	Número de Bits (típico)
`bool`	valor booleano	`true` e `false`	8
`int`	número inteiro	-2³¹ a 2³¹-1 (-2147483648 a 2147483647)	32
`float`	número decimal (com vírgula)	1.17549435 × 10^-38 a 3.40282347 × 10³⁸ (e negativos)	32
`char`	caractere (usa código ISO Latin1)	Qualquer caractere. Exemplos: '`a`', '`A`', '`1`', '`!`', '`*`', etc.	8
`short [int]`	número inteiro	-2¹⁵ a 2¹⁵-1 (-32768 a 32767)	16
`unsigned short [int]`	número inteiro positivo	0 a 2¹⁶-1 (0 a 65535)	16
`unsigned [int]`	número inteiro positivo	0 a 2³²-1 (0 a 4294967295)	32
`long [int]`	número inteiro	a mesma que `int`	32
`unsigned long [int]`	número inteiro positivo	a mesma que `unsigned int`	32
`double`	número decimal de precisão dupla	2.2250738585072014 × 10^-308 a 1.7976931348623157 × 10³⁰⁸ (e negativos)	64
`long double`	número decimal de precisão tripla	3.36210314311209350626e × 10^-4932 a 1.18973149535723176502 × 10⁴⁹³² (e negativos)	96

Notas:

Os caracteres (char) são interpretados como números inteiros em C++. Assim, quer em Linux sobre processadores Intel quer no Windows NT, a gama dos códigos vai de -128 a 127, isto é, os char são interpretados como números inteiros com sinal.
Alguns dos tipos derivados do int podem ser escritos de uma forma abreviada: os [] indicam a parte opcional na especificação do tipo.
O número de bits usado pelas variáveis de cada tipo refere-se ao sistema operativo Linux. Em Windows NT o long double tem 64 bits.

4 Caracteres

Em C++, cada caractere (um dado símbolo gráfico) é representado por um determinado valor inteiro: o seu código.

4.1 Exemplos

char caractere = 'a';
++caractere; // o mesmo que caractere = caractere + 1.
cout << "O caractere seguinte é: " << caractere << endl;
cout << "O seu código é: " << int(caractere) << endl;

O resultado da execução das linhas acima é:

O caractere seguinte é: b O seu código é: 98

Adicionou-se uma unidade ao código do caractere 'a' (97) de modo que a variável caractere passou a conter o código do caractere 'b' (98).

Importante: Isto é válido porque, no código usado em Linux (ASCII), as letras do alfabeto possuem códigos sucessivos (quer em maiúsculas quer em minúsculas).

(Experimente fazer o mesmo para o caractere 'z' ou para o caractere 'Z' e veja o resultado.)

5 Valores literais

Além de variáveis, também é necessário usar valores literais.

5.1 Exemplos

'a'      // do tipo char, representa o código do caractere 'a'.
100      // do tipo int, valor 100 (em decimal).
100.0    // do tipo double (e não float).
100.0F   // do tipo float.
100.0L   // do tipo long double.
1.3e230 // do tipo double, valor 1,3 × 10²³⁰.

6 Constantes

Quando numa definição se coloca o qualificador const imediatamente após o tipo, o valor da variável passa a ser fixo, não podendo ser modificado. Nesse caso deixa de se ter uma variável: passa a ser uma constante. Como é óbvio, as constantes têm de ser inicializadas durante a definição.

O nome genérico para variáveis e constantes é instância.

6.1 Exemplos

int const x = 2;
char const cifrão = ´$´;

7 Operadores

7.1 Operadores aritméticos

+ (soma)
- (subtracção)
* (multiplicação)
/ (divisão inteira)
% (resto da divisão inteira [módulo])

7.2 Operadores relacionais e de comparação

> (maior)
< (menor)
>= (maior ou igual)
<= (menor ou igual)
== (igual)
!= (diferente)

7.3 Operadores lógicos

not negação (ou !)
and conjunção (ou &&)
or disjunção (ou ||)

7.4 Operadores de atribuição

= (atribuição)
+= (x += y é equivalente a x = x + y)
-= (x -= y é equivalente a x = x - y)
*= (x *= y é equivalente a x = x * y)
/= (x /= y é equivalente a x = x / y)
%= (x %= y é equivalente a x = x % y)

Importante: Repare-se bem na diferença entre = (atribuição) e == (comparação, igual).

Nota: Mais tarde se verá que as "equivalências" acima não são rigorosamente equivalentes...

7.5 Operadores de incrementação e decrementação

++ (x++ e ++x são equivalentes a x = x + 1)
-- (x-- e --x são equivalentes a x = x - 1)

Nota: Em rigor estas "equivalências" não são verdadeiras. Ver as folhas teóricas para mais pormenores.

7.6 Operadores bit-a-bit

compl   negação (ou ~)
bitand conjunção (ou &)
bitor   disjunção (ou |)
xor     disjunção exclusiva (ou ^)
<< (deslocamento para a esquerda [atenção! não confundir com a inserção num canal!])
>> (deslocamento para a direita [atenção! não confundir com a extracção de um canal!])

Importante: Os operadores bit-a-bit devem ser utilizados apenas sobre valores de tipos aritméticos inteiros sem sinal.

8 Canais: leitura do teclado e escrita no ecrã

8.1 Exemplo de escrita no ecrã (ou inserção no canal `cout`)

int a = 10;
cout << "Vou escrever um número a seguir a esta frase: " << a << endl;

8.2 Exemplo de leitura do teclado (ou extracção do canal `cin`)

cin >> a;

Importante: Ao ser executada uma operação de leitura como acima, o computador interrompe a execução do programa até que seja introduzido algum valor no teclado.

9 Instruções condicional `if` e de selecção `if` `else`

9.1 Sintaxe

9.1.1 Instrução de selecção

if(expressão_booleana)

instrução_controlada₁
else
instrução_controlada₂ ou, usando instruções compostas (ou blocos de instruções),

if(expressão_booleana) {

... // instruções a executar se a expressão booleana for verdadeira.
} else {
... // instruções a executar se a expressão booleana for falsa.
}

9.1.2 Instrução condicional

if(expressão_booleana)
instrução_controlada //Se a expressão booleana for falsa continua o programa.

ou, usando instruções compostas (ou blocos de instruções),

if(expressão_booleana) {

... // instruções a executar se a expressão booleana for verdadeira.
}
// Se a expressão booleana for falsa continua o programa.

9.2 Exemplos

if(x > 0)
cout << "x é positivo." << endl;
else {
cout << "x é negativo ou zero (não-positivo)." << endl;
}

As instruções if else podem ser encadeadas. Por exemplo,

if(x > 0) {
    cout << "x é positivo." << endl;
} else
    if(x < 0)
        cout << " x é negativo " << endl;

Mas nesse caso é usual usar uma indentação diferente para o código C++ de modo a deixar mais clara a sequência de instruções alternativas,

if(x > 0) {
cout << "x é positivo." << endl;
} else if(x < 0)
cout << " x é negativo " << endl;

Nota: Quando existe apenas uma instrução dentro de um dos blocos a executar podem ser omitidas as chavetas, como é o caso do else e do segundo if.

Nota: O bloco else pode não existir, caso não se pretenda executar nenhuma instrução quando a expressão booleana for falsa, como é o caso do segundo if.

Importante: Por vezes pode ser ambíguo a que if diz respeito um dado else. A regra é que o else pertence ao if mais interior (mais "próximo"). A indentação utilizada não influencia a interpretação do compilador, embora possa induzir o programador em erro. Por exemplo, o código

if(x >= 0)
    if(x > 0)
        cout << "x é positivo." << endl;
else
    cout << "x é negativo." << endl;

não faz o que é suposto, pois é equivalente a

if(x >= 0) {
    if(x > 0)
        cout << "x é positivo." << endl;
    else
        cout << "x é negativo." << endl;
}

Para que o código faça o que se pretendia é necessário envolver o if mais interior em chavetas de modo a impossibilitar a sua associação com o else, i.e.,

if(x >= 0) {
    if(x > 0)
       cout << "x é positivo." << endl;
} else
    cout << "x é negativo." << endl;

Nota: Uma instrução if sem else é sempre equivalente a uma instrução if else em que a instrução controlada pelo else é a instrução nula (que só possui o terminador ;). Ou seja,

if(x > 0)
cout << "x é positivo" << endl;

é equivalente a

if(x > 0)
cout << "x é positivo" << endl;
else
;

10 Instruções de iteração

10.1 A instrução de iteração `while`

A instrução de iteração while serve para repetir a instrução instrução_controlada enquanto se verificar a condição dada pela expressão_booleana.

10.1.1 Sintaxe

while(expressão_booleana)
instrução_controlada ou, usando uma instrução composta (ou bloco de instruções),

while(expressão_booleana)
{

instruções
}

10.1.2 Exemplo

int n = 11;
int i = 0;
while(i != n) {
cout << i << ' ';
++i;
}

Importante: Uma instrução pode ser composta (bloco de instruções), i.e., uma sequência de instruções envolvida por chavetas.

10.2 A instrução de iteração `for`

A instrução de iteração for serve, normalmente, para repetir um conjunto de instruções um número determinado de vezes.

10.2.1 Sintaxe

for(inicialização; expressão_booleana; progresso)
instrução_controlada

for(inicialização; expressão_booleana; progresso) {
instruções
}

10.2.2 Exemplo

Ciclo para mostrar no ecrã os inteiros de 0 a 9 (inclusive) construído de três formas diferentes.

while:

int i = 0;
while(i != 10) {
cout << i << ' ';
++i;
}
cout << endl;

for:

for(int i = 0; i != 10; ++i)
cout << i << ' ';
cout << endl;

int i = 0;
for(; i != 10; ++i)
cout << i << ' ';
cout << endl;

11 Utilização do depurador `gdb` no editor XEmacs

Para entrar no modo de depuração (ou debug) de programas, seleccione o botão Debug do XEmacs (ou pressione

<ctrl-c
d>

) e indique o nome do ficheiro executável (o nome do executável é o nome do ficheiro sem a extensão .C).

Principais comandos do depurador:

(b)reak main: pára a execução na primeira linha do programa para podermos ver a sua execução linha a linha (para "traçar" o programa). É possível inserir pontos de paragem (breakpoints) noutros locais do programa usando o comando b número_da_linha ou o botão Stop.
(r)un: executa o programa desde o início até ao fim ou até ao primeiro ponto de paragem encontrado.
(n)ext (ou botão Step Over): executa a próxima linha de programa (a que está assinalada).
(s)tep (ou botão Step Into): entra dentro da rotina que está prestes a ser executada.
(c)ontinue: continua a execução do programa até ao fim ou até ao próximo ponto de paragem.
(p)rint nome_de_uma_variável (ou botão p=): mostra o valor actual de uma variável.
(disp)lay nome_de_uma_variável: mostra o valor da variável indicada após cada comando dado ao depurador.
(q)uit : Termina a execução do depurador.