Nome: _______________________________________________

Nº ______________________

Ass. Docente: ________________________________________

Nome: _______________________________________________

Nº ________________

Turma: ____________

Notas:

• Leia atentamente todo o enunciado (incluindo estas notas) antes de começar a prova.
• Esta frequência tem 4 questões.
• Duração: 1:15 (1 hora e 15 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é 6 de Julho de 1999.
• A revisão de provas terá lugar no dia 8 de Julho de 1999, das 10 às 12h.
• Boa sorte.

Questão 1

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 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 A {
    int a;
  public:
    A(int aa) : a(aa) {}
    void g() {
        std::cout << "Execução de A::g(). ";
    }
};

class B : public A {
  public:
    int bx;
    B(int, int);  // Não há construtor por omissão.
    void g() {
        A::g();
        std::cout << "Execução de B::g(). ";
    }
};

inline B::B(int aa, int bb) ...

int main() {
    ...
}

Questão 1.1

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

Questão 1.2

__ B::B(int aa, int bb) : a(aa), bx(bb) {}
__ B::B(int aa, int bb) : A(aa), bx(bb) {}
__ B::B(int aa, int bb) : bx(bb) { A(aa); }

Questão 1.3

B b(1, 2);
A* pa = &b;
pa->g();

__ Execução de A::g(). 
__ Execução de A::g(). Execução de B::g(). 
__ Execução de B::g().

Questão 2

class Tarefa {
  public:

    // Construtor (não há construtor por omissão):
    Tarefa(string descrição, string notas);

    // Destrutor virtual:
    virtual ~Tarefa() {}

    // Acesso à descrição e às notas:
    string descrição() const;
    string notas() const;

    // Devolve duração da tarefa (em dias):
    virtual int duração() const = 0;

    // Devolve custo total da tarefa (em escudos):
    virtual int custo() const = 0;

    // Devolve a mão de obra necessária para a execução da tarefa em cada dia (em operários):
    virtual int mãoDeObra() const = 0;

  private:
    string descrição_;
    string notas_;
};

Questão 2.1

Não é necessário nesta alínea definir qualquer um dos métodos da classe TarefaMecanizada.

 [4 valores]
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Questão 2.2

 [3 valores]
 
 
 
 
 
 

Questão 2.3

 [3 valores]
 
 
 
 

Questão 3

template <typename I>
class Pilha {
  public:
    // Construtor da classe:
    Pilha();
    // Coloca cópia de item no topo da pilha:
    void põe(const I& item);
    // Retira o item que está no topo da pilha:
    void tira();
    // Devolve cópia do item que está no topo da pilha:
    I topo() const;
    // Devolve true sse a pilha estiver vazia:
    bool vazia() const;
    // Devolve o número de itens na pilha:
    int altura() const;
  private:
    ...
};

Escreva um pequeno programa, utilizando o modelo de pilha fornecido, que peça ao utilizador para introduzir um texto e verifique se os seus parênteses estão correctamente balanceados.  Preveja apenas parêntesis de dois tipos: curvos (()) e rectos ([]).  Admita que o texto termina no primeiro ponto final (.) encontrado.   O programa deve ignorar o texto em si: só os parânteses são importantes.  Por exemplo, dadas as seguintes expressões, o programa deve escrever os erros indicados a itálico:

) Aqui ( há ) ( [ gato ] ) .
Fecho sem correspondente abertura.
( Aqui ] também .
Fecho com tipo de parênteses errado.
( Oops .
Parênteses por fechar.
[ este ) ( ] ] ) é ( ) [ ( comprido ) ( ) ] ( (.
Fecho com tipo de parênteses errado.
Fecho com tipo de parênteses errado.
Fecho sem correspondente abertura.
Fecho sem correspondente abertura.
Parênteses por fechar.
Parênteses por fechar.

Utilize o seguinte esqueleto de programa (não precisa de o reproduzir, basta identificar os três troços de programa a escrever: A, B e C):

#include <iostream>

#include "pilha.h"

int main() {
    std::cout << "Introduza um texto terminado por um ponto final."
              << std::endl;

    ... // A preencher.  Troço A.

    char c;
    while(std::cin.get(c) && c != '.')
        if(c == '(' || c == ')' || c == '[' || c == ']') {
           ... // A preencher.  Troço B.
        }

    ... // A preencher.  Troço C.
}

Questão 4

 [2 valores]