Exame de 2ª época

Recibo, Exame 2ª época, 2ºsemestre, 1998/99, Programação II/Programação Orientada por Objectos, ISCTE:

Nome: _______________________________________________

Nº ______________________

Ass. Docente: ________________________________________

Identificação

Nome: _______________________________________________

Nº ________________

Turma: ____________

ISCTE - ETI

Programação II /Programação Orientada por Objectos

Exame 2ª época

1998/1999, 2º semestre

Notas:

Leia atentamente todo o enunciado (incluindo estas notas) antes de começar a prova.
Este exame tem seis (6) questões. É composto por este enunciado e por um anexo.
Duração: 3:30h (três horas e trinta minutos).
A prova deve ser efectuada sem consulta.
Sobre a sua secretária só pode estar o enunciado e uma caneta (coloque pastas, roupa, etc. sobre a cadeira ao seu lado).
Deve responder a todas as questões no próprio enunciado, nos espaços reservados.
Use as páginas em branco no final do enunciado para rascunho.
Não destaque as folhas do enunciado (nem mesmo as de rascunho).
Preencha o seu nome e número no recibo (não o destaque). Este ser-lhe-á entregue, assinado por um docente, depois da prova.
Só um recibo assinado servirá de prova de que entregou a sua resolução.
As cotações encontram-se abaixo de cada alínea (total de 20 valores).
As notas serão afixadas até às 14:00h de segunda-feira dia 13 de Setembro de 1999.
As provas orais terão lugar a partir das 15:00h de quarta-feira dia 15 de Setembro de 1999.
A revisão de provas terá lugar na terça-feira dia 14 de Setembro de 1999 das 9:30 às 11:00h.
Boa sorte.

Questão 1

Assinale com V (Verdadeiro) as expressões que estão correctas e com F (Falso) as que estão incorrectas.

Deve preencher todos os espaços indicados por um sublinhado (___) com V ou F. Qualquer espaço não preenchido será considerado como uma resposta errada.

Em geral as alíneas podem ter zero ou mais respostas correctas. Cada resposta correctamente assinalada vale 0,5 valores.

Nas alíneas em que apenas uma resposta está correcta (estão assinaladas no texto), responder com mais ou menos do que um V anula a cotação, a resposta correcta corresponde à cotação completa. Qualquer outra resposta corresponde a zero valores.

Em todos os casos em que não é explicitamente referida a localização de uma instrução, considere que esta é dada na função main() do programa seguinte:

#include <iostream>
class X {
public:
    X();
    ...
};
class Y {
public:
    virtual void g() const = 0;
};
class A : public Y {
    int a;
    X* px;
public:
    A(int aa) : a(aa), px(0) {
    }
    A(int aa, X* p) : a(aa), px(p) {
    }
    void g() const {
        std::cout << "Execução de A::g(). ";
    }
};
class B : public A {
    int by;
public:
    int bx;
    B(int a, int x, int y = 0) : A(a), by(y), bx(x) {
    }
    B(int a, int x, int y, X* p) : A(a, p), by(y), bx(x) {
    }
    void g() const {
        std::cout << "Execução de B::g(). ";
        A::g();
    }
};
int main() {
    ...
}

Questão 1.1

Quais das seguintes sequências de instruções estão correctas (têm de estar correctas todas as instruções), quer do ponto de vista sintáctico quer do ponto de vista semântico?

__ B* p; p->bx = 1;
__ B p(1, 2); p->bx = 1;
__ B p(1, 2); p.by = 1;
__ B& a; a.bx = 1;

[2 valores]

Questão 1.2

Dadas as seguintes definições:

X* x = new X;
A* a = new A(1);
B b(10, 20);
int* i = new int(11);

quais das seguintes instruções são válidas?

__ B bb(b);
__ B bb(*i, *i, *i, &x);
__ B bb;

[1,5 valores]

Questão 1.3

Depois das seguintes instruções:

A* a = new B(1, 2);
a->g();

o que aparece escrito no écrã (apenas uma resposta está correcta)?

__ Execução de B::g(). Execução de A::g().
__ Execução de B::g().
__ Não aparece nada no ecrã.

[1,5 valores]

Questão 2

Pretende-se desenvolver uma hierarquia de classes representando itens passíveis de serem guardados numa biblioteca. No topo da hierarquia está uma classe abstracta ItemDeBiblioteca definida da seguinte forma :

