Introduzione alle classi e agli oggetti C ++

Oggetti sono la più grande differenza tra C ++ e C. Uno dei primi nomi per C ++ era C con Classi.

Una classe è una definizione di un oggetto. È un tipo proprio come int. Una classe ricorda a struct con una sola differenza: tutti i membri di struct sono pubblici per impostazione predefinita. Tutti i membri delle classi sono privati.

Ricorda: una classe è un tipo e un oggetto di questa classe è solo un variabile.

Prima di poter utilizzare un oggetto, è necessario crearlo. La definizione più semplice di una classe è:

 nome della classe {

 // membri

 }

Questa classe di esempio seguente modella un libro semplice. L'uso di OOP ti consente di astrarre il problema e pensarci e non solo variabili arbitrarie.

 // esempio uno

 #includere 

 #includere 

 libro di classe

 {

 int PageCount;

 int CurrentPage; 

 pubblico:

 Libro (int Numpages); // Costruttore

 ~ Book () {}; // Distruttore

 void SetPage (int PageNumber);

 int GetCurrentPage (void);

 }; 

 Book:: Book (int NumPages) {

 PageCount = NumPages;

 }

 void Book:: SetPage (int PageNumber) {

 CurrentPage = PageNumber;

 }

 int Book:: GetCurrentPage (void) {

 restituisce CurrentPage;

 }

 int main () {

 Libro ABook (128);

 Un libro. SetPage (56);

 std:: cout << "Pagina corrente" << ABook. GetCurrentPage () << std:: endl;

 ritorna 0;

 }

Tutto il codice da libro di classe fino al int Book:: GetCurrentPage (void) { la funzione fa parte della classe. Il principale() la funzione è lì per renderlo un'applicazione eseguibile.

Nel principale() funzione viene creata una variabile AB di tipo Libro con il valore 128. Non appena l'esecuzione raggiunge questo punto, l'oggetto ABook viene costruito. Nella riga successiva il metodo Un libro. SetPage () viene chiamato e il valore 56 assegnato alla variabile oggetto Un libro. Pagina corrente. Poi cout genera questo valore chiamando il Un libro. GetCurrentPage () metodo.

Quando l'esecuzione raggiunge il ritorna 0; l'oggetto ABook non è più necessario per l'applicazione. Il compilatore genera una chiamata al distruttore.

Tutto tra Libro di classe e il } è la dichiarazione di classe. Questa classe ha due membri privati, entrambi di tipo int. Questi sono privati ​​perché l'accesso predefinito ai membri della classe è privato.

Il pubblico: direttiva dice al compilatore che accede da qui in poi è pubblico. Senza questo, sarebbe comunque privato e impedirebbe alle tre righe nella funzione main () di accedere ai membri di Abook. Prova a commentare il pubblico: allineare e ricompilare per vedere i seguenti errori di compilazione.

Questa riga sotto dichiara un costruttore. Questa è la funzione chiamata quando l'oggetto viene creato per la prima volta.

 Libro (int Numpages); // Costruttore 

Si chiama dalla linea

 Libro ABook (128); 

Questo crea un oggetto chiamato ABook di tipo Book e chiama la funzione Book () con il parametro 128.

In C ++, il costruttore ha sempre lo stesso nome della classe. Il costruttore viene chiamato quando viene creato l'oggetto ed è dove dovresti inserire il codice per inizializzare l'oggetto.

Nel libro La riga successiva dopo il costruttore il distruttore. Questo ha lo stesso nome del costruttore ma con una ~ (tilde) davanti. Durante la distruzione di un oggetto, il distruttore viene chiamato per riordinare l'oggetto e garantire che vengano rilasciate risorse come memoria e handle di file utilizzati dall'oggetto.

Ricorda—Una classe xyz ha una funzione di costruzione xyz () e una funzione di distruttore ~ ​​xyz (). Anche se non dichiari, il compilatore li aggiungerà silenziosamente.

Il distruttore viene sempre chiamato quando l'oggetto viene terminato. In questo esempio, l'oggetto viene implicitamente distrutto quando esce dall'ambito. Per vedere questo, modifica la dichiarazione del distruttore in questo:

 ~ Book () {std:: cout << "Destructor chiamato";}; // Distruttore 

Questa è una funzione incorporata con codice nella dichiarazione. Un altro modo per inline è l'aggiunta della parola inline

 inline ~ Book (); // Distruttore

