C: Private Struktur als Teil einer Public Struktur

[Mark M. (mom-jovi)]

Ich würde gerne in einem C-Modul für einen Hardware-Treiber eine public 
Struktur deklarieren, die wiederum eine Struktur enthält, welche 
allerdings privat ist.

Geht sowas in C überhaupt?

Ich habe folgendes probiert, aber das funktioniert nicht, da die Public 
Deklaration im Header ja noch nichts von dem Private typedef weiß:

/**
 * driver.h
 */
typedef struct driver_class
{
   void attribute_1;
   void attrivute_2;
   driver_hardware_t hardware;
} driver_class_t;


/**
 * driver.c
 */
#include driver.h

typedef struct driver_hardware_t
{
   void* pHWModule1;
   void* pHWModule2;
}

/**
 * main.c
 */
#include driver.h

void main(void)
{
   driver_class_t   instance;
}

Die Private typedef muss nicht unbedingt eine Struktur sein, eine 
eifache Hardware-Adresse reicht evtl. auch. Aber hier nehmen wir an, 
dass der HW Treiber 2 Peripherie-Module ansprechen muss, z.B. Timer und 
ADC.

[Dr. Sommer (Gast)]

struct myStruct {
public:
  int somePublicMember;
private:
  int somePrivateMember;
};

Und den "gcc" Aufruf durch "g++" ersetzen.

[Mark M. (mom-jovi)]

Dr. Sommer schrieb:
>

struct myStruct {
> public:
>   int somePublicMember;
> private:
>   int somePrivateMember;
> };

> Und den "gcc" Aufruf durch "g++" ersetzen.

:-) Es geht hier aber um eine Lösung in C, da C++ nicht zum Einsatz 
kommt.

[Dr. Sommer (Gast)]

Mark M. schrieb:
> :-) Es geht hier aber um eine Lösung in C, da C++ nicht zum Einsatz
> kommt.
Warum versuchen immer alle C++ in C zu emulieren? Wenn man schon in 
private,public oder gar Objekten etc. denkt, kann man auch gleich C++ 
verwenden ohne sich den Krampf in C anzutun. Und sofern deine Plattform 
nicht völlig obskur ist wird es auch einen C++ Compiler geben, wenn du 
GCC verwendest eben einfach "gcc" durch "g++" ersetzen.

[(prx) A. K. (prx)]

Was nicht geht:

typedef struct driver_class
{
   ...
   driver_hardware_t hardware;
} driver_class_t;

Was geht:

typedef struct driver_class
{
   ...
   struct driver_hardware_s *hardware;
} driver_class_t;

Soll heissen: Ein Pointer auf eine unbekannte struct ist zulässig, aber 
auch nur der. Grund: Die Grösse des Pointers ist von der Definition der 
struct unabhängig.

[Tom K. (ez81)]

Die von AK beschriebene Methode heißt opaque pointer oder PIMPL :
http://en.wikipedia.org/wiki/Opaque_pointer#C

[Rolf Magnus (Gast)]

Alternativ geht man den Schritt zur Kapselung nicht nur halb, sondern 
gleich ganz und macht auch die struct driver_class nicht "public". 
Zugriff nur über Funktionen.

[Karl H. (kbuchegg)]

Rolf Magnus schrieb:
> Alternativ geht man den Schritt zur Kapselung nicht nur halb, sondern
> gleich ganz und macht auch die struct driver_class nicht "public".
> Zugriff nur über Funktionen.

Jep.
Und um dem geneigten Verwender dann auch noch jegliche Lust zu nehmen, 
da Tricks zu versuchen, kann man das Interface dann anstelle von 
spezfischen Pointern mit void Pointern gestalten. Dann muss man selbst 
zwar an den Schnittstellen ein wenig casten, aber der Verwender müsste 
das auch exzessiv tun.
Einen void Pointer hingegen kann er speichern und beim Aufruf einer 
anderen Funktion wieder benutzen ohne auch nur je davon gehört zu haben, 
wie die dahinter stehende Struktur heißt.
Nachteil natürlich: man hebelt sich selbst jegliche Typprüfung weg.

[Rolf Magnus (Gast)]

Es reicht doch, im Header nur eine Forward Declaration der Struct zu 
machen und einen Pointer darauf zu verwenden.

Karl Heinz schrieb:
> Einen void Pointer hingegen kann er speichern und beim Aufruf einer
> anderen Funktion wieder benutzen ohne auch nur je davon gehört zu haben,
> wie die dahinter stehende Struktur heißt.

Was ist denn so schlimm dran, wenn er das weiß?

[Mark M. (mom-jovi)]

Rolf Magnus schrieb:
> Alternativ geht man den Schritt zur Kapselung nicht nur halb, sondern
> gleich ganz und macht auch die struct driver_class nicht "public".
> Zugriff nur über Funktionen.
Der Hardware-Treiber soll aber so modular sein, dass ich bspw. bei einem 
uC mit 8 ADC und 4 Timern jeden mit jedem kombinieren kann - 
vorausgesetzt die Hardware lässt das zu. Heute so, morgen so. ;-)
Wenn ich also die struct driver_class auch "private" mache, muss ich mir 
ein enum o. ä. definieren, und bin damit in der Anzahl Instanzen 
beschränkt.