2  Conceitos básicos de programação em C++

2.1  Estrutura básica dum programa em C++

// As duas linhas seguintes são necessárias para permitir a 
// apresentação de variáveis no ecrã e a inserção de valores
// através do teclado (usando os canais [ou streams] cin e cout):
#include <iostream>
using namespace std;

// A linha seguinte indica o ponto onde o nosso programa vai
// começar a ser executado. Indica também que o programa não
// usa argumentos e que o valor por ele devolvido ao sistema
// operativo é um inteiro (estes assuntos serão vistos em
// pormenor mais tarde):
int main()
{   // esta chaveta assinala o início do programa.

    // Aqui aparecem as instruções que compõem o programa.

}   // esta chaveta assinala o fim do programa.

2.2  Variáveis

2.2.1  Memória e inicialização

Os tipos não passam duma abstração.  Tudo o que representamos na memória do computador corresponde a padrões de bits, os famosos "zeros e uns".  O tipo duma variável indica simplesmente como um dado padrão de bits deve ser interpretado.

Cada variável tem duas características: um nome e um tipo.  Antes de usar uma variável é necessário indicar ao compilador qual o seu nome e tipo, de modo a que a variável possa ser criada, i.e., ficar associada a uma posição de memória (ou várias posições de memória).  Uma instrução onde se pede para criar uma variável com um dado nome e dum determinado tipo denomina-se definição.  A instrução:

int a;

Uma forma intuitiva de var uma variável é imaginá-la como uma folha de papel com um nome associado e onde se decidiu escrever apenas números inteiros, por exemplo.  Outra restrição é que a folha de papel pode conter apenas um valor em cada instante, pelo que a escrita dum novo valor implica o apagamento do anterior.

Quando uma variável é definida, o computador reserva para ela na memória o número de bits necessário para guardar um valor do tipo referido (essas reservas são feitas em múltiplos de uma unidade básica de memória, tipicamente com oito bits, ou seja, um byte).  Essa posição de memória contém um padrão de bits arbitrário.  Para evitar esta arbitrariedade, que pode ter consequências nefastas num programa se não se tiver cuidado, ao definir uma variável pode (e deve-se sempre que possível e razoável) atribuir-se-lhe um valor inicial.  A atribuição de um valor a uma variável que acabou de ser definida é chamada a inicialização.  Esta operação pode ser feita de várias maneiras:

int a = 256;  // definição de uma variável 'a' do tipo int com valor
              // inicial 256.
int a(256);   // idem.
int a;        // estas duas instruções sucessivas têm o mesmo efeito das
a = 256;      // anteriores.

int a, b, c;

2.2.2  Nomes de variáveis

Os nomes das variáveis devem ser tão auto-explicativos quanto possível.  Se uma variável guarda, por exemplo, o número de alunos numa turma, deve chamar-se número_de_alunos_na_turma ou então número_de_alunos, se o complemento "na turma" for óbvio pelo contexto do programa.

2.2.3  Tipos básicos do C++

Nas tabelas seguintes são apresentados os tipos básicos existentes no C++ e a gama de valores que podem representar no Visual C++.  É muito importante notar que os computadores são máquinas finitas: tudo é limitado, desde a memória à representação dos tipos em memória.  Assim, a gama de diferentes valores possíveis de guardar em variáveis de qualquer tipo é limitada.

A gama de valores representável para cada tipo de dados pode variar com o processador e o sistema operativo.  Por exemplo, no sistema operativo Linux em processadores Alpha, os long int (segunda tabela) têm 64 bits.  Em geral não se pode afirmar muito mais do que: a gama dos long é sempre suficiente para abarcar qualquer int e a gama dos int é sempre suficiente para abarcar qualquer short, o mesmo acontecendo com os long double relativamente aos double e com os double relativamente aos float.
 

