Doctor Data

// 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;}
    };
}

Istruzioni

Inizi il tuo primo giorno in un'azienda australiana chiamata "Doctor Data", specializzata nel recupero di informazioni. Hai superato il colloquio di lavoro grazie alla tua conoscenza del C++ e delle sonde di von Neumann. Dato che hai visto molti file di test, il tuo nuovo capo vuole che tu ricrei i rispettivi file sorgente e di intestazione a partire da del codice di test che l'azienda ha recuperato di recente.

In questo esercizio ricreerai dei file perduti. Al momento il contenuto dei file è un insieme di dati inutilizzabili.

Hai quattro attività, tutte legate al recupero del codice perduto nei file di intestazione e sorgente.

1. Prova a estrarre i primi indizi

Dai un'occhiata a due righe recuperate dai file di test:

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

Il tuo occhio attento ha riconosciuto all'istante un namespace heaven. Vedi anche che deve esserci una classe chiamata Vessel. A quanto pare, il costruttore può essere chiamato con due o tre argomenti. Il primo argomento sembra essere di tipo string, il secondo è un numero. È possibile inizializzare la classe Vessel con un terzo argomento. Il terzo argomento proviene da un namespace star_map. È un enumeratore di tipo System. Hai persino ottenuto una delle enumerazioni: BetaHydri.

Prepara i file sorgente e di intestazione con le informazioni che hai scoperto. Ti servono due namespace: heaven e star_map. Il namespace heaven ha una classe Vessel, che può essere chiamata con due o tre argomenti. L'enum System va inserito nel namespace star_map e ha un'enumerazione BetaHydri. Tieni d'occhio le altre enumerazioni, così da poter aggiornare continuamente l'enum System.

2. Trova altri dettagli

Scopri altre righe dal test:

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);

Le righe di test appena trovate rivelano un'altra funzione membro della classe Vessel: replicate. Questa funzione riceve una stringa e restituisce un'altra istanza di Vessel. Ti fai un'idea del valore predefinito del terzo argomento del costruttore a partire dall'attività precedente. Vedi anche due variabili membro pubbliche della classe Vessel e la specifica della funzione membro replicate.

Aggiungi la funzione replicate e le variabili membro pubbliche current_system e generation ai file di intestazione e sorgente.

3. Esamina il funzionamento interno

Trovi altre righe interessanti nei file di test recuperati:

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);

A quanto pare, la classe Vessel ha una variabile membro busters, che può essere modificata con le due funzioni membro della classe make_buster e shoot_buster. Finché non emergono altre informazioni, ipotizzi che la funzione make_buster restituisca void. Dato che c'è un test per il valore restituito di shoot_buster, supponi che la funzione restituisca un bool.

Aggiungi le due funzioni e la variabile membro alla classe Vessel. Continua a cercare altri enumeratori di System.

4. Completa il quadro

Mentre scorri i file di test, trovi solo due sezioni di codice ancora scoperte:

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));

Vedi due funzioni che non sono membri della classe Vessel, dato che non vengono chiamate su un'istanza. get_older_bob confronta due istanze di Vessel e restituisce una string. in_the_same_system confronta due istanze di Vessel e restituisce un bool.

Implementa le ultime funzioni mancanti a partire dalle righe recuperate qui sopra.