4. Information-Hiding und Modularisieung, Design-Problem

Information-Hiding und Modularisieung, Design-Problem

  • S

    Guten Morgen,

    ich habe 2 Module Foo and Bar.

    Foo.h enthält irgendwelche (private) daten, welche in der Foo.c deklariert sind, und ich getter/setter habe.

    foo.h

    #ifndef FOO_H
#define FOO_H

struct foo_t; //Forware dec.

double foo_getValue(struct foo_t* foo);

void foo_setValue(struct foo_t* foo, double value);

#endif //FOO_H

    foo.c

    #include "foo.h"

struct foo_t
{
	double value;
};

double foo_getValue(struct foo_t* foo)
{
	return foo->value;
}

void foo_setValue(struct foo_t* foo, double value)
{
	foo->value = value;
}

    Dann habe ich eine Module bar, welche eine list /array der foos enthalten soll, wobei

    bar.h

    #ifndef BAR_H
#define BAR_H

#include "foo.h"

struct bar_t; //Forward dec.

struct bar_t* bar_create(const size_t capacity);

struct foo_h* bar_getFoo(struct bar_t* bar, const size_t idx);

#endif //FOO_H

    nun möchte ich auch hier die bar_t nicht offen legen , und diese im foo.c declarien:

    #include "bar.h"
#include "foo.h"

#include <stdlib.h>


struct bar_t
{
	struct foo_t* foos;
	size_t count;
};

struct bar_t* bar_create(const size_t capacity)
{
	struct bar_t* pBar = malloc(sizeof(struct bar_t));

	pBar->count = capacity;
	pBar->foos = calloc(capacity, sizeof(struct foo_t)); // <= hier kann foo_t größe ich bestimmt werden

	return pBar;
}

struct foo_h* bar_getFoo(struct bar_t* bar, const size_t idx)
{
	return bar->foos[idx]; // <= hier kann foo_t größe ich bestimmt werden
}

    Aber das Problem hier, nun leider , dass Bar nur die facade forward foo bestimmen kann, da diese ja nur in der foo.c. bekannt ist... alles ganz nachvollziebar.

    aber nun frage ich ich, wie sowas schön elegant in c designen kann!?

    0
    *
     1 Antwort
  • *

    @SoIntMan sagte in Information-Hiding und Modularisieung, Design-Problem:

    aber nun frage ich ich, wie sowas schön elegant in c designen kann!?

    In dem Du für zwei Header schreibst. In dem Header „für die Welt“ foo.h wird foo nur als Opaquer Zeiger deklariert, dann gibt es noch einen Header in dem die Implementation von foo foo_impl.h in dem die Struktur fürs Projekt definiert wird, und in der eigentlichen foo.c Datei werden dann die Funktionen definiert. Du musst natürlich aufpassen, dass foo.h und foo_impl.h nicht beide in das gleiche Include Verzeichnis abgelegt werden. Du brauchst ein internes Includes Verzeichnis fürs Projekt und ein öffentliches für die Welt.

    0
  • S

    @john-0 sagte in Information-Hiding und Modularisieung, Design-Problem:

    In dem Du für zwei Header schreibst. In dem Header „für die Welt“ foo.h wird foo nur als Opaquer Zeiger deklariert, dann gibt es noch einen Header in dem die Implementation von foo foo_impl.h in dem die Struktur fürs Projekt definiert wird, und in der eigentlichen foo.c Datei werden dann die Funktionen definiert. Du musst natürlich aufpassen, dass foo.h und foo_impl.h nicht beide in das gleiche Include Verzeichnis abgelegt werden. Du brauchst ein internes Includes Verzeichnis fürs Projekt und ein öffentliches für die Welt.

    ahh.. ok das macht Sinn. Quasi ein "public" verzeichnis der Headers /Schnittstellen nach außen. und die structs in in den impl Header bekannt, das ist gut. Danke Dir

    P.S. Kann jemand vll. noch ein gute(s) Buch/Bücher empfehlen Designe Pattern in C etc. ?

    0
Anmelden zum Antworten