e aggiungi il distruttore come una funzione come questa.

 inline Book:: ~ Book (vuoto) { 

 std:: cout << "Destruttore chiamato";

 }

Le funzioni incorporate sono suggerimenti per il compilatore per generare codice più efficiente. Dovrebbero essere usati solo per piccole funzioni, ma se usati in luoghi appropriati, come all'interno loop—Può fare una differenza notevole nelle prestazioni.

La migliore pratica per gli oggetti è di rendere tutti i dati privati ​​e accedervi attraverso funzioni note come funzioni di accesso. SetPage () e GetCurrentPage () sono le due funzioni utilizzate per accedere alla variabile oggetto Pagina corrente.

Cambiare il classe dichiarazione da strutturare e ricompilare. Dovrebbe comunque essere compilato ed eseguito correttamente. Ora le due variabili PageCount e Pagina corrente sono accessibili al pubblico. Aggiungi questa riga dopo il libro ABook (128) e verrà compilata.

 Un libro. PageCount = 9;

Se cambi la struttura a classe e ricompilare, quella nuova riga non verrà più compilata come PageCount ora è di nuovo privato.

Dopo il corpo della dichiarazione Classe libro, ci sono le quattro definizioni delle funzioni membro. Ciascuno è definito con il prefisso Book:: per identificarlo come appartenente a quella classe.:: è chiamato identificatore dell'ambito. Identifica la funzione come parte della classe. Ciò è evidente nella dichiarazione di classe ma non al di fuori di essa.

Se hai dichiarato una funzione membro in una classe, devi fornire il corpo della funzione in questo modo. Se si desidera che la classe Book venga utilizzata da altri file, è possibile spostare la dichiarazione del libro in un altro intestazione file, forse chiamato book.h. Qualsiasi altro file potrebbe quindi includerlo con

 #include "book.h" 

Questo esempio dimostrerà l'eredità. Questa è un'applicazione a due classi con una classe derivata da un'altra.

 #includere 

 #includere 

 punto di classe

 {

 int x, y;

 pubblico:

 Punto (int atx, int aty); // Costruttore

 inline virtual ~ Point (); // Distruttore

 virtual void Draw ();

 }; 

 Cerchio di classe: punto pubblico {

 int radius;

 pubblico:

 Cerchio (int atx, int aty, int theRadius);

 inline virtual ~ Circle ();

 virtual void Draw ();

 };

 Point:: Point (int atx, int aty) {

 x = atx;

 y = aty;

 }

 inline Point:: ~ Point (vuoto) { 

 std:: cout << "Point Destructor chiamato";

 }

 void Point:: Draw (void) {

 std:: cout << "Point:: Disegna il punto su" << x << "" << y << std:: endl;

 }

 Cerchio:: Cerchio (int atx, int aty, int theRadius): Point (atx, aty) {

 radius = theRadius;

 }

 inline Circle:: ~ Circle () {

 std:: cout << "Circle Destructor chiamato" << std:: endl;

 }

 void Circle:: Draw (void) {

 Point:: Draw ();

 std:: cout << "cerchio:: Disegna punto" << "Raggio" << raggio << std:: endl;

 }

 int main () {

 Circle ACircle (10,10,5);

 Un cerchio. Disegnare() ;

 ritorna 0;

 }

L'esempio ha due classi, Punto e Cerchio, modellando un punto e un cerchio. Un punto ha coordinate xey. La classe Circle deriva dalla classe Point e aggiunge un raggio. Entrambe le classi includono a Disegnare() funzione membro. Per mantenere questo esempio breve l'output è solo testo.

