Track
/
C++
C++
/
Esercizi
/
Il gioco alieno di Ellen
Il gioco alieno di Ellen

Il gioco alieno di Ellen

Esercizio di apprendimento

Introduzione

Classi

È ora di arrivare ad uno dei paradigmi fondamentali del C++: la programmazione orientata agli oggetti (OOP). L'OOP è incentrata sulle classes, tipi di dati definiti dall'utente con il proprio insieme di funzioni correlate. Inizieremo dalle basi e tratteremo argomenti più avanzati più avanti nel percorso.

Membri

Le classi possono avere variabili membro e funzioni membro. Vi si accede tramite l'operatore di selezione dei membri .. Proprio come per le variabili al di fuori delle classes, è consigliabile inizializzare le variabili membro con un valore al momento della dichiarazione. Questo valore diventerà poi quello predefinito per i nuovi oggetti creati da questa classe.

Incapsulamento e occultamento delle informazioni

Le classi offrono la possibilità di limitare l'accesso ai propri membri. I due access specifiers di base sono private e public. I membri private non sono accessibili dall'esterno della classe. Ai membri public si può accedere liberamente. Per impostazione predefinita, tutti i membri di una class sono private. Solo i membri contrassegnati esplicitamente con public sono liberamente utilizzabili all'esterno della classe.

Esempio di base

La definizione di una class è visibile nell'esempio seguente. Nota il ; dopo la definizione:

class Wizard {
  public:               // from here on all members are publicly accessible
    int cast_spell() {  // defines the public member function cast_spell
      return damage;
    }
    std::string name{}; // defines the public member variable `name`
  private:              // from here on all members are private
    int damage{5};      // defines the private member variable `damage`
};

Puoi accedere a tutte le variabili membro dall'interno della classe. Dai un'occhiata a damage all'interno della funzione cast_spell. Non puoi leggere o modificare i membri private dall'esterno della classe:

Wizard silverhand{};
// calling the `cast_spell` function is okay, it is public:
silverhand.cast_spell();
// => 5

// name is public and can be changed:
silverhand.name = "Laeral";

// damage is private:
silverhand.damage = 500;
 // => Compilation error

Costruttori

I costruttori offrono la possibilità di assegnare valori alle variabili membro al momento della creazione dell'oggetto. Hanno lo stesso nome della class e non hanno un tipo di ritorno. Una classe può avere diversi costruttori. Questo è utile se non hai sempre bisogno di impostare tutte le variabili. A volte potresti voler lasciare tutto ai valori predefiniti e cambiare solo la variabile name. Nel caso di un Wizard potente, potresti voler cambiare anche il damage, quindi ti servono due constructors.

class Wizard {
  public:
    Wizard(std::string new_name) {
      name = new_name;
    }
    Wizard(std::string new_name, int new_damage) {
      name = new_name;
      damage = new_damage;
    }
    int cast_spell() {
      return damage;
    }
    std::string name{};
  private:
    int damage{5};
};

Wizard el{"Eleven"};       // deals  5 damage
Wizard vecna{"Vecna", 50}; // deals 50 damage

I costruttori sono un argomento complesso ed hanno molte sfumature. Se non definisci esplicitamente un constructor per la class, allora, e solo allora, il compilatore farà il lavoro al posto tuo. È quello che è successo nel primo esempio qui sopra. L'oggetto silverhand viene creato chiamando il costruttore predefinito: non è stato passato alcun argomento. Tutte le variabili sono impostate al valore indicato nella definizione della classe. Se non avessi indicato alcun valore in quella definizione, le variabili potrebbero rimanere non inizializzate, con possibili conseguenze indesiderate.

Note

Strutture

