Resolução dos Exercícios da Aula 7

Exercícios

1.  Construa uma classe FilaInt por herança privada de ListaInt.

R:

fila_double.H

#ifndef FILA_H
#define FILA_H

#include "lista_double.H"

class FilaDouble : private ListaDouble {
public:
    using ListaDouble::Item;
    void poe(Item const& item);
    void tira();
    Item frente() const;
    Item& frente();
    using ListaDouble::vazia;
    using ListaDouble::cheia;
    using ListaDouble::comprimento;
};

#include "fila_double_impl.H"

#endif // FILA_H

fila_double_impl.H
inline void FilaDouble::poe(Item const& item) {
    poeFim(item);
}

inline void FilaDouble::tira() {
    tiraPrimeiro();
}

inline FilaDouble::Item FilaDouble::frente() const {
    return primeiroItem();
}

inline FilaDouble::Item& FilaDouble::frente() {
    return primeiroItem();
}

2.  Dada a classe Filme no módulo filme que se segue:

filme.H

#ifndef FILME_H
#define FILME_H

#include <iostream>
#include <string>

class Filme {
  public:
    Filme(std::string const& nome, std::string const& realizador,
          int duracao);
    Filme(istream& entrada);

    std::string nome() const;
    std::string realizador() const;
    int duracao() const;

    void carrega(std::istream&);
    // void guarda(std::ostream&);

    void mostra(std::ostream&);
    // void le(std::istream&)

  private:
    std::string nome_;
    std::string realizador_;
    int duracao_;
};

#include "filme_impl.H"

#endif

filme_impl.H
inline Filme::Filme(std::string const& nome,
                    std::string const& realizador,
                    int duracao)
  :nome_(nome), realizador_(realizador), duracao_(duracao) {
}

inline Filme::Filme(std::istream& entrada) {
    carrega(entrada);
}

inline std::string Filme::nome() const {
    return nome_;
}

inline std::string Filme::realizador() const {
    return realizador_;
}

inline int Filme::duracao() const {
    return duracao_;
}

inline void Filme::mostra(std::ostream& saida) {
    saida << "Nome:\t\t" << nome_ << std::endl
          << "Realizador:\t" << realizador_ << std::endl
          << "Duracao:\t" << duracao_ << std::endl;
}

filme.C
#include "filme.H"

using namespace std;

void Filme::carrega(istream& entrada)
{
    getline(entrada, nome_ );
    getline(entrada, realizador_);
    entrada >> duracao_;
    char c;
    while(entrada.get(c) && c != '\n')
       ;
}

e o programa:

teste.C

#include <iostream>
#include <fstream>

using namespace std;

#include "filme.H"

int main()
{
    ifstream entrada("filmes.txt");

    Filme filme(entrada);
    filme.mostra(cout);
}

construa as classes FilmeEstrangeiro e EdicaoDoRealizador por herança pública de Filme.  A classe FilmeEstrangeiro deve ter informção sobre o país de origem e a língua em que o filme é falado. A classe EdicaoDoRealizador deve ter informação (uma string) sobre as alterações feitas ao original.

Ambas as classes devem ter procedimentos carrega() e mostra().

Altere o ficheiro teste.C de modo a que carregue de um ficheiro (usando o procedimento carrega()) um Filme, um FilmeEstrangeiro e uma EdicaoDoRealizador e os mostre no ecrã (usando o procedimento mostra()).  Cada classe derivada apenas carrega e mostra a sua própria informação específica, delegando sempre que necessário nos procedimentos da classe base para carregar e mostrar a informação genérica relativa a um Filme.

R:

outros_filmes.H

#ifndef OUTROS_FILMES_H
#define OUTROS_FILMES_H

#include <iostream>
#include <string>

#include "filme.H"

class FilmeEstrangeiro : public Filme {
public:
    FilmeEstrangeiro(std::string const& nome, std::string const& realizador,
                     int duracao,
                     std::string const& lingua, std::string const& pais);
    FilmeEstrangeiro(istream& entrada);