O qualificador signed também pode ser usado, mas signed int e int são sinónimos.  O único caso em que este qualificador faz diferença é na construção signed char, mas apenas em máquinas onde os char não têm sinal.

A representação interna dos vários tipos pode ser ou não relevante para os programas.  A maior parte das vezes não é relevante, excepto quanto ao facto de que devemos sempre estar cientes das limitações de qualquer tipo.  Por vezes, no entanto, a representação é muito relevante, nomeadamente quando programando ao nível do sistema operativo, que muitas vezes tem de aceder a bits individuais.  Assim, apresentam-se em seguida algumas noções sobre a representação usual dos tipos básicos do C++.  Esta matéria será, a seu tempo, tratada pormenorizadamente em Arquitectura de Computadores.

Tipos aritméticos

Representação de inteiros

Suponha-se agora que se soma 1 ao número representado por:
 

1

1

1

1

O resultado é (1111 + 1)₂ = (10000)₂.  Mas este valor não é representável num unsigned int de quatro bits!  O que acontece tipicamente num caso destes é que são guardados apenas os 4 bits menos significativos do resultado, pelo que, no computador hipotético, (1111 + 1)₂ = (0000)₂.  Ou seja, nesta aritmética binária com um número limitado de dígitos, tudo funciona como se os valores possíveis estivessem organizados em torno de um relógio, neste caso em torno de um relógio com 16 horas, onde após as (1111)₂ = 15 horas são de novo (0000)₂ = 0 horas *.

A extensão destas ideias para, por exemplo, 32 bits é trivial: nesse caso o (grande) relógio teria 2³² horas, de 0 a 2³² - 1, que é, de facto, a gama dos unsigned int no Visual C++.

Falta verificar como representar inteiros com sinal, i.e., incluindo não só valores positivos mas também valores negativos.  Suponha-se que os int têm, de novo num computador hipotético, apenas 4 bits.  Admita-se uma representação semelhante à dos unsigned int, mas diga-se que, no lugar das 15 horas (padrão de bits 1111), mesmo antes de chegar de novo a 0, o valor representado é x.  Pelo que se disse anteriormente, somar 1 a x corresponde a rodar o ponteiro das 15 para as 0 horas (padrão 0000).  Admitindo que o padrão 0000 representa de facto o valor 0, tem-se x + 1 = 0, donde se conclui ser o padrão 1111 um bom candidato para representar -1!  Estendendo o argumento anterior, pode-se dizer que as 14 horas correspondem à representação de -2, e assim sucessivamente.  Assim,
 

O "salto" nos valores no relógio deixa de ocorrer do padrão 1111 para o padrão 0000 (15 para 0 horas, se interpretados como inteiros sem sinal), para passar a ocorrer na passagem do padrão 0111 para o padrão 1000 (das 7 para as -8 horas, se interpretados como inteiros com sinal).  A escolha deste local para a transição não foi arbitrária.  Em primeiro lugar permite representar um número semelhante de valores positivos e negativos: 7 positivos e 8 negativos.  Deslocando a transição de uma hora no sentido dos ponteiros do relógio, poder-se-ia alternativamente representar 8 positivos e 7 negativos.  A razão para a escolha representada na tabela acima prende-se com o facto de que, dessa forma, a distinção entre não negativos (positivos ou zero) e negativos se pode fazer olhando apenas para o bit mais significativo (o bit mais à esquerda), que quando é 1 indica que o valor representado é negativo.  A esse bit chama-se, por isso, bit de sinal.  Esta representação chama-se representação em complemento para 2.  Em Arquitectura de Computadores as vantagens desta representação para simplificação do hardware do computador ficarão muito claras.

Como saber, olhando para o padrão de bits, qual o valor representado?  Primeiro olha-se para o bit de sinal.  Se for 0, interpreta-se o padrão de bits como um número binário: é esse o valor representado.  Se o bit de sinal for 1, então o valor representado é igual ao valor binário correspondente ao padrão de bits subtraído de 16.  Por exemplo, observando o padrão 1011, conclui-se que representa o valor negativo (1011)₂ - 16 = -5, como se pode confirmar na tabela acima.