Le strutture derivano dalle radici C originali del linguaggio e sono vecchie quanto il C++ stesso. Sono in pratica la stessa cosa delle classes, con un'importante eccezione. Per impostazione predefinita, tutto ciò che sta in una class è private. Le strutture, invece, sono public finché non si specifica il contrario. Per convenzione, la parola chiave struct si usa spesso per le strutture di soli dati. La parola chiave class è invece preferita per gli oggetti che devono garantire determinate proprietà. Un invariante di questo tipo potrebbe essere che il damage della class Wizard non possa diventare negativo. La variabile damage è privata e qualsiasi funzione che modifichi il damage farebbe in modo che l'invariante venga mantenuto.

Istruzioni

Ellen sta creando un gioco in cui il giocatore deve combattere contro gli alieni. Ha appena imparato la programmazione orientata agli oggetti (OOP) e non vede l'ora di sfruttare quello che l'uso delle classes potrebbe offrire al suo programma.

Con grande gioia di Ellen, ti sei offerto di aiutarla e lei ti ha affidato il compito di programmare gli alieni che il giocatore deve combattere.

1. Crea la classe Alien

Definisci la classe Alien con un costruttore che accetta due parametri int, x e y, e li assegna alle variabili membro x_coordinate e y_coordinate. Inoltre ogni alieno partirà con un livello di salute di 3, quindi anche la variabile membro health va inizializzata.

health deve essere una variabile membro privata. Per permettere alle altre parti del programma di leggere le informazioni sulla salute, Ellen vuole un metodo public get_health() che restituisce un int.

Alien alien{2, 0};
alien.x_coordinate;
// => 2
alien.y_coordinate;
// => 0
alien.get_health();
// => 3

Ora ogni alieno deve poter tenere traccia al proprio interno della propria posizione e della propria salute.

2. La funzione hit

Ellen vorrebbe che la class Alien avesse un metodo hit che, quando viene chiamato, decrementa di 1 la salute di un oggetto alieno. Così può semplicemente chiamare some_alien_instance.hit() invece di dover cambiare a mano la salute di un alieno. Assicurati che i punti salute non scendano sotto zero. La funzione deve restituire true. Ellen vuole introdurre gli scudi più avanti, e in quel caso la funzione restituirebbe false se lo scudo è attivo.

Alien alien {0, 0};
alien.get_health();
// => 3 (Initial health value)

alien.hit(); // Decrements health by 1 point.
alien.get_health();
// => 2

3. La funzione is_alive

Ti rendi conto che, se la salute continua a diminuire, a un certo punto arriverà probabilmente a 0. Sarebbe una buona idea aggiungere un metodo is_alive che Ellen possa chiamare al volo per controllare se l'alieno è... beh... vivo. 😉 some_alien_instance.is_alive() deve restituire un booleano.

alien.get_health();
// => 1
alien.is_alive();
// => true
alien.hit();
alien.get_health();
// => 0
alien.is_alive();
// => false

4. La funzione teleport

Nel gioco di Ellen gli alieni possono teletrasportarsi! Dovrai scrivere un metodo teleport che accetta i valori x_new e y_new e modifica di conseguenza le coordinate dell'alieno. Per ora la funzione deve restituire true. Ellen vuole aggiungere bombe che bloccano il teletrasporto nei livelli successivi, e in quel caso la funzione restituirebbe false per i tentativi di teletrasporto falliti.

alien.teleport(5, -4);
alien.x_coordinate;
// => 5
alien.y_coordinate;
// => -4

5. La funzione collision_detection

Se gli alieni possono essere colpiti da qualcosa, allora devono poter rilevare quando una collisione del genere può verificarsi. Ellen ha bisogno di sapere se due alieni occupano le stesse coordinate. La funzione collision_detection() accetta come argomento un altro oggetto alieno e restituisce un bool.

Alien lrrr {3, 6};
Alien ndnd {-2, 12};
lrrr.collision_detection(ndnd);
// => false
ndnd.teleport(3, 6);
ndnd.collision_detection(lrrr);
// => true
Modifica tramite GitHub Il link si apre in una nuova finestra o scheda
C++ Exercism

Vuoi iniziare Il gioco alieno di Ellen?

Iscriviti a Exercism per imparare e padroneggiare C++ con 19 concetti100 esercizi e il mentoring di persone reali, tutto gratis.