PARA A RESOLUÇÃO DO EXAME, ACOSELHA-SE QUE LEIA ATETAMETE O SEGUITE:
ORMAS:
1) O exame tem a duração de 150 minutos. 2) O exame é feito SEM COSULTA.
3) Deve assinalar todas as opções tomadas: no código dos seus programas, todas as constantes, variáveis, procedimentos ou funções devem ser devidamente explicadas através de comentário.
4) As respostas, que embora, sintáctica e semanticamente correctas, se apresentem pouco estruturadas serão severamente penalizadas, ou não consideradas.
5) As respostas de conteúdo inadequado não serão consideradas. 6) As respostas sem justificação serão fortemente penalizadas. IFORMAÇÕES:
1) Antes de começar a responder, leia todo o enunciado. Verifique se o exemplar está completo, isto é, se tem 7 páginas numeradas e termina com a palavra - FIM -. 2) No caso de o exemplar que lhe foi distribuído estar incompleto, ou tiver qualquer
falha, dirija-se ao professor vigilante, a fim de resolver o problema.
3) Qualquer aspecto que considere menos claro deverá ser explicado em comentário no código. A clareza da sua solução, o seu rigor científico e legibilidade constituem critérios de avaliação de máxima importância.
4) O exame é constituído por quatro questões a primeira com quatro alíneas, a segunda com duas alíneas, a terceira questão com duas alíneas e a quarta questão com uma alínea.
5) Em caso de dúvida ou omissão resultante do enunciado de exame, a sua interpretação, quando devidamente explicada e enquadrada nos objectivos de avaliação da questão em causa, será considerada na avaliação da sua resposta. Bom Trabalho!
1º Problema (6 Valores)
Considere a classe Carro a seguir definida: class Carro {
private:
std::string marca; // Marca do carro std::string modelo; // Modelo do carro int ano_fabrico; //Ano de fabrico std::string matricula; // matrícula do carro
float consumo; // consumo nominal do carro aos 100 Km int kilometros; // número de km percorridos
float gasolina; // número de litros no depósito de gasolina
public:
Carro (std::string amarca, std::string omodelo, int ano, float consumoNominal); virtual ~Carro();
virtual std::string Marca() const; virtual std::string Modelo() const; virtual int AnoFabrico() const; virtual int Kilometros() const; virtual std::string Matricula() const; virtual void Conduziu(int x); virtual void MeterGasolina(int x); virtual int KilometrosDisponiveis();
virtual void DefineMatricula(std::string matr); };
a) Implemente o construtor da classe, sabendo que ao adquirir o carro ele possui 0 Km, e vem com o depósito de gasolina vazio. A matrícula vem em branco sendo definida pelo modificador.
Espaço de resposta à questão 1a)
Carro::Carro(std::string amarca, std::string omodelo, int ano, float consumoNominal):
marca(amarca), modelo(omodelo),
b) Defina os seguintes selectores desta classe virtual std::string Marca() const;
virtual std::string Modelo() const; virtual int AnoFabrico() const; virtual int Kilometros() const; virtual std::string Matricula() const;
Espaço de resposta à questão 1b)
int Carro::AnoFabrico() const {
return ano_fabrico; };
std::string Carro::Marca() const {
return marca; };
std::string Carro::Modelo() const {
return modelo; };
std::string Carro::Matricula() const {
return matricula; };
int Carro::Kilometros() const {
return kilometros; };
c) Defina os modificadores:
virtual void Conduziu(int x); // Regista que o veículo percorreu x quilómetros, a adicionar aos que já percorreu. virtual void MeterGasolina(int x); // Representa a operação de meter x litros de combustível.
virtual void DefineMatricula(std::string matr); // Define a matrícula matr para o carro.
Espaço de resposta à questão 1c)
void Carro::Conduziu(int x) { kilometros+=x; gasolina-=consumo*x/100; }; void Carro::MeterGasolina(int x) { gasolina+=x; };
void Carro::DefineMatricula(std::string matr) {
matricula=matr; };
d) Defina o método:
virtual int KilometrosDisponiveis(); /* Devolve o número de quilómetros que o carro ainda pode percorrer com o combustível que tem no depósito, presumindo que o consumo é igual ao consumo médio */
Espaço de resposta à questão 1d)
int Carro::KilometrosDisponiveis() {
return (int)(gasolina/consumo*100); };
2º Problema (7 Valores)
Implemente em C++ uma classe Frota, para representar uma frota de carros (por exemplo pertencente a uma companhia ou a um milionário) usando um vector não polimórfico de objectos do tipo Car (veja a questão anterior). A capacidade deste vector é fixa e dada na construção. Inclua operações para acrescentar um carro, para obter o índice de um carro, dada a matrícula (ou -1 se não houver), para abater um carro dada a matrícula, e para indicar a utilização de todos os carros (em que a utilização se mede pelo produto do sucessor da idade do carro pela raiz quadrada do número inteiro de milhares de quilómetros: por exemplo, no ano 2000, a utilização de um carro de 1998 com 25000 quilómetro tem o valor 15.0). A operação de acrescentar o carro não tem efeito se já houver um carro com a matrícula indicada, e a de abater não tem efeito se não houver nenhum carro com a matrícula indicada.
a) Implemente a declaração da classe Espaço de resposta à questão 2a) class Frota { private: Car* items; int capacity; int count; public: Frota(int capacity); ~Frota();
virtual void AcrescentarCarro(const Car& c); virtual int IndiceCarro(std::string matr) const; virtual void AbaterCarro(std::string matr);
virtual void IndicarUtilizacao() const; }; b) Implemente os métodos: • AcrescentarCarro • IndiceCarro • AbaterCarro • IndicarUtilizacao Espaço de resposta à questão 2b)
void Frota::AcrescentarCarro(const Car& c) {
for(int counter=0; counter<count; counter++) if(items[counter].Matricula()==c.Matricula()) return; items[count]=c; if (count<capacity) count++; };
int Frota::IndiceCarro(std::string matr) const { for(int counter=0;counter<count;counter++) if(items[counter].Matricula()==matr) return counter; return -1; };
void Frota::AbaterCarro(std::string matr) {
int index= IndiceCarro(matr); if (index==-1) return;
for (int counter=index; counter<count; counter++) items[counter]=items[counter+1];
count--; };
void Frota::IndicarUtilizacao() const {
float util;
for (int counter=0;counter<count;counter++) {
util=2008-items[counter].AnoFabrico()+1/ ::sqrt(items[counter].Kilometros()/1000); std::cout << util << std::endl;
} };
3º Problema (4 Valores)
Considere a classe CarroHibrido derivada de Carro a seguir definida: class CarroHibrido: public Carro
{ private:
float consumoComb; //Consumo combinado do motor a gasolina e da bateria public:
CarroHibrido();
CarroHibrido(std::string amarca, std::string omodelo, int ano,float conscomb); virtual ~CarroHibrido();
virtual float ConsumoComb() const; //Consumo combinado
virtual int KilometrosDisponiveis(); //Kms disponíveis cm a gasolina existente no depósito };
a) Implemente o construtor com parâmetros, e o selector. CarroHibrido(std::string amarca, std::string omodelo, int ano,float conscomb); virtual float ConsumoComb() const;
Espaço de resposta à questão 3a)
CarroHibrido::CarroHibrido(std::string amarca, std::string omodelo, int ano, float conscomb): Carro(amarca,omodelo,ano,0),
consumoComb(conscomb) {}
float CarroHibrido::ConsumoComb() const {
return consumoComb; }
b) Redefina o método que devolve os Kms disponíveis, o qual se baseia na gasolina existente no depósito e no consumo combinado do carro, o qual será obviamente menor do que o consumo nominal.
virtual int KilometrosDisponiveis();
Espaço de resposta à questão 3b)
int CarroHibrido::KilometrosDisponiveis() {
return (int)(Carro::Gasolina()/consumoComb*100); }
4º Problema (3 Valores)
Considere a classe IntList, estudada no livro da cadeira, para a manipulação de uma Lista de inteiros ordenados e sem repetições.
class IntList {
struct IntNode {// Classe interna para os nós da lista. int data;
IntNode* ptNext;
IntNode(int n) { data = n; }// Construtor com int n. };
IntNode* ptList; // Apontador para o primeiro nodo. bool find(int v, IntNode *&prev, IntNode *&curr) const; // Inviabilizar a construção por cópia e a afectação. IntList (const IntList&) {} // Construtor por cópia. void operator=(const IntList &) {} // Afectação. public:
IntList();// Iniciar a lista.
~IntList() { removeAll(); } // Destruir todos os nós. bool insert(int val); // Inserir ordenado.
bool remove(int val); // Remover se existir. int removeHead(); // Remover o 1º nodo da lista. bool contain(int val) const; // Testar se existe val. void display() const; // Apresenta os elementos. bool isEmpty() const; // Testar se lista está vazia. void removeAll(); // Remover todos os elementos. };
a) Implemente um método (int removeTail()) para remover o último elemento da lista: int removeTail()
Espaço de resposta à questão 4a) int IntList::removeTail() {
