Programmazione orientata agli oggetti – Come suggerisce il nome, utilizza gli oggetti nella programmazione. La programmazione orientata agli oggetti mira a implementare entità del mondo reale come ereditarietà, occultamento, polimorfismo, ecc. nella programmazione. Lo scopo principale dell'OOP è quello di collegare insieme i dati e le funzioni che operano su di essi in modo che nessun'altra parte del codice possa accedere a questi dati tranne quella funzione.

Esistono alcuni concetti di base che fungono da elementi costitutivi degli OOP, ad es.

1. Classe
2. Oggetti
3. Incapsulamento
4. Astrazione
5. Polimorfismo
6. Eredità
7. Legatura dinamica
8. Passaggio del messaggio

Caratteristiche di un linguaggio di programmazione orientato agli oggetti

confronto di stringhe in Java

Classe

L'elemento costitutivo del C++ che porta alla programmazione orientata agli oggetti è una classe. È un tipo di dati definito dall'utente, che contiene i propri membri dati e funzioni membro, a cui è possibile accedere e utilizzare creando un'istanza di quella classe. Una classe è come un progetto per un oggetto. Ad esempio: considera la classe delle automobili. Potrebbero esserci molte auto con nomi e marchi diversi, ma tutte condivideranno alcune proprietà comuni come tutte avranno 4 ruote, limite di velocità, autonomia di chilometraggio, ecc. Quindi qui, l'auto è la classe e le ruote, i limiti di velocità e il chilometraggio sono le loro proprietà.

• Una classe è un tipo di dati definito dall'utente che dispone di membri dati e funzioni membro.
• I membri dati sono le variabili dati e le funzioni membro sono le funzioni utilizzate per manipolare queste variabili insieme. Questi membri dati e funzioni membro definiscono le proprietà e il comportamento degli oggetti in una classe.
• Nell'esempio precedente della classe Auto, il membro dati sarà il limite di velocità, il chilometraggio, ecc. e le funzioni membro possono applicare freni, aumentare la velocità, ecc.

Possiamo dire che a Lezione in C++ è un progetto che rappresenta un gruppo di oggetti che condivide alcune proprietà e comportamenti comuni.

Oggetto

Un Oggetto è un'entità identificabile con alcune caratteristiche e comportamenti. Un Oggetto è un'istanza di una Classe. Quando viene definita una classe, non viene allocata memoria ma quando viene istanziata (ovvero viene creato un oggetto) viene allocata memoria.

// C++ Program to show the syntax/working of Objects as a // part of Object Oriented PProgramming #include  using namespace std; class person {  char name[20];  int id; public:  void getdetails() {} }; int main() {  person p1; // p1 is a object  return 0; }>

Gli oggetti occupano spazio in memoria e hanno un indirizzo associato come un record in pascal o struttura o unione. Quando un programma viene eseguito, gli oggetti interagiscono inviandosi messaggi tra loro. Ogni oggetto contiene dati e codice per manipolare i dati. Gli oggetti possono interagire senza dover conoscere i dettagli dei dati o del codice l'uno dell'altro, è sufficiente conoscere il tipo di messaggio accettato e il tipo di risposta restituita dagli oggetti.

Per saperne di più sugli oggetti e sulle classi C++, fare riferimento a questo articolo – Classi e oggetti C++

Incapsulamento

In termini normali, l'incapsulamento è definito come il raggruppamento di dati e informazioni in una singola unità. Nella programmazione orientata agli oggetti, l'incapsulamento è definito come l'unione dei dati e delle funzioni che li manipolano. Considera un esempio reale di incapsulamento, in un'azienda ci sono diverse sezioni come la sezione contabilità, la sezione finanza, la sezione vendite, ecc. La sezione finanza gestisce tutte le transazioni finanziarie e tiene traccia di tutti i dati relativi alla finanza. Allo stesso modo, la sezione vendite gestisce tutte le attività legate alle vendite e tiene traccia di tutte le vendite. Ora potrebbe verificarsi una situazione in cui per qualche motivo un funzionario della sezione finanziaria ha bisogno di tutti i dati sulle vendite in un determinato mese. In questo caso non gli è consentito accedere direttamente ai dati della sezione vendite. Dovrà prima contattare qualche altro responsabile della sezione vendite e poi chiedergli di fornire i dati particolari. Questo è ciò che è l'incapsulamento. Qui i dati della sezione vendite e dei dipendenti che possono manipolarli sono racchiusi sotto un'unica sezione vendite con nome.

