Objectgeoriënteerd programmeren – Zoals de naam al doet vermoeden, worden bij het programmeren objecten gebruikt. Objectgeoriënteerd programmeren heeft tot doel om real-world entiteiten zoals overerving, verbergen, polymorfisme, enz. In het programmeren te implementeren. Het belangrijkste doel van OOP is om de gegevens en de functies die erop werken samen te binden, zodat geen enkel ander deel van de code toegang heeft tot deze gegevens, behalve die functie.
Er zijn enkele basisconcepten die fungeren als de bouwstenen van OOP’s, d.w.z.
- Klas
- Voorwerpen
- Inkapseling
- Abstractie
- Polymorfisme
- Erfenis
- Dynamische binding
- Bericht overslaan
Kenmerken van een objectgeoriënteerde programmeertaal
Mission Impossible alle films
Klas
De bouwsteen van C++ die leidt tot objectgeoriënteerd programmeren is een klasse. Het is een door de gebruiker gedefinieerd gegevenstype dat zijn eigen gegevensleden en lidfuncties bevat, die toegankelijk en gebruikt kunnen worden door een exemplaar van die klasse te maken. Een klasse is als een blauwdruk voor een object. Bijvoorbeeld: denk eens aan de autoklasse. Er kunnen veel auto's zijn met verschillende namen en merken, maar ze zullen allemaal een aantal gemeenschappelijke eigenschappen delen, zoals ze hebben allemaal 4 wielen, snelheidslimiet, kilometerbereik, enz. Dus hier is de auto de klasse, en wielen, snelheidslimieten , en kilometerstand zijn hun eigendommen.
- Een klasse is een door de gebruiker gedefinieerd gegevenstype met gegevensleden en lidfuncties.
- Gegevensleden zijn de gegevensvariabelen en lidfuncties zijn de functies die worden gebruikt om deze variabelen te manipuleren. Deze gegevensleden en lidfuncties definiëren samen de eigenschappen en het gedrag van de objecten in een klasse.
- In het bovenstaande voorbeeld van de klasse Auto is het gegevenslid de snelheidslimiet, kilometerstand, enz. En de ledenfuncties kunnen remmen toepassen, de snelheid verhogen, enz.
We kunnen zeggen dat A Klasse in C++ is een blauwdruk die een groep objecten vertegenwoordigt die enkele gemeenschappelijke eigenschappen en gedragingen gemeen hebben.
Voorwerp
Een object is een identificeerbare entiteit met bepaalde kenmerken en gedrag. Een object is een instantie van een klasse. Wanneer een klasse wordt gedefinieerd, wordt er geen geheugen toegewezen, maar wanneer deze wordt geïnstantieerd (dat wil zeggen dat er een object wordt gemaakt) wordt er geheugen toegewezen.
C++ // 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; }> Objecten nemen ruimte in beslag in het geheugen en hebben een bijbehorend adres, zoals een record in pascal of structuur of vereniging. Wanneer een programma wordt uitgevoerd, communiceren de objecten door berichten naar elkaar te sturen. Elk object bevat gegevens en code om de gegevens te manipuleren. Objecten kunnen communiceren zonder details van elkaars gegevens of code te hoeven kennen. Het is voldoende om te weten welk type bericht wordt geaccepteerd en welk type reactie door de objecten wordt geretourneerd.
Raadpleeg dit artikel voor meer informatie over C++-objecten en -klassen: C++ Klassen en objecten
Inkapseling
In normale termen wordt inkapseling gedefinieerd als het samenbrengen van gegevens en informatie onder één enkele eenheid. Bij objectgeoriënteerd programmeren wordt inkapseling gedefinieerd als het samenbinden van de gegevens en de functies die deze manipuleren. Beschouw een realistisch voorbeeld van inkapseling: in een bedrijf zijn er verschillende secties, zoals de boekhoudsectie, de financiële sectie, de verkoopsectie, enz. De financiële sectie verwerkt alle financiële transacties en houdt alle gegevens met betrekking tot financiën bij. Op dezelfde manier behandelt de verkoopsectie alle verkoopgerelateerde activiteiten en houdt het alle verkopen bij. Nu kan er een situatie ontstaan waarin een ambtenaar van de financiële afdeling om de een of andere reden alle gegevens over de verkopen in een bepaalde maand nodig heeft. In dit geval heeft hij geen directe toegang tot de gegevens van de verkoopsectie. Hij zal eerst contact moeten opnemen met een andere functionaris van de verkoopafdeling en hem vervolgens moeten vragen de betreffende gegevens te verstrekken. Dit is wat inkapseling is. Hier worden de gegevens van de verkoopsectie en de medewerkers die deze kunnen manipuleren onder één enkele naam verkoopsectie verpakt.
Inkapseling in C++
Inkapseling leidt ook tot gegevensabstractie of gegevensverberging . Het gebruik van inkapseling verbergt ook de gegevens. In het bovenstaande voorbeeld zijn de gegevens van een van de secties, zoals verkoop, financiën of accounts, verborgen voor elke andere sectie.
Raadpleeg dit artikel voor meer informatie over inkapseling: Inkapseling in C++
Abstractie
Gegevensabstractie is een van de meest essentiële en belangrijke kenmerken van objectgeoriënteerd programmeren in C++. Abstractie betekent alleen essentiële informatie weergeven en de details verbergen. Data-abstractie verwijst naar het verstrekken van alleen essentiële informatie over de gegevens aan de buitenwereld, waarbij de achtergronddetails of implementatie verborgen blijven. Beschouw eens een voorbeeld uit de praktijk van een man die een auto bestuurt. De man weet alleen dat het intrappen van het gaspedaal de snelheid van de auto zal verhogen, of dat het remmen de auto tot stilstand zal brengen, maar hij weet niet hoe de snelheid daadwerkelijk toeneemt als hij het gaspedaal indrukt. Hij weet niets van het interne mechanisme van de auto of het implementeren van een gaspedaal, remmen etc. in de auto. Dit is wat abstractie is.
- Abstractie met behulp van klassen : We kunnen Abstractie in C++ implementeren met behulp van klassen. De klasse helpt ons gegevensleden en lidfuncties te groeperen met behulp van beschikbare toegangsspecificaties. Een Klasse kan beslissen welk datalid zichtbaar is voor de buitenwereld en welke niet.
- Abstractie in headerbestanden : Nog een type abstractie in C++ kunnen headerbestanden zijn. Neem bijvoorbeeld de methode pow() die aanwezig is in het headerbestand math.h. Wanneer we de macht van een getal moeten berekenen, roepen we eenvoudigweg de functie pow() aan die aanwezig is in het headerbestand math.h en geven de getallen door als argumenten zonder het onderliggende algoritme te kennen volgens welke de functie feitelijk de macht van getallen berekent. .
Raadpleeg dit artikel voor meer informatie over C++-abstractie – Abstractie in C++
Polymorfisme
Het woord polymorfisme betekent dat er vele vormen zijn. In eenvoudige bewoordingen kunnen we polymorfisme definiëren als het vermogen van een bericht om in meer dan één vorm te worden weergegeven. Een persoon kan tegelijkertijd verschillende kenmerken hebben. Een man is tegelijkertijd vader, echtgenoot en werknemer. Dezelfde persoon vertoont dus verschillend gedrag in verschillende situaties. Dit heet polymorfisme. Een operatie kan in verschillende gevallen verschillend gedrag vertonen. Het gedrag is afhankelijk van de soorten gegevens die bij de bewerking worden gebruikt. C++ ondersteunt overbelasting door operators en overbelasting van functies.
- Overbelasting van de machinist : Het proces waarbij een operator in verschillende gevallen ander gedrag vertoont, staat bekend als overbelasting van de operator.
- Functie Overbelasting : Bij overbelasting van functies wordt één functienaam gebruikt om verschillende soorten taken uit te voeren. Polymorfisme wordt veelvuldig gebruikt bij het implementeren van overerving.
Voorbeeld : Stel dat we een functie moeten schrijven om enkele gehele getallen op te tellen, soms zijn er 2 gehele getallen, en soms zijn er 3 gehele getallen. We kunnen de optellingsmethode met dezelfde naam schrijven met verschillende parameters, de betreffende methode wordt aangeroepen op basis van de parameters.
Polymorfisme in C++
Java splitst de tekenreeks op door een scheidingsteken
Raadpleeg dit artikel voor meer informatie over polymorfisme - Polymorfisme in C++
Erfenis
Het vermogen van een klasse om eigenschappen en kenmerken af te leiden van een andere klasse wordt genoemd Erfenis . Overerving is een van de belangrijkste kenmerken van objectgeoriënteerd programmeren.
- Subklasse : De klasse die eigenschappen van een andere klasse erft, wordt Subklasse of Afgeleide klasse genoemd.
- Superklasse : De klasse waarvan de eigenschappen worden overgenomen door een subklasse, wordt Basisklasse of Superklasse genoemd.
- Herbruikbaarheid : Overerving ondersteunt het concept van herbruikbaarheid, dat wil zeggen dat wanneer we een nieuwe klasse willen maken en er al een klasse is die een deel van de code bevat die we willen, we onze nieuwe klasse kunnen afleiden uit de bestaande klasse. Door dit te doen, hergebruiken we de velden en methoden van de bestaande klasse.
Voorbeeld : Hond, Kat, Koe kunnen een afgeleide klasse of een dierenbasisklasse zijn.
Overerving in C++
Raadpleeg dit artikel voor meer informatie over erfenis: Overerving in C++
wat is 10 van de 100
Dynamische binding
Bij dynamische binding wordt tijdens runtime bepaald welke code moet worden uitgevoerd als reactie op de functieaanroep. C++ heeft virtuele functies om dit te ondersteunen. Omdat dynamische binding flexibel is, vermijdt het de nadelen van statische binding, die de functieaanroep en definitie tijdens het bouwen met elkaar verbond.
Voorbeeld:
C++ // 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; }> Uitvoer
Printing the Base class Content Printing the Base class Content>
Zoals we kunnen zien, wordt de functie print() van de bovenliggende klasse zelfs vanuit het afgeleide klasseobject aangeroepen. Om dit op te lossen gebruiken we virtuele functies.
Bovenstaand voorbeeld met virtuele functie:
C++ #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> Uitvoer
Printing the Base class Content Printing the Derived class Content>
Bericht overslaan
Objecten communiceren met elkaar door informatie te verzenden en te ontvangen. Een bericht voor een object is een verzoek om het uitvoeren van een procedure en zal dus een functie in het ontvangende object aanroepen die de gewenste resultaten genereert. Bij het doorgeven van berichten moet u de naam van het object, de naam van de functie en de te verzenden informatie opgeven.
Voorbeeld:
C++ #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>
gerelateerde artikelen :
- Klassen en objecten
- Erfenis
- Toegang tot modificaties
- Abstractie