Scrivere una classe.
Creiamo una classe che memorizzi colore e luminosità come variabili private e ti permetta di ottenere o modificare questo colore/luminosità usando i metodi:
class Colors // classe Colors
{
public:
Colors(); // costruttore
private:
byte _color; // variabile _color
byte _bright; // variabile _bright
};
Abbiamo creato una classe chiamata Colors
che ha un costruttore e variabili private _color e _bright.
Cosa è importante sapere:
- Il nome della classe è solitamente scritto con una lettera maiuscola per separarlo dalle variabili (che di solito sono scritte con una lettera minuscola).
- Il nome del costruttore deve corrispondere al nome della sua classe (il registro è importante).
- È consuetudine nominare le variabili private che iniziano con un trattino basso (_color).
- Potrebbe non esserci un costruttore, quindi il compilatore lo creerà da solo, il nome corrisponderà al nome della classe.
Consentiamo di specificare un valore _color durante la creazione di un oggetto. Per fare ciò, abbiamo bisogno di un costruttore che accetta parametri. Cioè, come una normale funzione:
class Colors // classe Colors
{
public:
Colors(byte color) // costruttore
{
_color = color; // memorizzare
}
private:
byte _color; // variabile _color
byte _bright; // variabile _bright
};
Colors myColor(50); // crea un oggetto myColor con un valore
Abbiamo reso il costruttore una funzione che prende un parametro byte e lo assegna alla variabile di classe _color.
Abbiamo scritto l'implementazione della funzione all'interno della classe, questo è importante perché può essere fatto dall'esterno. Dopo aver chiamato il costruttore (viene creato un oggetto), la variabile color viene rimossa dalla memoria (era locale), ma il suo valore rimane nel nostro _color. Consentiamo all'utente di impostare anche la luminosità durante la creazione dell'oggetto. È qui che ci aiuterà la conoscenza delle funzioni sovraccaricate.
class Colors
{
public:
Colors(byte color)
{
_color = color;
}
Colors(byte color, byte bright)
{
_color = color;
_bright = bright;
}
private:
byte _color;
byte _bright;
};
Colors myColor(10);
Colors myColor2(10, 20); // specificare colore e luminosità.
Ora abbiamo due costruttori e, durante la creazione di un oggetto, il programma stesso sceglierà quale utilizzare. Bene, restituiremo il nostro costruttore vuoto in modo da poter creare un oggetto senza inizializzare i parametri:
Colors myColor3(); // senza inizializzazione (sono necessarie parentesi).
Inizializzazione all'interno del costruttore. Vediamo come funziona:
class Colors
{
public:
Colors(byte color = 5, byte bright = 32)
{
_color = color;
_bright = bright;
}
private:
byte _color;
byte _bright;
};
Colors myColor(10); // crea l'oggetto myColor specificando _color (otteniamo
10, 32)
Colors myColor2(10, 20); // specificare il colore e la luminosità (otteniamo 10, 20)
Colors myColor3; // senza inizializzazione (получим 5, 32)
Un costruttore, in cui l'inizializzazione del valore di una variabile locale viene impostata tramite l'operatore (=), se non viene passato come parametro. Cioè, chiamando il costruttore durante la creazione di myColor3; non abbiamo passato alcun parametro e il costruttore ha preso i parametri predefiniti 5 e 32, e li ha equiparati a colore e luminosità. Nota anche che non mettiamo parentesi durante la creazione di myColor3; perché il costruttore
è universale. Durante la creazione di myColor(10) abbiamo passato solo il colore impostato su 10 e la luminosità è stata impostata automaticamente su 32. E come non specificare il colore, ma specificare la luminosità? Ma non c'è modo. Basta creare un nuovo costruttore. Aggiungiamo altri due metodi: per impostare e leggere i valori correnti. Tutto è semplice - impostazione per analogia con il costruttore e lettura - basta return:
class Colors
{
public:
Colors(byte color = 5, byte bright = 32)
{
_color = color;
_bright = bright;
}
void setColor(byte color)
{
_color = color;
}
void setBright(byte bright)
{
_bright = bright;
}
byte getColor()
{
return _color;
}
byte getBright()
{
return _bright;
}
private:
byte _color;
byte _bright;
};
Colors myColor(10);
Colors myColor2(10, 20);
Colors myColor3;
Ora, quando chiamiamo, ad esempio, myColor2.getColor() , otterremo il valore 10, come impostiamo durante l'inizializzazione. Se chiamiamo myColor2.setColor(50), impostiamo la variabile privata _color dell'oggetto myColor2 su 50. Con un'ulteriore chiamata a myColor2.getColor(), otterremo già 50. E allo stesso modo funziona con il resto degli oggetti e il metodo set/getBright che abbiamo scritto.
Cos'altro aggiungere: non è sempre conveniente scrivere l'implementazione di un metodo all'interno della classe, risulta essere molto macchinoso e la classe cessa di essere documentazione per se stessa. Ricorda la libreria Servo: i metodi sono dichiarati, ma scritti da qualche altra parte. Questo viene fatto in un file .cpp. Ora scriviamo l'implementazione dei metodi al di fuori della classe - lasceremo la descrizione dei metodi all'interno della classe e scriveremo l'implementazione "sotto", di conseguenza, la classe rimarrà pulita e visiva:
class Colors
{
public:
Colors(byte color = 5, byte bright = 30);
void setColor(byte color);
void setBright(byte bright);
byte getColor();
byte getBright();
private:
byte _color;
byte _bright;
};
Colors::Colors(byte color, byte bright)
{
_color = color;
_bright = bright;
}
void Colors::setColor(byte color)
{
_color = color;
}
void Colors::setBright(byte bright)
{
_bright = bright;
}
byte Colors::getColor()
{
return _color;
}
byte Colors::getBright()
{
return _bright;
}
Colors myColor(10);
Colors myColor2(10, 20);
Colors myColor3;
Il doppio due punti :: è un operatore che specifica l'ambito del nome a cui viene applicato. Scrivendo void Colors::setColor... abbiamo detto al compilatore che è questa funzione (metodo) setColor che appartiene alla classe Color, ed in effetti questa è l'implementazione del metodo descritto. Ciò significa che puoi avere un'altra funzione con lo stesso nome, ma non correlata alla classe Colors, il che è molto conveniente.
Ad esempio, tale aggiunta non comporterà un errore, perché abbiamo spiegato al compilatore a cosa si riferisce: la prima funzione è nella classe Colors, la seconda è solo una funzione in questo documento:
void Colors::setColor(byte color) // appartiene alla classe Colors
{
_color = color;
}
void setColor(byte color) // solo qualche funzione
{
return color;
}