Incapsulamento in C++

L'incapsulamento porta anche a astrazione o occultamento dei dati . Utilizzando l'incapsulamento si nascondono anche i dati. Nell'esempio precedente, i dati di una qualsiasi delle sezioni come vendite, finanza o conti sono nascosti da qualsiasi altra sezione.

vikas divyakirti

Per saperne di più sull'incapsulamento, fare riferimento a questo articolo – Incapsulamento in C++

Astrazione

L'astrazione dei dati è una delle caratteristiche più essenziali e importanti della programmazione orientata agli oggetti in C++. Astrazione significa mostrare solo le informazioni essenziali e nascondere i dettagli. L'astrazione dei dati si riferisce alla fornitura al mondo esterno solo delle informazioni essenziali sui dati, nascondendo i dettagli di base o l'implementazione. Considera un esempio di vita reale di un uomo che guida un'auto. L'uomo sa soltanto che premendo l'acceleratore la velocità dell'auto aumenterà o che frenando l'auto si fermerà, ma non sa come premendo l'acceleratore la velocità aumenti effettivamente, non conosce il meccanismo interno dell'auto o l'implementazione di un acceleratore, freni, ecc. nell'auto. Ecco cos'è l'astrazione.

• Astrazione mediante classi : Possiamo implementare l'astrazione in C++ utilizzando le classi. La classe ci aiuta a raggruppare i membri dati e le funzioni membro utilizzando gli specificatori di accesso disponibili. Una Classe può decidere quale membro dati sarà visibile al mondo esterno e quale no.
• Astrazione nei file Header : Un altro tipo di astrazione in C++ possono essere i file header. Ad esempio, considera il metodo pow() presente nel file di intestazione math.h. Ogni volta che dobbiamo calcolare la potenza di un numero, chiamiamo semplicemente la funzione pow() presente nel file header math.h e passiamo i numeri come argomenti senza conoscere l'algoritmo sottostante secondo il quale la funzione sta effettivamente calcolando la potenza dei numeri .

Per saperne di più sull'astrazione C++, fare riferimento a questo articolo – Astrazione in C++

Polimorfismo

La parola polimorfismo significa avere molte forme. In parole semplici, possiamo definire il polimorfismo come la capacità di un messaggio di essere visualizzato in più di una forma. Una persona allo stesso tempo può avere caratteristiche diverse. Un uomo è allo stesso tempo padre, marito e dipendente. Quindi la stessa persona possiede comportamenti diversi in situazioni diverse. Questo si chiama polimorfismo. Un'operazione può presentare comportamenti diversi in istanze diverse. Il comportamento dipende dai tipi di dati utilizzati nell'operazione. C++ supporta l'overloading degli operatori e l'overloading delle funzioni.

• Sovraccarico degli operatori : Il processo mediante il quale un operatore mostra comportamenti diversi in istanze diverse è noto come sovraccarico dell'operatore.
• Sovraccarico di funzioni : L'overload delle funzioni utilizza un singolo nome di funzione per eseguire diversi tipi di attività. Il polimorfismo è ampiamente utilizzato nell'implementazione dell'ereditarietà.

Esempio : Supponiamo di dover scrivere una funzione per aggiungere alcuni numeri interi, a volte ci sono 2 numeri interi e talvolta ci sono 3 numeri interi. Possiamo scrivere il metodo di addizione con lo stesso nome avendo parametri diversi, il metodo interessato verrà chiamato in base ai parametri.

Polimorfismo in C++

Per saperne di più sul polimorfismo, fare riferimento a questo articolo – Polimorfismo in C++

Eredità