class ItemDeBiblioteca {
public:
    ItemDeBiblioteca(const std::string& título) : título_(título) {
    }
    virtual ~ItemDeBiblioteca() {
    }
    // Função membro que devolve true caso o item de biblioteca aborde o assunto passado como
    // argumento e false no caso contrário.
    virtual bool aborda(const std::string& assunto) const = 0;
    std::string título() const {
        return título_;
    }
private:
    std::string título_;
};

Questão 2.1

Defina uma classe Artigo que contém o nome do autor, o título do artigo e o assunto que aborda (tudo std::string). Admite-se que cada artigo aborda apenas um assunto. Devem existir funções que permitem consultar o nome do autor, o título e o assunto do artigo. Devem ainda existir os construtores adequados à classe (inclua um construtor por omissão). Note que um artigo não é um item de biblioteca!

Não é necessário implementar qualquer um dos métodos nesta alínea.

[1 valor]

Questão 2.2

Defina uma classe concreta Revista, que é um item de biblioteca, e que contenha o nome da empresa editora (uma std::string) e uma lista dos artigos que a compõem (pode usar a classe-modelo Lista dada em anexo para implementar esta lista). Devem existir, para além das funções e procedimentos comuns a todos os itens de biblioteca:

Uma função membro para consultar a editora.
Um procedimento membro para acrescentar um artigo à revista.
O(s) construtor(es) adequado(s) à classe.

Não é necessário implementar qualquer um dos métodos nesta alínea.

[2 valores]

Questão 2.3

Defina o(s) contrutor(es) da classe Revista.

[0,5 valores]

Questão 2.4

Preencha a função membro abaixo de modo a que esta devolva true caso o assunto dado como argumento seja abordado em algum dos artigos que constam da revista e false no caso contrário.

bool Revista::aborda(const std::string& assunto) const {

}

[2 valores]

Questão 3

Preencha o procedimento abaixo, cujos argumentos são uma matriz de inteiros m e um inteiro n que indica o tamanho dessa mesma matriz, de modo a que este procedimento passe todos os elementos da matriz para a posição seguinte à que ocupavam originalmente, passando o último elemento para a primeira posição.

void rodaÀDireita(int m[], int n) {

}

[1 valor]

Questão 4

Preencha o procedimento abaixo de modo a que este ordene uma matriz m contendo n inteiros usando o algoritmo de selecção. Relembra-se que o algoritmo de ordenação por selecção (selection sort) consiste essencialmente em ir seleccionando sucessivamente os elementos mais pequenos até a matriz estar ordenada (em cada passo do algoritmo há uma parte da matriz ordenada, e que contém os elementos mais pequenos da matriz, e outra em que os elementos estão por ordenar).

void ordenaPorSelecção(int m[], int n) {

}

[2 valores]

Questão 5.1

Pretende-se criar um conjunto de modelos de classes (ou estruturas), funções e procedimentos que implementem listas duplamente ligadas circulares. Uma lista duplamente ligada circular possui um conjunto de nós duplamente ligados em que o nó seguinte do último nó da lista é o primeiro nó da lista e o nó anterior do primeiro nó da lista é o último nó da lista.

Defina um modelo de estrutura chamada Nó que represente um nó de uma lista duplamente ligada circular que pode guardar um item de tipo parametrizável (inclua um construtor).

[0,5 valores]

Questão 5.2

Preencha o procedimento-modelo abaixo de modo a que este insira um novo item i na lista duplamente ligada cujo primeiro nó é apontado por primeiro (que é igual a 0 [zero] caso a lista esteja vazia). Tenha atenção ao caso particular de a lista estar vazia!

template <typename I>
void põeNoInício(Nó<I>*& primeiro, const I& i) {

}

[1,5 valores]

Questão 5.3

Preencha o procedimento-modelo abaixo de modo a que este remova o nó apontado por nó da lista duplamente ligada cujo primeiro nó é apontado por primeiro (garante-se que a lista não está vazia e que o nó a remover está de facto na lista). Tenha atenção aos casos particulares (lista com um único nó e nó a remover é o primeiro).

template <typename I>
void remove(Nó<I>*& primeiro, Nó<I>* nó) {

}

[2 valores]

Questão 5.4

Preencha o procedimento-modelo abaixo de modo a que este passe todos os nós da lista duplamente ligada cujo primeiro nó é apontado por primeiro para a posição seguinte à que ocupam, passando o último para a primeira posição (não tem qualquer efeito se a lista tiver menos de dois nós).

template <typename I>
void rodaÀDireita(Nó<I>*& primeiro) {

}

[1,5 valores]

Questão 6

Explique sucintamente as vantagens e desvantagens da utilização de listas ligadas por oposição à utilização de matrizes para a implementação do conceito de lista.

[1 valor]