C/C++ Informationhiding (Datenkapselung)

[TTOm]

Frage: Gibt es die Möglichkeit Datenkapselung auch in C durchzufürhen? Worin liegen eigentlich die Unterschiede zwischen C und C++ zum Thema Informationhiding?!? Gibt es Unterschiede? Wenn ja welche? Ist Informationhiding in C überhaupt möglich? vielen dank für antworten, wäre sehr dringend! mfg ttom.

[HumeSikkins]

Gibt es die Möglichkeit Datenkapselung auch in C durchzufürhen?

Sicher. Gib z.B. bei google mal Abstrakte Datenstruktur (ADS) bzw. Abstrakter Datentyp (ADT) ein.

Worin liegen eigentlich die Unterschiede zwischen C und C++ zum Thema Informationhiding?!?

C++ bietet einfach eine größere Vielzahl an Methoden für Informationhiding und Kapselung.

Ist Informationhiding in C überhaupt möglich?

Sicher. Siehe z.B. ADT, ADS, Funktionen usw.

Information hiding und Kapselung sind aber zwei unterschiedliche Dinge. Information hiding ist zwar immer eine Form von Kapselung, andersherum muss Kapselung aber nicht immer mit information hiding zusammenhängen.

[TTOm]

aha

*nix verstanden hab*

[Marc++us]

*hüstel*

Also, ein klassischer Ansatz in C ist dafür der nichttypisierte Zeiger void*.

Nehmen wir mal an, Du willst die folgende Struktur für andere Leute unsichtbar machen:

struct Dingsbums
{
   int geheimerwert;
   int superzahl;
};

Es gibt zwei Funktionen, die auf dieser Struktur arbeiten. Wie implementieren wir das nun, so daß keiner sieht was in der Struktur steht?

// deine h-Datei dingsbums.h
#ifndef DINGSBUMS_H
#define DINGSBUMS_H

typedef void* DingsbumsPtr;

DingsbumsPtr allocDingsbums();
void freeDingsbums(DingsbumsPtr ptr);
void setGeheimerwert(DingsbumsPtr ptr, int val);
int getSumme(DingsbumsPtr ptr);

#endif

So, wenn ich nun als Benutzer auf Dingsbums zugreifen will, sieht das so aus:

DingsbumsPtr mydings;
mydings = allocDingsbums();
// ...
setGeheimerwert(mydings, 4711);
printf("%d\n", getSumme(mydings));
// ...
freeDingsbums(mydings);

Keiner sieht also, was sich hinter DingsbumsPtr verbirgt und kann auch nicht auf darin versteckte Attribute zugreifen.

Die Implementation dahinter sieht so aus:

// deine c-Datei dingsbums.c
#include "dingsbums.h"

struct Dingsbums
{
   int geheimerwert;
   int superzahl;
};

DingsbumsPtr allocDingsbums()
{
   return (DingsbumsPtr)malloc(sizeof(Dingsbums));
}

void freeDingsbums(DingsbumsPtr ptr)
{
   free((Dingsbums*)ptr);
}

int getSumme(DingsbumsPtr ptr)
{
   if (ptr)
   {
      return ( ((Dingsbums*)ptr)->geheimerwert + 
               ((Dingsbums*)ptr)->superzahl) );
   }
   else
      return 0; // naja, was auch immer :)
}

// falls Dir das zu viele Klammern und * -> sind, kannst Du ja auch

void setGeheimerwert(DingsbumsPtr ptr, int val)
{
   if (ptr)
   {
      Dingsbums* myptr = (Dingsbums*)ptr;
      myptr->geheimerwert = val;
   }
}

// schreiben

Ist zwar nicht so komfortionös wie C++ mit seinem private und hat in keinem Fall die Möglichkeiten von gemischten protected-Schnittstellen, aber private und public kann man damit ganz gut simulieren, übrigens auch für Funktionen.

[ Dieser Beitrag wurde am 27.05.2003 um 19:52 Uhr von Marc++us editiert. ]

[Duden]

Original erstellt von Marc++us:
komfortionös

[Marc++us]

Oh bitte, was gefällt Dir an "komfortionös" nicht? Ich finde das Wort nett...