A extensão destas ideias para o caso dos int com 32 bits é muito simples.  Nesse caso os valores representados variam de -2³¹ a 2³¹ - 1 e a interpretação dos valores representados faz-se como indicado no parágrafo acima, só que subtraíndo 2³² no caso dos valores negativos.  Por exemplo, os padrões 00000000000000000000010000000001 e 10000000000000000000000000000111 representam os valores 1025 e -2147483641, como se pode verificar facilmente com uma máquina de calcular.

* De acordo, tipicamente no topo do relógio estaria 16, e não zero, mas optaremos pela numeração de 0 a 15.

Representação de valores de vírgula flutuante

A representação em vírgula fixa impõe limitações consideráveis na gama de valores representáveis: no caso dos 32 bits com vírgula 16 posições para a esquerda, representam-se valores (em módulo) apenas entre aproximadamente 10^-5 e 10⁵.  Na prática este problema resolve-se usando uma representação em que a vírgula não está fixa, mas varia consoante as necessidades: a vírgula flutuante.  Uma vez que especificar a posição da vírgula é o mesmo que especificar uma potência de dois pela qual o valor deve ser multiplicado, a representação de vírgula flutuante corresponde a especificar um número da forma m 2^e, em que a m se chama mantissa e a e expoente.  Aliás, na prática os valores são especificados na forma s m 2^e, em que m é sempre não negativo e s é o sinal, valendo ou -1 ou 1.  A representação prática de valores de vírgula flutuante passa pois por dividir o padrão de bits disponível em três zonas, com representações diferentes: o sinal, a mantissa e o expoente.  Como parte dos bits têm de ser transferidos para o expoente, o que se ganha na gama de valores representáveis perde-se na precisão dos valores.  Por exemplo, na maior parte dos processadores utilizados hoje em dia usa-se uma das representações especificadas na norma IEEE 754 [2], que, no caso de valores de representados em 32 bits (i.e., de precisão simples),

1. atribui 1 bit (s₀) ao sinal (0 significa positivo e 1 negativo),
2. atribui 23 bits (m₂₂...m₀) à mantissa, que são interpretados como um valor de vírgula fixa sem sinal com vírgula deslocada de 23 posições para a esquerda, e
3. atribui 8 bits (e₇...e₀) ao expoente, que são interpretados como um inteiro entre 0 e 255 a que se subtrai 127 (os valores 0 e 255 são especiais, pelo que o expoente varia entre -126 e 127);

É fácil verificar que o menor valor normalizado (em módulo) representável é 1 x 2^-126 = (aproximadamente) 1,17549435 x 10^-38 e o maior é (2²⁴ - 1) x 2^-23 x 2¹²⁷ = (aproximadamente) 3,40282347 x 10⁺³⁸ (conferir com a tabela das gamas dos tipos básicos do C++, tipo float).  Com esta representação conseguem-se cerca de seis dígitos decimais de precisão.

A representação de valores de vírgula flutuante e pormenores de implementação de operações com essas representações serão estudados com maior pormenor em Arquitectura de Computadores.

No que diz respeito à programação, a utilização de valores de vírgula flutuante deve ser evitada sempre que possível: se for possível usar inteiros nos cálculos, é sempre preferível usá-los a recorrer aos tipos de vírgula flutuante, que, apesar da sua aparência inocente, reservam muitas surpresas: os valores são representados com precisão finita, o que implica arredondamentos e acumulações de erros.  Outra fonte comum de erros prende-se com a conversão de valores na base decimal para os formatos de vírgula flutuante em base binária: valores inocentes como 0.4 não são representáveis exactamente (experimente escrevê-lo em base 2)!  A forma de lidar com estes tipos de erros sem surpresas é estudada pela disciplina de análise numérica [3].