    std::string lingua() const;
    std::string pais() const;

    void carrega(std::istream&);
    // void guarda(std::ostream&);

    void mostra(std::ostream&);
    // void le(std::istream&)

private:
    std::string lingua_;
    std::string pais_;

    void carregaPrivado(std::istream&);
};

class EdicaoDoRealizador : public Filme {
public:
    EdicaoDoRealizador(std::string const& nome,
                       std::string const& realizador,
                       int duracao,
                       std::string const& alteracoes);
    EdicaoDoRealizador(istream& entrada);

    std::string alteracoes() const;

    void carrega(std::istream&);
    // void guarda(std::ostream&);

    void mostra(std::ostream&);
    // void le(std::istream&)

private:
    std::string alteracoes_;

    void carregaPrivado(std::istream&);
};

#include "outros_filmes_impl.H"

#endif // OUTROS_FILMES_H

outros_filmes_impl.H
inline FilmeEstrangeiro::FilmeEstrangeiro(std::string const& nome,
                                          std::string const& realizador,
                                          int duracao,
                                          std::string const& lingua,
                                          std::string const& pais)
    : Filme(nome, realizador, duracao), lingua_(lingua), pais_(pais) {
}

inline FilmeEstrangeiro::FilmeEstrangeiro(std::istream& entrada)
    : Filme(entrada) {
    carregaPrivado(entrada);
}

inline std::string FilmeEstrangeiro::lingua() const {
    return lingua_;
}

inline std::string FilmeEstrangeiro::pais() const {
    return pais_;
}

inline void FilmeEstrangeiro::carregaPrivado(std::istream& entrada)
{
    std::getline(entrada, lingua_ );
    std::getline(entrada, pais_);
}

inline void FilmeEstrangeiro::carrega(std::istream& entrada)
{
    Filme::carrega(entrada);
    carregaPrivado(entrada);
}

inline void FilmeEstrangeiro::mostra(std::ostream& saida) {
    Filme::mostra(saida);
    saida << "Língua:\t\t" << lingua_ << std::endl
          << "País:\t\t" << pais_ << std::endl;
}

inline
EdicaoDoRealizador::EdicaoDoRealizador(std::string const& nome,
                                       std::string const& realizador,
                                       int duracao,
                                       std::string const& alteracoes)
    : Filme(nome, realizador, duracao), alteracoes_(alteracoes) {
}

inline EdicaoDoRealizador::EdicaoDoRealizador(std::istream& entrada)
    : Filme(entrada) {
    carregaPrivado(entrada);
}

inline std::string EdicaoDoRealizador::alteracoes() const {
    return alteracoes_;
}

inline void EdicaoDoRealizador::carregaPrivado(std::istream& entrada) {
    std::getline(entrada, alteracoes_ );
}

inline void EdicaoDoRealizador::carrega(std::istream& entrada) {
    Filme::carrega(entrada);
    carregaPrivado(entrada);
}

inline void EdicaoDoRealizador::mostra(std::ostream& saida) {
    Filme::mostra(saida);
    saida << "Alterações:\t" << alteracoes_ << std::endl;
}

teste.C
#include <iostream>
#include <fstream>

using namespace std;

#include "filme.H"
#include "outros_filmes.H"

int main()
{
    ifstream entrada("filmes.txt");

    Filme filme(entrada);
    filme.mostra(cout);

    FilmeEstrangeiro filme_estrangeiro(entrada);
    filme_estrangeiro.mostra(cout);
    EdicaoDoRealizador edicao_realizador(entrada);
    edicao_realizador.mostra(cout);
}
 

Makefile
teste: teste.o filme.o
filme.o: filme.C filme.H filme_impl.H
teste.o: teste.C filme.H filme_impl.H outros_filmes.H outros_filmes_impl.H
3.  Trabalhe no Problema 2 da avaliação.