classes objects c
Una breve introduzione a classi e oggetti in C ++.
Le classi e gli oggetti sono gli elementi costitutivi della programmazione orientata agli oggetti in C ++. Ogni entità, vivente o non vivente, può essere rappresentata come un oggetto e programmata di conseguenza utilizzando C ++. Così entità come un'auto, una scrivania, una persona, un uccello, un animale, ecc. Possono essere rappresentate come oggetti.
La classe è un livello superiore all'oggetto e rappresenta la categoria degli oggetti. Pertanto, la classe agisce come un progetto che delinea il design e i dettagli dell'oggetto. Ciò include i dati utilizzati per descrivere l'oggetto e vari metodi o funzioni che possono agire sui dati dell'oggetto.
=> Guarda qui la serie di formazione C ++ semplice.
In questo tutorial, discutiamo tutti i dettagli della classe e degli oggetti in C ++ insieme alla loro rappresentazione programmatica.
Cosa imparerai:
- Classi
- Oggetti
- Specificatori di accesso
- Costruttori
- Tipi di costruttori
- Operatore di assegnazione
- Cacciatorpediniere
- Puntatore 'questo'
- Conclusione
- Lettura consigliata
Classi
Una classe in C ++ può essere vista come un progetto o uno scheletro di una particolare entità. La classe è un tipo di dati definito dall'utente. Contiene le informazioni oi dati generali per quella particolare entità e le funzioni che operano su quella entità.
Nella sintassi C ++, definiamo una classe con la parola chiave 'class' seguita dal nome della classe.
Il nome della classe è seguito dai dettagli della classe racchiusi tra parentesi graffe e termina con un punto e virgola.
Il blocco seguente mostra la sintassi generale per la definizione della classe.
Come mostrato nella rappresentazione sopra, la classe può avere specificatori di accesso come public / protected / private. Può avere membri dati e funzioni membro. I dati e le funzioni vengono chiamati come membri della classe. Per impostazione predefinita, i membri sono privati della classe, in modo che nessuna entità esterna abbia accesso a questi membri.
Per esempio, un veicolo può essere una classe generalizzata con proprietà come modello, colore, numero di telaio, velocità_media, ecc. Può avere funzioni come changeModel, accelerate, slowdown, ecc. che eseguono azioni sui membri dei dati. Possiamo definire una classe denominata 'veicolo' che avrà tutti questi membri di dati e funzioni.
Come già accennato, una classe è solo un modello per le entità. Non occupa spazio in memoria quando è definito. Affinché una classe sia funzionale, dobbiamo definire oggetti che possono utilizzare i membri della classe.
Oggetti
Per utilizzare la funzionalità della classe, è necessario creare un'istanza della classe per creare un oggetto. Un oggetto è un'istanza di una classe. Con parole semplici, possiamo dire che un oggetto è una variabile di tipo class.
La sintassi generale per creare un oggetto è:
classname object_name;
Una volta creato l'oggetto, può essere utilizzato per accedere ai membri dati e alle funzioni di quella classe.
L'accesso ai membri della classe (dati e funzioni) viene effettuato utilizzando l'operatore punto (.), Chiamato anche operatore di accesso ai membri.
Se obj è il nome dell'oggetto e nella classe è presente una funzione 'display ()', è possibile accedere alla funzione come 'obj.display ()'.
Tuttavia, c'è un problema nella dichiarazione di cui sopra. Possiamo accedere alla funzione display () utilizzando un oggetto e l'operatore punto se la funzione è 'pubblica'.
Specificatori di accesso
In C ++, l'accesso ai membri dati e alle funzioni nella classe dipende dall'accesso dato a quel particolare membro dati o funzione utilizzando uno specificatore di accesso.
C ++ supporta i seguenti specificatori di accesso:
# 1) Privato
Questo è l'identificatore di accesso predefinito per una classe in C ++. Ciò significa che se non viene specificato alcun identificatore di accesso per i membri in una classe, viene considerata privata.
Quando un membro è privato, non è possibile accedervi al di fuori della classe. Nemmeno usando l'oggetto e l'operatore punto. È possibile accedere ai membri dei dati privati solo utilizzando le funzioni membro della classe.
occhiali per realtà virtuale per xbox 360
Tuttavia, c'è un'eccezione a questa regola, che discuteremo nei nostri argomenti successivi.
# 2) Pubblico
Un membro dati o una funzione definita come pubblica nella classe è accessibile a tutti gli utenti esterni alla classe. È possibile accedere a questi membri utilizzando l'oggetto e l'operatore punto.
# 3) Protetto
Un membro protetto di una classe è accessibile alla classe stessa e alle classi figlie di quella classe.
Questo specificatore di accesso viene utilizzato soprattutto in caso di ereditarietà e ne discuteremo in dettaglio discutendo l'argomento dell'ereditarietà.
Prendiamo il seguente esempio per comprendere meglio questi specificatori di accesso.
#include #include using namespace std; class ABC{ int var1 = 10; public: string name; void display() { cout<<'var1 ='< Produzione:
var1 = 10
nome = sth
In questo programma, abbiamo due membri di dati di cui var1 di tipo int è privato (specificatore di accesso non specificato. L'impostazione predefinita è privato). Un altro membro è il nome della stringa, che viene dichiarato pubblico. Abbiamo ancora un'altra funzione di visualizzazione che mostra il valore di entrambi questi membri.
Nella funzione main dichiariamo un oggetto abc della classe ABC. Quindi impostiamo i valori sui membri dei dati e anche la visualizzazione della funzione di chiamata utilizzando l'oggetto 'abc'.
Tuttavia, quando il compilatore incontra la riga abc.var1 = 20; genererà un errore che 'var1 è variabile privata'.
Questo perché non possiamo accedere a dati privati membri di una classe al di fuori della classe. Quindi c'è un errore. Ma possiamo accedervi all'interno della funzione e quindi quando restituiamo il valore di var1 nella funzione di visualizzazione; non genera alcun errore.
Quindi l'output del programma mostra il valore iniziale con cui viene dichiarata var1.
Finora, abbiamo visto i dettagli su classi, oggetti e specificatori di accesso, ora prendiamo un esempio completo di uno studente di classe campione. Questa classe ha membri dati: student_id, student_name e student_age. Ha anche funzioni membro per leggere le informazioni sugli studenti e visualizzare le informazioni sugli studenti.
Per rendere le cose facili per i lettori, abbiamo dichiarato tutti i membri della classe come pubblici.
Il seguente programma mostra l'implementazione completa.
#include #include using namespace std; class student{ public: int student_id; string student_name; int student_age; void read_studentInfo(); void print_studentInfo() { cout<<'
Student ID : '<student_id; cout<>student_name; cout<>student_age; } int main() { student s1; s1.read_studentInfo(); s1.print_studentInfo(); }
Produzione:
Immettere l'ID studente: 1
Inserisci student_name: abc
perché Linux è più veloce di Windows
Inserisci student_age: 12
ID studente: 1
Nome dello studente: abc
Età degli studenti: 12
Quindi, abbiamo una classe completa definita sopra. L'unica differenza notevole è che abbiamo definito una funzione 'print_studentInfo' all'interno della classe mentre l'altra funzione 'read_studentinfo' è definita all'esterno della classe. Questi sono i due modi in cui le funzioni membro possono essere definite per una classe.
Si noti che la funzione definita all'esterno ha ancora una dichiarazione / prototipo all'interno della classe. Inoltre, è definito al di fuori della classe utilizzando il operatore di risoluzione dell'ambito (: :) . Quindi, nella funzione principale, creiamo un oggetto classe studente e quindi chiamiamo le funzioni per leggere e visualizzare i dati.
Costruttori
Finora in questo tutorial, abbiamo creato un oggetto semplice e quindi assegniamo valori a ciascun membro dei dati della classe nella funzione principale dopo aver letto questi valori dall'input standard.
In questo argomento, daremo uno sguardo a una funzione speciale che viene utilizzata per inizializzare l'oggetto durante la sua creazione. Questa funzione speciale è chiamata costruttore.
Un costruttore è una funzione membro della classe ma differisce dalla normale funzione membro nei seguenti modi:
- Il costruttore non ha valore di ritorno, ovvero il costruttore non restituisce mai un valore.
- È una funzione membro pubblica della classe.
- Viene utilizzato per inizializzare i membri dati e costruire l'oggetto della classe.
- Viene chiamato automaticamente dal compilatore durante la creazione dell'oggetto.
Tipi di costruttori
C ++ supporta i seguenti tipi di costruttori.
# 1) Costruttore predefinito
Un costruttore predefinito è il costruttore di base e non ha parametri. Possiamo creare un oggetto semplice senza parametri utilizzando il costruttore predefinito.
Il costruttore predefinito ha la seguente sintassi:
classname() { //constructor code }
Se una classe non dispone di un costruttore predefinito, il compilatore lo crea.
# 2) Costruttore parametrizzato
Un costruttore parametrizzato è uno che dispone di un elenco di parametri tramite il quale è possibile inizializzare i membri della classe. Quando dichiariamo un oggetto in un costruttore parametrizzato, dobbiamo passare i valori iniziali alla funzione costruttore come parametri.
Una funzione di costruzione parametrizzata appare come mostrato di seguito.
classname(argument list){ //constructor code }
Un costruttore parametrizzato viene usato per sovraccaricare i costruttori. Vedremo di più sul sovraccarico nei nostri argomenti successivi.
Un costruttore parametrizzato viene utilizzato allo scopo di inizializzare membri di dati di oggetti diversi. Così facendo, possiamo trasferire diversi valori di membri di dati a diversi oggetti.
# 3) Copia costruttori
C ++ supporta un terzo tipo di costruttore noto come costruttore di copia. La sua forma generale è
classname (const classname & obj);
Come mostrato nella dichiarazione precedente, nel costruttore di copia viene creato un nuovo oggetto utilizzando i valori di un altro oggetto della stessa classe. Il parametro che viene passato al costruttore è il riferimento costante di un oggetto i cui valori verranno utilizzati per la costruzione del nuovo oggetto.
Un costruttore di copie viene solitamente chiamato nelle seguenti situazioni:
- Quando un oggetto classe viene restituito per valore.
- Quando un oggetto viene passato a una funzione come argomento e viene passato per valore.
- Quando un oggetto viene costruito da un altro oggetto della stessa classe.
- Quando un oggetto temporaneo viene generato dal compilatore.
Tuttavia, non possiamo garantire che il costruttore di copia verrà sicuramente chiamato in tutti i casi precedenti poiché il compilatore C ++ ha un modo per ottimizzare le operazioni di copia.
Un costruttore di copie esegue la copia a livello di membro tra gli oggetti. Proprio come il costruttore predefinito, il compilatore C ++ crea un costruttore di copia predefinito se non ne forniamo uno nel nostro programma. Ma quando una classe ha determinati membri di dati come puntatori, riferimenti o qualsiasi allocazione di risorse in fase di esecuzione, è necessario disporre di un nostro costruttore di copie definito dall'utente.
Il motivo è che il costruttore di copia predefinito esegue solo una copia superficiale dei membri dei dati, ovvero entrambi gli oggetti condivideranno la stessa posizione di memoria. Questo va bene per semplici membri di dati non puntatori.
Tuttavia, quando si tratta di puntatori o altri membri di dati dinamici, vorremmo che i dati fossero puntati su una nuova posizione di memoria. Questa è la copia completa e può essere ottenuta solo utilizzando un costruttore di copie definito dall'utente.
Di seguito viene fornito un programma C ++ completo che implementa tutti e tre i tipi di costruttori e il loro utilizzo nella costruzione di un oggetto.
#include #include using namespace std; class student{ public: int student_id; string student_name; int student_age; //default constructor student(){ student_id = 1; student_name = 'abc'; student_age = 10; } //parameterized constructor student(int id,string name,int age){ student_id = id; student_name = name; student_age = age; } //copy constructor student(const student& st){ student_id = st.student_id; student_name = st.student_name; student_age = st.student_age; } void print_studentInfo() { cout<<'
Student ID : '< Produzione:
********** S **********
ID studente: 1
Nome dello studente: abc
Età degli studenti: 10
********** s2 **********
ID studente: 2
Nome dello studente: xyz
Età degli studenti: 12
Lo screenshot per lo stesso è fornito di seguito.
In questo programma abbiamo definito una classe studentesca simile a quella definita nel programma precedente. La differenza è che invece di leggere i valori dei membri dati dall'input standard tramite una funzione, definiamo tre costruttori.
È assolutamente possibile che una classe abbia più di un costruttore. Abbiamo un costruttore predefinito che inizializza i membri dati sui valori iniziali. Successivamente, definiamo un costruttore parametrizzato che passa i valori iniziali come parametri al costruttore.
Successivamente, definiamo un costruttore di copia a cui passiamo un riferimento costante a un oggetto della classe student.
Nella funzione principale, creiamo tre oggetti separatamente utilizzando tre costruttori. Il primo oggetto s viene creato utilizzando il costruttore predefinito. Il secondo oggetto s1 viene creato utilizzando il costruttore parametrizzato mentre il terzo oggetto s2 viene creato utilizzando un costruttore di copia.
Notare la creazione del terzo oggetto s2. Qui assegniamo l'oggetto s1 già creato al nuovo oggetto s2. Pertanto, quando costruiamo un nuovo oggetto utilizzando l'oggetto già esistente, il compilatore chiama un costruttore di copia.
Operatore di assegnazione
Possiamo anche assegnare i valori di un oggetto a un altro utilizzando un operatore di assegnazione (=). In questo caso, avremo un'istruzione come s1 = s.
La differenza tra il costruttore di copia e l'operatore di assegnazione è che mentre il costruttore di copia costruisce del tutto un nuovo oggetto, l'operatore di assegnazione assegna semplicemente i valori di un membro dell'oggetto su RHS a quelli dell'oggetto su LHS. Ciò significa che gli oggetti su entrambi i lati di un operatore di assegnazione devono essere esistenti prima dell'assegnazione.
Cacciatorpediniere
Un distruttore è anche una funzione speciale come un costruttore, ma implementa la funzionalità che è esattamente opposta al costruttore. Mentre il costruttore viene utilizzato per creare un oggetto, un distruttore viene utilizzato per distruggere o eliminare un oggetto.
Alcune delle caratteristiche del distruttore includono:
- Il nome di un distruttore è uguale al nome della classe ma inizia con un segno tilde (~).
- Il distruttore non ha un tipo di ritorno.
- Un distruttore non ha argomenti.
- Può esserci un solo distruttore in una classe.
- Il compilatore crea sempre un distruttore predefinito se non ne forniamo uno per una classe.
La sintassi generale di un distruttore è:
~classname(){ //cleanup code }
Il distruttore di una classe viene solitamente chiamato nelle seguenti situazioni:
- Quando l'oggetto esce dall'ambito, viene chiamato automaticamente il distruttore di classe.
- Allo stesso modo, il distruttore viene chiamato quando il programma termina l'esecuzione. Ciò significa che anche tutti gli oggetti cessano di esistere. Quindi, verrà chiamato il distruttore di ogni oggetto.
- Il distruttore della classe viene chiamato anche quando viene eseguito l'operatore 'cancella' per eliminare un oggetto.
- Possiamo anche chiamare esplicitamente il distruttore per eseguire qualsiasi attività di pulizia dopo aver finito con la funzionalità dell'oggetto.
L'esempio fornito di seguito dimostra il funzionamento di un distruttore.
#include using namespace std; class sample{ public: sample(){ cout<<'Constructor::sample called'< Produzione:
Costruttore :: campione chiamato
Questa è una classe di esempio
Destructor :: ~ campione chiamato
Lo screenshot per l'output di cui sopra è riportato di seguito.
Abbiamo definito un esempio di classe in cui abbiamo definito un costruttore, un distruttore e un display di funzione. Nella funzione main, creiamo un oggetto obj di classe sample e quindi chiamiamo la funzione display su questo oggetto.
Successivamente, viene eseguito un ritorno 0. Nell'output, possiamo vedere che nel momento in cui la funzione di visualizzazione ritorna e il controllo del programma arriva all'istruzione return 0, il distruttore viene eseguito. Ciò significa che viene eseguito nel momento in cui l'oggetto esce dall'ambito.
Puntatore 'questo'
Il C ++ utilizza un concetto speciale relativo agli oggetti, noto come puntatore 'this'. Il puntatore 'this' punta sempre all'oggetto corrente. Quindi, a seconda della situazione, ogni volta che dobbiamo fare riferimento all'oggetto corrente, usiamo il puntatore 'this'.
Sappiamo che ogni volta che viene creata un'istanza della classe, ovvero un oggetto, viene creata una copia separata dei membri dei dati della classe per l'oggetto. Ma quando si tratta delle funzioni membro della classe, tutti gli oggetti condividono la stessa copia.
come aprire il file .json
Quindi, quando uno o più oggetti accedono simultaneamente alle funzioni membro, come possiamo garantire che i membri dati corretti siano accessibili e modificati dalle funzioni membro?
Questo è il luogo in cui 'questo' puntatore entra in azione. Il compilatore passa un puntatore implicito con il nome della funzione 'this'. Questo è chiamato il puntatore 'questo'.
Il puntatore 'this' viene passato come argomento nascosto a tutte le chiamate di funzione membro. Di solito è una variabile locale. Quindi, il puntatore 'questo' è un puntatore costante e il suo contenuto è l'indirizzo di memoria dell'oggetto corrente.
Notare che questo puntatore è disponibile solo per funzioni membro non statiche e non per funzioni statiche. Questo perché non è necessario accedere alle funzioni statiche utilizzando un oggetto. È possibile accedervi direttamente utilizzando il nome della classe.
Di solito usiamo il puntatore 'this' nelle situazioni in cui le variabili membro ei parametri vengono passati per inizializzare le variabili membro che condividono lo stesso nome. Lo usiamo anche quando dobbiamo restituire l'oggetto corrente dalla funzione.
Vediamo la dimostrazione del puntatore 'questo' di seguito.
#include using namespace std; class Sample { private: int num; char ch; public: Sample &setParam(int num, char ch){ this->num =num; this->ch = ch; return *this; } void printValues(){ cout<<'num = '< Produzione:
num = 100
ch = A
Nel programma precedente, abbiamo una classe chiamata Sample, con due membri di dati num e ch. Abbiamo una funzione membro setParam che passa i parametri con gli stessi nomi, num e ch per impostare i valori delle variabili membro.
All'interno della funzione, assegniamo questi valori alle variabili membro dell'oggetto corrente indicate da questo puntatore. Una volta impostati i valori, l'oggetto corrente 'this' viene restituito dalla funzione.
Nella funzione main, creiamo prima un oggetto della classe Sample, obj e chiamiamo una funzione setParam per impostare i valori, quindi chiamiamo la funzione printValues per stampare i valori.
Conclusione
Abbiamo imparato gli elementi costitutivi di base di OOP in C ++ in questo tutorial. Comprendere le classi e gli oggetti sono i requisiti principali, per cominciare, OOP in C ++. Abbiamo anche imparato a conoscere in dettaglio costruttori e distruttori con esempi.
Nel nostro prossimo tutorial, impareremo a conoscere gli elenchi di inizializzatori in C ++.
=> Guarda qui la serie di formazione C ++ semplice.
Lettura consigliata
- Concetti di Python OOP (classi, oggetti ed ereditarietà Python)
- Tutorial sull'interfaccia Java e sulla classe astratta con esempi
- Lavorare con oggetti Excel VBScript
- Tutorial QTP n. 7 - Il paradigma di identificazione degli oggetti di QTP - In che modo QTP identifica gli oggetti in modo univoco?
- Repository di oggetti in QTP - Tutorial # 22
- Utilizzo degli oggetti di connessione VBScript ADODB
- Polimorfismo di runtime in C ++
- Ereditarietà in C ++