* A representação diz-se normalizada se o seu bit mais significativo for 1.  A versão normalizada dos valores em formato IEEE 754 tem sempre o bit mais significativo, que é implícito, a 1.  Os valores não normalizados têm, naturalmente, menor precisão (dígitos significativos) que os normalizados.

Booleanos ou lógicos

Caracteres

Os char são tipicamente representados usando 8 bits, pelo que existem 256 diferentes caracteres representáveis.  Existem várias tabelas de codificação de caracteres diferentes.  De longe a mais comum é a tabela dos códigos ASCII.  A tabela de codificação usada no Windows NT usa uma extensão do ASCII que permite usar caracteres acentuados.  Existem muitas dessas extensões, que podem ser usadas de acordo com o país em que se está.  Essas extensões são possíveis porque os códigos ASCII usam apenas os 7 bits menos significativos dum caracter (i.e., apenas 128 das possíveis combinações de zeros e uns).

Não é necessário, em C++, saber os códigos dos caracteres.  Assim, para referir o código do caractere 'b' usa-se 'b', que tem o mesmo significado que 98 (em ASCII).  O que de facto é armazenado numa variável do tipo char quando lhe é atribuido o valor 'b' é a representação binária do número 98.  É possível tratar um char como um pequeno número inteiro.  Por exemplo, se se executar o conjunto de instruções seguinte:

char caractere = 'a';
caractere = caractere + 1;
cout << "O caracter seguinte é: " << caractere;

O caracter seguinte é: b

