Aula 9

1 Resumo da matéria

1.1 Modelos ou templates

A completar.

1.2 Leitura recomendada

Recomenda-se a leitura do Capítulo 6 de [1].

2 Exercícios

1.a) Escreva um procedimento troca() que troque os valores de dois inteiros passados como argumento. Por exemplo:

#include <iostream>
// definição de troca...
int main() {
    int i = 1, j = 2;
    troca(i, j);
    std::cout << j << ' ' << i << std::endl;
}

deve resultar em

2 1

Teste o procedimento usando o programa acima.

1.b) Sobrecarrege o procedimento com uma versão para float e outra para string. Teste-as acrescentando código apropriado à função main().

1.c) Converta as três versões do procedimento por um único modelo (ou template) de procedimento. Teste-o compilando e executando o programa sem alterar a função main(). Depois experimente parametrizar explicitamente o modelo durante a invocação (i.e., troca<int>(i, j) em vez de troca(i, j)). Que forma prefere? Será sempre possível?

1.d) A implementação do modelo de procedimento troca<>() que desenvolveu provavelmente faz uso de uma variável auxiliar. Reescreva-o, se for necessário, de modo a que a definição da variável auxiliar seja separada da atribuição do seu valor *:

T aux;
aux = ...;

Crie uma classe C que guarde um valor inteiro, não possua construtor por omissão, e se possa escrever num canal de saída. Por exemplo:

class C {
public:
    int i;
    C(int ii) : i(ii) {
    }
};
std::ostream& operator << (std::ostream& saida, C c) {
    return saida << c.i;
}

Acrescente à função main() um teste do modelo troca<>(). Experimente compilar. Porque ocorreu o erro? Interprete-o e conclua acerca das restrições impostas pelo modelo implicitamente ao tipo do seu parâmetro.

* Isto não segnifica que se recomende fazê-lo, pelo contrário! As variáveis devem ser inicializadas logo que possível com valores significativos!

2.a) Transforme a classe FilaInt, desenvolvida na Aula 11 do 1º semestre numa classe modelo Fila em que o tipo dos itens guardados na fila é parametrizável. Isto permitir-lhe-á usar filas em que o tipo dos elementos é especificado passando um argumento ao modelo. Por exemplo:

#include <iostream>
// Modelo de classe fila:
int main() {
    Fila<double> f;
    f.poe(1.1);
    f.poe(2.2);
    std::cout << f.frente() << endl;
    f.tira();
    std::cout << f.frente() << endl;
    f.tira();
}

onde frente() é uma função membro que devolve o item à frente da fila, deve resultar em:

1.1
2.2

Teste o modelo com o programa acima.

2.b) Altere o modelo de modo a que o número limite de itens nas filas seja parametrizável. Isso deve permitir escrever o seguinte programa:

int main() {
    Fila<double, 10> f; // pilha com máximo de 10 itens float.
    f.poe(1.1);
    f.poe(2.2);
    std::cout << f.frente() << endl;
    f.tira();
    std::cout << f.frente() << endl;
    f.tira();
}

2.c) Altere o modelo de modo a que o número limite de itens tenha, por omissão, o valor de 100. Isso deve permitir escrever o seguinte programa:

int main() {
    Fila<double> f; // pilha com máximo de 100 itens float.
    f.poe(1.1);
    f.poe(2.2);
    std::cout << f.frente() << endl;
    f.tira();
    std::cout << f.frente() << endl;
    f.tira();
}

3 Referências

[1] Michael Main e Walter Savitch, "Data Structures and Other Objects Using C++", Addison-Wesley, Reading Massachusetts, 1997. #

# Existem 10 exemplares na biblioteca do ISCTE.