encapsulation c
Una panoramica completa dell'incapsulamento in C ++:
Abbiamo discusso in dettaglio di astrazione nel nostro precedente tutorial. L'astrazione, come sappiamo, nasconde i dettagli di implementazione all'utente ed espone solo l'interfaccia richiesta dall'utente.
In questo tutorial, discuteremo ancora un'altra importante funzionalità di OOP, ovvero l'incapsulamento. Astrazione e incapsulamento vanno di pari passo. In effetti, possiamo dire che il codice incapsulato ci aiuta nell'astrazione. In altre parole, incapsulamento e astrazione sono strettamente legati insieme.
=> Visita qui per il corso completo C ++ degli esperti.
Quindi, possiamo discutere questi due concetti insieme poiché esiste una linea molto sottile tra incapsulamento e astrazione.
Cosa imparerai:
- Cos'è l'incapsulamento?
- Implementazione dell'incapsulamento
- Differenza tra incapsulamento e astrazione
- Conclusione
- Lettura consigliata
Cos'è l'incapsulamento?
L'incapsulamento dei dati si riferisce al processo di associazione di dati e funzioni o metodi che operano su questi dati in una singola unità in modo che sia protetto da interferenze esterne e usi impropri.
java 8 nuove funzionalità con esempi
Questo è un importante concetto di programmazione orientata agli oggetti e porta a un altro concetto OOP noto come ' Dati nascosti '. L'incapsulamento nasconde i dati ei suoi membri, mentre l'astrazione espone solo i dettagli o le interfacce necessarie al mondo esterno.
In un certo senso, l'astrazione presenta la 'visione astratta' dei dati nascosti al mondo esterno. Quindi abbiamo già affermato che l'incapsulamento e l'astrazione vanno di pari passo.
Una classe in C ++ è quella in cui raggruppiamo i membri dati e le funzioni che operano su questi membri dati insieme a specificatori di accesso come l'incapsulamento privato, pubblico e protetto. Abbiamo già discusso degli specificatori di accesso nel nostro precedente tutorial su classi e oggetti.
Sappiamo anche che per impostazione predefinita i membri della classe sono privati. Quando dichiariamo i membri della classe come privati e i metodi per accedere ai membri della classe come pubblici, stiamo veramente implementando l'incapsulamento. Allo stesso tempo, forniamo una visione astratta dei dati al mondo esterno sotto forma di metodi pubblici.
Implementazione dell'incapsulamento
L'incapsulamento in C ++ è implementato come una classe che raggruppa i dati e le funzioni che operano su questi dati insieme. Per lo più i dati vengono dichiarati privati in modo che non siano accessibili al di fuori della classe. I metodi o le funzioni sono dichiarati pubblici ed è possibile accedervi utilizzando l'oggetto della classe.
Tuttavia, non possiamo accedere direttamente ai membri privati e questo è chiamato nascondere i dati. Al termine, i dati sono protetti e sono accessibili solo dalle funzioni di quella particolare classe in cui vengono dichiarati i dati.
// Example program #include #include using namespace std; //example class to demonstrate encapsulation class sampleData{ int num; char ch; public: //getter methods to read data values int getInt() const{ return num; } char getCh() const{ return ch; } //setter methods to set data values void setInt(int num) { this->num = num; } void setCh(char ch){ this->ch = ch; } }; int main() { sampleData s; s.setInt(100); s.setCh('Z'); cout<<'num = '< Nel programma sopra abbiamo raggruppato due variabili membro insieme ai metodi getter e setter in una classe. e questo è un esempio di incapsulamento.
Abbiamo dichiarato due variabili, ovvero num e ch, come variabili private in modo che non siano accessibili al mondo esterno. Sono accessibili solo alle funzioni che abbiamo dichiarato pubbliche. Quindi abbiamo membri dati nascosti come variabili private in una classe.
Facciamo un altro esempio per comprendere meglio l'incapsulamento in C ++.
#include #include using namespace std; //Accounts class: includes salary info for a particular employee class Accounts{ int empId; double salary, basic, allowances, deductions; public: Accounts(int empId):empId(empId){} //read salary info void readEmployeeInfo(int empId){ cout<<'Enter basic for the employee'< basic; cout<>allowances; cout<>deductions; } //calculate salary double calculateSalary(){ salary = basic+ allowances - deductions; return salary; } //display details void display(){ salary = calculateSalary(); cout<<'Employee: '< Produzione:
Immettere base per il dipendente1: 10000
indennità: 4324,43
detrazioni: 1000
Dipendente: 1
Stipendio: 13324,4
Questo è ancora un altro esempio di incapsulamento. Come mostrato sopra, abbiamo una classe Account che raggruppa i dati dell'account e tutte le funzioni che operano su questi dati in un'unica classe Account. Nella funzione principale, possiamo creare un oggetto di questa classe e accedere alle funzioni per ottenere le informazioni desiderate.
Ora, se alcune altre classi dicono che i dettagli dei dipendenti vogliono accedere ai dati degli account, non possono farlo direttamente. Dovrà creare un oggetto della classe Account e potrà accedere solo a quegli elementi che sono pubblici. In questo modo, utilizzando l'incapsulamento garantiamo il controllo dell'accesso ai dati e assicuriamo anche l'integrità dei dati.
come costruire un firewall per Windows
Differenza tra incapsulamento e astrazione
Astrazione e incapsulamento sono strettamente legati insieme. L'incapsulamento aiuta l'astrazione raggruppando insieme dati e metodi che operano su quei dati.
Incapsulamento Astrazione Nasconde i dati Nasconde l'implementazione Raggruppa dati e metodi insieme Fornisce un'interfaccia astratta all'utente che espone solo ciò che è richiesto Aiuta nell'astrazione Aiuta nel riutilizzo e nella sicurezza del codice. Implementato come una classe con specificatori di accesso che definiscono l'accesso a membri e metodi di dati Implementato come una classe astratta e interfacce che non possono essere istanziate.
Conclusione
L'incapsulamento è una delle caratteristiche più importanti di OOP in quanto ci fornisce un modo per nascondere i dati. Questo, a sua volta, rende i dati più sicuri e li protegge da usi dannosi.
L'incapsulamento aiuta l'astrazione, in modo che possiamo esporre solo l'interfaccia richiesta all'utente finale e nascondere altri dettagli di conseguenza. In questo tutorial, abbiamo esaminato i concetti di astrazione e incapsulamento in C ++.
Nel nostro prossimo tutorial, discuteremo dell'ereditarietà in C ++ con esempi.
=> Visita qui per l'esclusiva serie di tutorial di formazione C ++.
Lettura consigliata
- Astrazione dei dati in C ++
- Tipi di dati C ++
- La migliore serie di tutorial GRATUITI per C #: la guida definitiva a C # per principianti
- 70+ MIGLIORI tutorial C ++ per imparare la programmazione C ++ GRATUITAMENTE
- Funzioni di libreria in C ++
- Programmazione orientata agli oggetti in C ++
- Introduzione alle strutture dati in C ++
- Elenchi di inizializzatori in C ++