O programa seguinte imprime no ecrã todos os caracteres do código ASCII (que só especifica os caracteres correspondentes aos códigos de 0 a 127, isto é, todos os valores positivos dos char em Windows NT *:

#include <iostream>
using namespace std;

int main(void)
{
    for(int i = 0; i < 128; i++) {
        cout << "'" << char(i) << "' (" << i << ")" << endl;
    }
}

2.2.4  Inicialização de variáveis

Existem algumas classes de variáveis (ver secção sobre Permanência de variáveis) que são inicializadas implicitamente com zero.  Evite fazer uso dessa característica do C++: inicialize-as sempre explicitamente.

2.3  Valores literais

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

0x1U   // o mesmo que 1U.
0x10FU // o mesmo que 271U, ou seja (00000000000000000000000100001111)₂.
077U   // o mesmo que 63U, ou seja (00000000000000000000000000111111)₂.

2.4  Constantes

const int primeiro_primo = 2;
const char primeira_letra_do_alfabeto_latino = 'a';

2.5  Expressões e operadores

; // expressão nula
2;
1 + 2 * 3;

int i;

i = 2;
i = 1 + 2 * 3;

a = b + 3;

Outro exemplo:

int i, j;
bool i_é_igual_a_j;
...
i_é_igual_a_j = i == j;

2.5.1  Operadores aritméticos

O significado do operador divisão depende do tipo dos operandos usados.  Por exemplo, o resultado de 10/20 é 0 (zero), e não 0,5.  Do mesmo modo, não faz sentido usar o operador % com operandos de vírgula flutuante, sendo esse operador reservado para operandos inteiros.

Os operadores de divisão e resto da divisão inteira estão especificados de tal forma que, se a e b forem valores inteiros, então a é igual a (a / b) * b + a % b.

As operações aritméticas preservam os tipos dos operandos, i.e., a soma de dois float resulta num valor do tipo float, etc.  Mais tarde se verá que é possível que os operandos sejam de tipos aritméticos diferentes, sendo feitas conversões automáticas.

2.5.2  Operadores relacionais e de igualdade

2.5.3  Operadores lógicos

a > 5           // verdadeira se a maior que 5.
a < 5 && b <= 7 // verdadeira se a menor que 5 e b menor ou igual a 7.
a < 5 || b <= 7 // verdadeira se a menor que 5 ou b menor ou igual a 7.

2.5.4  Operadores bit-a-bit

123U & 0xFU == 11U == 0xBU

Os deslocamentos simplesmente deslocam o padrão de bits correspondente ao primeiro operando de tantas posições quanto o valor do segundo operando, inserindo zeros (0) à direita quando o deslocamento é para a esquerda e à esquerda quando o deslocamento é para a direita.  Por exemplo:

1U << 4 == 16U
20U >> 3 == 1U

(Os exemplos assumem que os int têm 32 bits.)

2.5.5  Operadores de atribuição

a = 3 + 5; // a toma o valor 8

A atribuição é uma operação, pelo que deve ter um valor: o valor de uma atribuição é o valor que ficou guardado na variável do lado esquerdo da atribuição.  Estes facto, conjugado com a associatividade à direita deste tipo de operadores, permite escrever

a = b = c = 1;

Existem muitos outros operadores de atribuição em C++, que são formas abreviadas de escrever expressões muito comuns.  Assim, i += 1 tem (quase) o mesmo significado que i = i + 1.  Por exemplo:

i = i + n;  i += n;
i = i - n;  i -= n;
i = i * n;  i *= n;
i = i % n;  i %= n;
i = i / n;  i /= n;

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

i += 1; // ou
i++;    // ou 
++i;

int i = 0;
int j = i++;
cout << i << ' ' << j << endl;

int i = 0;
int j = ++i;
cout << i << ' ' << j << endl;

As mesmas observações aplicam-se às duas versões do operador --.

2.5.7  Precedência, associatividade e ordem de cálculo.

Para alterar a precedência dos operadores numa expressão podem-se usar parênteses.  Por exemplo: x = (y + z) * w.  Podem-se usar os parênteses também para alterar o agrupamento de operações com a mesma precedência.  Por exemplo, x * y / z significa (x * y) / z, pois os dois operadores têm a mesma precedência e associam-se da esquerda para a direita.  Se o objectivo fosse calcular primeiro a divisão, então dever-se-ia escrever x * (y / z).  Note-se que o resultado, se os operandos forem inteiros, é quase sempre diferente: 4 * 5 / 6 resulta em 3 e 4 * (5 / 6) resulta em 0!  E o mesmo se passa com valores de vírgula flutuante, por pouco intuitivo que isso seja.  Por exemplo, o seguinte troço de programa

cout << setprecision(20); // para os resultados serem mostrados com 20 dígitos
cout << 0.3f * 0.7f / 0.001f << ' ' << 0.3f * (0.7f / 0.001f) << endl;

210 209.9999847412109375

Ordem de cálculo e efeitos laterais

x = y = z = 1;  // sem efeitos laterais: atribuições sucessivas.
x = y + (y = z = 1); // com efeitos laterais.
if(x == 0) ....  // sem efeitos laterais: não altera qualquer variável.
if(x++ == 0) .... // com efeitos laterais.
while(cin >> x) .... // com efeitos laterais.

y = sin(x) + cos(x) + sqrt(x)

int i = 0;
int j = i + i++;

Este tipo de comportamento deve-se, fundamentalmente, a que, em C++, as atribuições são operações com um valor, e não instruções especiais, como em Pascal *.  Este tipo de operações, no entanto, fazem parte do estilo usual de programação em C e C++, pelo que devem ser bem percebidas as suas consequências: uma expressão com efeitos laterais não pode ser interpretada como uma simples expressão matemática, pois há variáveis que mudam de valor!  Expressões com efeitos laterais, são pois de evitar, salvo em "expressões idiomáticas" da linguagem C++.

* No entanto, mesmo o Pascal não está livre deste tipo de problemas, pois funções com argumentos passados por referência (var) podem alterar argumentos envolvidos na mesma expressão que envolve a sua chamada.

2.5.8  Exercícios

Insira dois numeros inteiros: 3 5
Atribuí a m o valor 3
Atribuí a n o valor 5
O resultado de m-- é: 2
O resultado de n++ é: 6
O resultado de n += m é: 8
...
O resultado de n > m é: false
O resultado de n <= m é: true

2.6  Canais: leitura do teclado e escrita no ecrã

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

cin >> a;

Quando é feita a leitura de um caracter do teclado (através de cin) o que é lido é apenas um caractere, mesmo que no teclado seja inserido um código (ou mais do que um caractere), i.e., o resultado das seguintes operações:

cout << "Insira um caractere: "; 
char caractere;
cin >> caractere;
cout << "O caracter inserido é : " << caractere;

Insira um caractere: 48 
O caracter inserido é: 4

A utilização de canais de entrada e saída, associados ao teclado e ao ecrã, mas também a ficheiros arbitrários no disco, serão discutidos em pormenor mais tarde.

2.7  Exercícios

// Este programa lê dois números inteiros do teclado,
// multiplica-os, e escreve o resultado no ecrã.
#include <iostream>
using namespace std;

int main()
{
    cout << "Introduza dois números inteiros: " << endl;
    int primeiro_número, segundo_número;
    cin >> primeiro_número >> segundo_número;

    int resultado = primeiro_número * segundo_número;

    cout << "O resultado da multiplicação dos dois numeros é "
         << resultado << endl; 
}

1. A utilização de caracteres acentuados é válida, de acordo com a norma do C++.  Mas o Visual C++ não os aceita senão em comentários e entre "".
2. Podem haver algumas surpresas com os caracteres acentuados colocados entre "" quando eles são escritos no ecrã (em Windows NT + Visual C++).
3. Logo, a sua utilização pode não ser recomendável.

2.  Desenvolva um pequeno programa que escreva no ecrã a frase "Olá mundo!".

3.a)  Escreva um programa que peça ao utilizador para inserir dois números inteiros e os some.  Depois de terminar o programa, o seu ecrã deve ter o seguinte aspecto:

