Doutor Dados

// A file named quick_math.h
#pragma once
namespace quick_math {
    double super_root(double x, int n);
}

// A file named quick_math.cpp
#include "quick_math.h"
#include <cmath>
double quick_math::super_root(double x, int n) {
    while(n) { x = std::sqrt(x), --n;}
    return x;
}

// A file named robot_flower.h
#if !defined(ROBOT_FLOWER_H)
#define ROBOT_FLOWER_H
#include <string>
namespace robots {
    class Flower {
        private:
            bool needs_water{};
            int size{};
            std::string name{};
        public:
            Flower(std::string name, int size = 0);
            void give_water();
            std::string get_name();
            int get_size();
            void start_next_day();
    };
}
#endif

// A file named robot_flower.cpp
#include "robot_flower.h"
robots::Flower::Flower(std::string name, int size) {this->name = "Robotica " + name; this->size = size;}
void robots::Flower::start_next_day() {if (!needs_water) ++size; needs_water = true;}
std::string robots::Flower::get_name() {return name;}
int robots::Flower::get_size() {return size;}

// A file named robot_flower.h
#pragma once
#include <string>
namespace robots {
    class Flower {
        private:
            bool needs_water{};
            int size{};
            std::string name{};
        public:
            Flower(std::string name, int size = 0) {this->name = "Robotica " + name; this->size = size;}
            void give_water() {needs_water = false;}
            std::string get_name() {return name;}
            int get_size() {return size;}
            void start_next_day() {if (!needs_water) ++size; needs_water = true;}
    };
}

Instruções

Começas o teu primeiro dia numa empresa australiana chamada "Doctor Data", especializada em recuperação de informação. Arrasaste na entrevista de emprego graças aos teus conhecimentos de C++ e de sondas de von Neumann. Como já viste muitos ficheiros de testes, o teu novo chefe quer que recries os respetivos ficheiros fonte e de cabeçalho a partir de algum código de teste que a empresa recuperou recentemente.

Neste exercício, vais recriar ficheiros perdidos. Atualmente, o conteúdo dos ficheiros é lixo inutilizável.

Tens quatro tarefas, todas relacionadas com a recuperação do código perdido nos ficheiros de cabeçalho e fonte.

1. Tenta extrair as primeiras pistas

Olhas para duas linhas recuperadas dos ficheiros de testes:

heaven::Vessel bob{"Robert Johansson", 1};
heaven::Vessel will{"Riker", 2, star_map::System::BetaHydri};

O teu olhar atento reconheceu imediatamente um namespace heaven. Vês também que deve haver uma classe chamada Vessel. Pelos vistos, o construtor pode ser chamado com dois ou três argumentos. O primeiro argumento parece ser do tipo string e o segundo é um número. É possível inicializar a classe Vessel com um terceiro argumento. O terceiro argumento vem de um namespace star_map. É um enumerador do tipo System. Até já descobriste uma das enumerações: BetaHydri.

Prepara os ficheiros fonte e de cabeçalho com a informação que descobriste. Precisas de dois namespaces: heaven e star_map. O namespace heaven tem uma classe Vessel, que pode ser chamada com dois ou três argumentos. O enum System deve ser colocado no namespace star_map e tem uma enumeração BetaHydri. Fica atento a outras enumerações, para poderes atualizar constantemente o enum System.

2. Encontra mais detalhes

Desenterras mais linhas do teste:

heaven::Vessel bob{"Robert Johansson", 1};
REQUIRE(bob.current_system == star_map::System::Sol);
REQUIRE(bob.generation == 1);
heaven::Vessel bob5 = bob.replicate("Mario");
REQUIRE(bob5.current_system == star_map::System::Sol);
REQUIRE(bob5.generation == 2);

As linhas de teste que acabaste de encontrar revelam outra função membro da classe Vessel: replicate. Esta função recebe uma string e devolve outra instância de Vessel. Ficas com uma ideia do valor predefinido do terceiro argumento do construtor da tarefa anterior. Vês também duas variáveis membro públicas da classe Vessel e a especificação da função membro replicate.

Adiciona a função replicate e as variáveis membro públicas current_system e generation aos ficheiros de cabeçalho e fonte.

3. Observa o funcionamento interno

Encontras mais algumas linhas interessantes nos ficheiros de testes recuperados:

heaven::Vessel bob6{"Homer", 3, star_map::System::EpsilonEridani};
REQUIRE(bob6.busters == 0);
bob6.make_buster();
REQUIRE(bob6.busters == 1);
bool success = bob6.shoot_buster();
REQUIRE(success);
REQUIRE(bob6.busters == 0);
success = bob6.shoot_buster();
REQUIRE_FALSE(success);

Ao que parece, a classe Vessel tem uma variável membro busters, que pode ser alterada com as duas funções membro da classe make_buster e shoot_buster. Enquanto não surge mais informação, arriscas um palpite de que a função make_buster devolve void. Como há um teste para o valor devolvido de shoot_buster, assumes que a função devolve um bool.

Adiciona as duas funções e a variável membro à classe Vessel. Continua à procura de outros enumeradores de System.

4. Completa o quadro

Enquanto analisas os ficheiros de testes, encontras apenas duas secções de código por descobrir:

heaven::Vessel bob1{"Bob", 1, star_map::System::AlphaCentauri};
heaven::Vessel marv{"Marvin", 2, star_map::System::DeltaEridani};
heaven::Vessel milo{"Milo", 3, star_map::System::DeltaEridani};
heaven::Vessel howie{"Howard", 4, star_map::System::Omicron2Eridani};

REQUIRE("Bob" == heaven::get_older_bob(bob1, marv));
REQUIRE(heaven::in_the_same_system(marv, milo));
REQUIRE_FALSE(heaven::in_the_same_system(marv, howie));

Vês duas funções que não são membros da classe Vessel, pois não são chamadas com uma instância. get_older_bob compara duas instâncias de Vessel e devolve uma string. in_the_same_system compara duas instâncias de Vessel e devolve um bool.

Implementa as últimas funções em falta a partir das linhas recuperadas acima.