La classe Cerchio è derivato dal Punto classe. Questo viene fatto in questa riga:

 classe Cerchio: Punto {

Poiché deriva da una classe base (Point), Circle eredita tutti i membri della classe.

 Punto (int atx, int aty); // Costruttore

 inline virtual ~ Point (); // Distruttore

 virtual void Draw ();

 Cerchio (int atx, int aty, int theRadius);

 inline virtual ~ Circle ();

 virtual void Draw ();

Pensa alla classe Circle come alla classe Point con un membro aggiuntivo (raggio). Eredita le funzioni membro della classe base e le variabili private X e y.

Non può assegnarle o usarle se non implicitamente perché sono private, quindi deve farlo attraverso la lista degli inizializzatori del costruttore Circle. Questo è qualcosa che dovresti accettare come è per ora. Tornerò agli elenchi di inizializzatori in un tutorial futuro.

Nel costruttore del cerchio, prima theRadius è assegnato a raggio, la parte Point di Circle viene costruita attraverso una chiamata al costruttore di Point nell'elenco di inizializzatori. Questo elenco è tutto compreso tra: e {sotto.

 Cerchio:: Cerchio (int atx, int aty, int theRadius): Point (atx, aty) 

Per inciso, l'inizializzazione del tipo di costruttore può essere utilizzata per tutti i tipi predefiniti.

 int a1 (10);

 int a2 = 10;

Entrambi fanno lo stesso.

Il polimorfismo è un termine generico che significa "molte forme". In C ++ la forma più semplice di polimorfismo è sovraccarico di funzioni. Ad esempio, vengono chiamate diverse funzioni SortArray (arraytype) dove sortarray potrebbe essere un Vettore di ints o doppio.

Tuttavia, siamo interessati solo alla forma di polimorfismo OOP qui. Questo viene fatto creando una funzione (ad es. Draw ()) virtuale nella classe base Point e poi sovrascrivendolo in classe derivata Cerchio.

Sebbene la funzione Disegnare() è virtuale nella classe derivata Cerchio, questo non è effettivamente necessario, è solo un promemoria per me che è virtuale. Se la funzione in una classe derivata corrisponde a una funzione virtuale nella classe base su nomi e tipi di parametro, è automaticamente virtuale.

Disegnare un punto e disegnare un cerchio sono due operazioni molto diverse con solo le coordinate del punto e del cerchio in comune, quindi è importante che il Disegnare() è chiamato. In che modo il compilatore riuscirà a generare codice che ottiene la giusta funzione virtuale verrà trattato in un tutorial futuro.

Un costruttore è una funzione che inizializza i membri di un oggetto. Un costruttore sa solo come costruire un oggetto della sua stessa classe.

I costruttori non vengono ereditati automaticamente tra la base e le classi derivate. Se non ne fornisci uno nella classe derivata, verrà fornito un valore predefinito ma ciò potrebbe non fare ciò che desideri.

Se non viene fornito alcun costruttore, il compilatore ne crea uno predefinito senza parametri. Deve esserci sempre un costruttore, anche se è predefinito e vuoto. Se si fornisce un costruttore con parametri, NON verrà creato un valore predefinito.

Alcuni punti sui costruttori:

• I costruttori sono solo funzioni con lo stesso nome della classe.
• I costruttori intendono inizializzare i membri della classe quando viene creata un'istanza di quella classe.
• I costruttori non vengono chiamati direttamente (tranne che attraverso gli elenchi di inizializzatori)
• I costruttori non sono mai virtuali.
• È possibile definire più costruttori per la stessa classe. Devono avere parametri diversi per distinguerli.

C'è molto altro da sapere sui costruttori, ad esempio costruttori predefiniti, assegnazioni e costruttori di copie. Questi saranno discussi nella prossima lezione.

Un distruttore è una funzione membro della classe che ha lo stesso nome del costruttore (e della classe) ma con una ~ (tilde) davanti.

 ~ Cerchio ();

Quando un oggetto esce dal campo di applicazione o più raramente viene esplicitamente distrutto, viene chiamato il suo distruttore. Ad esempio, se l'oggetto ha variabili dinamiche come i puntatori, è necessario liberarli e il distruttore è il posto appropriato.

A differenza dei costruttori, i distruttori possono e devono essere resi virtuali se si hanno classi derivate. Nel Punto e Cerchio esempio di classi, il distruttore non è necessario in quanto non è necessario eseguire alcun lavoro di pulizia (serve solo come esempio). Se ci fossero state variabili membro dinamiche (come puntatori) quindi quelli avrebbero richiesto la liberazione per evitare perdite di memoria.

Inoltre, quando la classe derivata aggiunge membri che richiedono di riordinare, sono necessari i distruttori virtuali. Quando è virtuale, viene chiamato per primo il distruttore di classe più derivato, quindi viene chiamato il distruttore del suo antenato immediato e così via fino alla classe base.

Nel nostro esempio,

 ~ Cerchio ();

poi

 ~ Point ();

Il distruttore delle classi base è chiamato ultimo.

Questo completa questa lezione. Nella lezione successiva, scopri i costruttori predefiniti, i costruttori di copie e il compito.