Insira dois números :
12
234
A soma dos dois números inseridos é: 256

3.c)  Altere o seu programa para fazer a leitura de cinco números e somá-los.

3.d)  Se usou mais do que duas variáveis para fazer a alínea anterior, re-escreva o seu programa usando apenas duas variáveis. Uma delas deve guardar o valor lido, enquanto a outra deve guardar o valor acumulado da soma dos números inseridos até ao momento.  Faça o traçado deste programa vizualizando a evolução de ambas as variáveis.

4.a)  Escreva um programa que, dado um caracter, escreva no ecrã o seu número de ordem no alfabeto (assuma código ASCII).  Exemplo:

Por favor introduza um caracter:
a
A ordem do caracter 'a' é: 1

Por favor introduza um caracter:
c
A ordem do caracter 'c' é: 3

5.a)  Use o seu programa de soma (a versão feita para inteiros, na alínea 3.a)) para tentar somar os números 2147483647 e 2.  Faça um traçado do programa e tente perceber porque não funciona.

5.b)  Experimente "corrigir" o programa mencionado na alínea anterior usando variáveis do tipo float.  Funcionou?  Porquê?

6.  Corrija o seguinte programa:

#include <iostream>

using namespace std

int main(void)
{
    inteiro p1 p2 divisao,

    cout >> "Introduza dois numeros: << endl;
    cin >> primeiro_numero >> segundo_numero;
    primeiro_numero \ segundo_numero = divisao;
    cout << O Resultado e >> divisao ; 
}

****** 
**  **
**  **
******

2.8  Referências

[2]  Irv Englander, "The Architecture of Computer Hardware and Systems Software: An Information Technology Approach", John Wiley & Sons, Inc., Nova Iorque, 1996. *

[3] Samuel D. Conte and Carl de Boor, "Elementary Numerical Analysis", McGraw-Hill International Book Company, Auckland, 1983.

* Existe na biblioteca do ISCTE.