Viene chiamata la capacità di una classe di derivare proprietà e caratteristiche da un'altra classe Eredità . L'ereditarietà è una delle caratteristiche più importanti della programmazione orientata agli oggetti.

• Sottoclasse : La classe che eredita le proprietà da un'altra classe è chiamata Sottoclasse o Classe Derivata.
• Classe eccellente : La classe le cui proprietà sono ereditate da una sottoclasse è chiamata Classe Base o Superclasse.
• Riutilizzabilità : L'ereditarietà supporta il concetto di riusabilità, ovvero quando vogliamo creare una nuova classe ed esiste già una classe che include parte del codice che desideriamo, possiamo derivare la nostra nuova classe dalla classe esistente. In questo modo riutilizziamo i campi e i metodi della classe esistente.

Esempio : Cane, Gatto, Mucca possono essere classi derivate dalla classe base animale.

Ereditarietà in C++

Per saperne di più sull'ereditarietà, fare riferimento a questo articolo – Ereditarietà in C++

stringa comparabile

Legatura dinamica

Nell'associazione dinamica, il codice da eseguire in risposta alla chiamata di funzione viene deciso in fase di esecuzione. C++ ha funzioni virtuali per sostenere questo. Poiché l'associazione dinamica è flessibile, evita gli svantaggi dell'associazione statica, che collegava la chiamata di funzione e la definizione in fase di compilazione.

Esempio:

// C++ Program to Demonstrate the Concept of Dynamic binding // with the help of virtual function #include  using namespace std; class GFG { public:  void call_Function() // function that call print  {  print();  }  void print() // the display function  {  cout << 'Printing the Base class Content' << endl;  } }; class GFG2 : public GFG // GFG2 inherit a publicly { public:  void print() // GFG2's display  {  cout << 'Printing the Derived class Content'  << endl;  } }; int main() {  GFG geeksforgeeks; // Creating GFG's object  geeksforgeeks.call_Function(); // Calling call_Function  GFG2 geeksforgeeks2; // creating GFG2 object  geeksforgeeks2.call_Function(); // calling call_Function  // for GFG2 object  return 0; }>

Printing the Base class Content Printing the Base class Content>

Come possiamo vedere, la funzione print() della classe genitore viene chiamata anche dall'oggetto della classe derivata. Per risolvere questo usiamo le funzioni virtuali.

Esempio sopra con funzione virtuale:

#include using namespace std; class GFG { public:  void call_Function() // function that call print  {  print();  }  virtual void print() // using 'virtual' for the display function   {  cout << 'Printing the Base class Content' << endl;  } }; class GFG2 : public GFG // GFG2 inherit a publicly { public:  void print() // GFG2's display  {  cout << 'Printing the Derived class Content'  << endl;  } }; int main() {  GFG geeksforgeeks; // Creating GFG's object  geeksforgeeks.call_Function(); // Calling call_Function  GFG2 geeksforgeeks2; // creating GFG2 object  geeksforgeeks2.call_Function(); // calling call_Function  // for GFG2 object  return 0; } //this code is contributed by Md Nizamuddin>

Printing the Base class Content Printing the Derived class Content>

Passaggio del messaggio

Gli oggetti comunicano tra loro inviando e ricevendo informazioni. Un messaggio per un oggetto è una richiesta per l'esecuzione di una procedura e quindi invocherà una funzione nell'oggetto ricevente che genera i risultati desiderati. Lo scambio di messaggi implica specificare il nome dell'oggetto, il nome della funzione e le informazioni da inviare.

Esempio:

#include  using namespace std; // Define a Car class with a method to display its speed class Car { public:  void displaySpeed(int speed) {  cout << 'The car is moving at ' << speed << ' km/h.' << endl;  } }; int main() {  // Create a Car object named myCar  Car myCar;  // Send a message to myCar to execute the displaySpeed method  int currentSpeed = 100;  myCar.displaySpeed(currentSpeed);  return 0; } //this code is contributed by Md Nizamuddin>

articoli Correlati :

• Classi e oggetti
• Eredità
• Modificatori di accesso
• Astrazione