È 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.
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.
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.
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
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.
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.
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.
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.
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
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
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
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
Iscriviti a Exercism per imparare e padroneggiare C++ con 19 concetti100 esercizi e il mentoring di persone reali, tutto gratis.