Data Abstractie in C++ Beheersen: Ontwerp Vereenvoudigen met Interface-Implementatie Scheiding

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

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

Laten we een real-life voorbeeld nemen van een TV, die u aan en uit kunt zetten, het kanaal kunt veranderen, het volume kunt aanpassen, en externe componenten kunt toevoegen zoals speakers, videorecorders, en DVD-spelers, MAAR u kent de interne details niet, dat wil zeggen, u weet niet hoe het signalen ontvangt door de lucht of via een kabel, hoe het ze vertaalt, en uiteindelijk op het scherm toont.

Dus, we kunnen zeggen dat een televisie duidelijk de interne implementatie scheidt van de externe interface en u kunt met de interfaces spelen zoals de aan/uit knop, kanaalwisselaar, en volumecontrole zonder enige kennis van de internalen.

In C++ bieden klassen een geweldig niveau van data abstractie. Ze bieden voldoende publieke methoden aan de buitenwereld om met de functionaliteit van het object te spelen en objectdata te manipuleren, d.w.z., state zonder daadwerkelijk te weten hoe de klasse intern geïmplementeerd is.

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

In C++ gebruiken we klassen om onze eigen abstracte datatypen (ADT) te definiëren. U kunt het cout object van klasse ostream gebruiken om data naar standaarduitvoer te streamen zoals dit:

 #include <iostream>
using namespace std;
int main() {
  cout << "Hello C++" <<endl;
  return 0;
} 

Hier hoeft u niet te begrijpen hoe cout de tekst op het scherm van de gebruiker toont. U hoeft alleen de publieke interface te kennen en de onderliggende implementatie van 'cout' is vrij om te veranderen.

Access Labels Dwingen Abstractie Af

In C++ gebruiken we access labels om de abstracte interface aan de klasse te definiëren. Een klasse kan nul of meer access labels bevatten:

• Leden gedefinieerd met een public label zijn toegankelijk voor alle delen van het programma. De data-abstractie view van een type wordt gedefinieerd door zijn publieke leden.

• Leden gedefinieerd met een private label zijn niet toegankelijk voor code die de klasse gebruikt. De private secties verbergen de implementatie van code die het type gebruikt.

Er zijn geen beperkingen op hoe vaak een access label mag voorkomen. Elk access label specificeert het toegangsniveau van de opvolgende liddefinities. Het gespecificeerde toegangsniveau blijft van kracht totdat het volgende access label ontmoet wordt of de sluitende rechter accolade van de klassebody wordt gezien.

Voordelen van Data Abstractie

Data abstractie biedt twee belangrijke voordelen:

• Klasse-internalen zijn beschermd tegen ongewillekeurige gebruikersfouten, die de staat van het object kunnen corrupten.

• De klasse-implementatie kan im Laufe der Zeit evolueren in reactie op veranderende eisen of bug reports zonder verandering in gebruikerscode te vereisen.

Door datamembers alleen in de private sectie van de klasse te definiëren, is de klasseschrijver vrij om veranderingen in de data aan te brengen. Als de implementatie verandert, hoeft alleen de klassencode onderzocht te worden om te zien welk effect de verandering kan hebben. Als data public is, dan kan elke functie die direct toegang heeft tot de datamembers van de oude representatie gebroken worden.

Data Abstractie Voorbeeld

Elk C++ programma waar u een klasse implementeert met publieke en private leden is een voorbeeld van data abstractie. Overweeg het volgende voorbeeld:

 #include <iostream>
using namespace std;
class Adder {
public:
  // constructor
  Adder(int i = 0) {
    total = i;
  }
  // interface naar buitenwereld
  void addNum(int number) {
    total += number;
  }
  // interface naar buitenwereld
  int getTotal() {
    return total;
  };
private:
  // verborgen data van buitenwereld
  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 gecompileerd en uitgevoerd wordt, produceert het het volgende resultaat:

 Total 60 

Bovenstaande klasse telt getallen op en retourneert de som. De publieke leden - addNum en getTotal zijn de interfaces naar de buitenwereld en een gebruiker moet ze kennen om de klasse te gebruiken. Het private lid total is iets wat de gebruiker niet hoeft te weten, maar nodig is voor de klasse om correct te functioneren.

Ontwerpstrategie

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 verandert, de interface intact blijft.

In dit geval zouden alle programma's die deze interfaces gebruiken, niet beïnvloed worden en zouden alleen een hercompilatie nodig hebben met de nieuwste implementatie.