Gegevensabstractie in C++

Gegevensabstractie verwijst naar het verstrekken van alleen essentiële informatie aan de buitenwereld en het verbergen van hun achtergronddetails, d.w.z. om de benodigde informatie in het programma weer te geven zonder de details te presenteren.

Data-abstractie is een programmeer- (en ontwerp)techniek die berust op de scheiding van interface en implementatie.

Laten we een voorbeeld uit de praktijk nemen van een tv, die u kunt in- en uitschakelen, het kanaal kunt wijzigen, het volume kunt aanpassen en externe componenten kunt toevoegen, zoals luidsprekers, videorecorders en dvd-spelers, MAAR u kent de interne details niet, die is, je weet niet hoe het signalen ontvangt via de ether of via een kabel, hoe het ze vertaalt en ze uiteindelijk op het scherm weergeeft.

We kunnen dus zeggen dat een televisie zijn interne implementatie duidelijk scheidt van zijn externe interface en dat je kunt spelen met zijn interfaces zoals de aan / uit-knop, kanaalwisselaar en volumeregeling zonder enige kennis van de binnenkant.

In C++ bieden klassen een hoog niveau van gegevensabstractie . Ze bieden de buitenwereld voldoende openbare methoden om met de functionaliteit van het object te spelen en objectgegevens te manipuleren, d.w.z. te vermelden zonder daadwerkelijk te weten hoe de klasse intern is geïmplementeerd.

Uw programma kan bijvoorbeeld een aanroep doen naar de sort() functie zonder te weten welk algoritme de functie daadwerkelijk gebruikt om de gegeven waarden te sorteren. In feite kan de onderliggende implementatie van de sorteerfunctionaliteit veranderen tussen releases van de bibliotheek, en zolang de interface hetzelfde blijft, zal je functieaanroep nog steeds werken.

In C++ gebruiken we klassen om onze eigen abstracte datatypes (ADT) te definiëren. U kunt de cout . gebruiken object van klasse ostream om gegevens op deze manier naar standaarduitvoer te streamen −

Live demo

#include <iostream>
using namespace std;

int main() {
   cout << "Hello C++" <<endl;
   return 0;
}

Hier hoef je niet te begrijpen hoe cout geeft de tekst weer op het scherm van de gebruiker. U hoeft alleen de openbare interface te kennen en de onderliggende implementatie van 'cout' is vrij te wijzigen.

Toegangslabels dwingen abstractie af

In C++ gebruiken we toegangslabels om de abstracte interface naar de klasse te definiëren. Een klasse kan nul of meer toegangslabels bevatten −

Leden gedefinieerd met een openbaar label zijn toegankelijk voor alle onderdelen van het programma. De data-abstractieweergave van een type wordt gedefinieerd door zijn openbare leden.
Leden die zijn gedefinieerd met een privélabel, zijn niet toegankelijk voor code die de klasse gebruikt. De privésecties verbergen de implementatie van code die het type gebruikt.

Er zijn geen beperkingen voor hoe vaak een toegangslabel mag verschijnen. Elk toegangslabel specificeert het toegangsniveau van de volgende liddefinities. Het opgegeven toegangsniveau blijft van kracht totdat het volgende toegangslabel wordt gevonden of de accolade rechts van de klasse wordt gezien.

Voordelen van data-abstractie

Gegevensabstractie biedt twee belangrijke voordelen −

Interne klassen zijn beschermd tegen onbedoelde fouten op gebruikersniveau, die de status van het object kunnen beschadigen.
De klasse-implementatie kan in de loop van de tijd evolueren als reactie op veranderende vereisten of bugrapporten zonder dat de code op gebruikersniveau moet worden gewijzigd.

Door alleen gegevensleden in het privégedeelte van de klas te definiëren, staat het de auteur van de klas vrij om wijzigingen in de gegevens aan te brengen. Als de implementatie verandert, hoeft alleen de klassecode te worden onderzocht om te zien wat voor invloed de wijziging kan hebben. Als gegevens openbaar zijn, kan elke functie die rechtstreeks toegang heeft tot de gegevensleden van de oude weergave worden verbroken.

Voorbeeld van gegevensabstractie

Elk C++-programma waarin u een klasse met openbare en privéleden implementeert, is een voorbeeld van gegevensabstractie. Beschouw het volgende voorbeeld −

Live demo

#include <iostream>
using namespace std;

class Adder {
   public:
      // constructor
      Adder(int i = 0) {
         total = i;
      }
      
      // interface to outside world
      void addNum(int number) {
         total += number;
      }
      
      // interface to outside world
      int getTotal() {
         return total;
      };
      
   private:
      // hidden data from outside world
      int total;
};

int main() {
   Adder a;
   
   a.addNum(10);
   a.addNum(20);
   a.addNum(30);

   cout << "Total " << a.getTotal() <<endl;
   return 0;
}

Wanneer de bovenstaande code wordt gecompileerd en uitgevoerd, levert dit het volgende resultaat op −

Total 60

Bovenstaande klasse telt getallen bij elkaar op en geeft de som terug. De openbare leden - addNum en getTotal zijn de interfaces naar de buitenwereld en een gebruiker moet ze kennen om de klasse te gebruiken. Het privélid totaal is iets dat de gebruiker niet hoeft te weten, maar dat nodig is om de klas goed te laten werken.

Strategie ontwerpen

Abstractie scheidt code in interface en implementatie. Dus tijdens het ontwerpen van uw component moet u de interface onafhankelijk houden van de implementatie, zodat als u de onderliggende implementatie wijzigt, de interface intact blijft.

In dit geval zouden welke programma's deze interfaces ook gebruiken, ze niet worden beïnvloed en zouden ze alleen opnieuw moeten worden gecompileerd met de nieuwste implementatie.

Polymorfisme in C++ Gegevensinkapseling in C++

C Taal