mikrocontroller.net

Forum: Compiler & IDEs Kapselung in C


Autor: Andreas G. (andy1988)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo,
ich habe eine generelle Frage zum Programmieren in C.

Ich bin sonst nur verwöhntes OOP Kind. Hab bisher fast nie etwas mit 
prozedualer Programmierung zu tun gehabt, ausser ein wenig PHP Gefrickel 
in meinen Anfangszeiten.
Selbst in C++ hab ich bisher relativ wenig gemacht. Langsam komm ich 
jedoch auf den Geschmack von Hardwarenäherem Zeug.
Mir gefällt der OOP-Ansatz auch wesentlich besser, aber auf 
Mikrocontrollern steh ich dem Ganzen etwas skeptisch gegenüber.

Ich stehe jetzt vor dem Problem, dass ich ein Programm habe, dass 
mehrere Queues benötigt. Eine Queue implementieren ist jetzt nicht das 
Ding. Wie gesagt: EINE.
Was macht man nun, wenn ich mehrere Queues benötige? Ich brauche also 
irgendwie Instanzen von dieser Queue.

Meine erste Idee war einfach einen Pointer auf den anfang eines 
allokierten Speicherbereis bei jeder Funktion mitzuliefern, aber das 
ganze ist auch blöd, weil ich das Ding 1. ständig überall mitführen muss 
und 2. unter Umständen noch andere Daten wie die größe oder Schreib- und 
Lesezeiger für einen Ringpuffer benötige. Irgendwie müsste ich die Daten 
Kapseln.
Bei einem Pointer auf eine struct kann ich zwar die Metadaten wie die 
Größe usw. komfortabel speichern, muss den Pointer aber immernoch von 
einer Ecke in die nächste schieben.

Was macht man da nu?
Wahrscheinlich werde ich zumindest nichtt um den Pointer auf die struct 
herumkommen.

Danke für die Hilfe,
Andreas

Autor: Bernhard M. (boregard)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ja, das ist das Standardverfahren in C. Viele (Programmierer, APIs) 
verstecken diesen Pointer noch indem sie ihn evtl. als void* anlegen 
(mit typedef) und nennen das dann "Handle".

Na, und wie machts den C++?

Im Prinzip genauso, die Erweiterung ist, daß jede Instanz einen "this" 
pointer hat, der auf die eigenen Daten zeigt. In C++ wird im Prinzip 
dieser Zeiger als erster Parameter jeder Methode übergeben, dies ist 
aber ein versteckter Parameter, d.h. in C++ sieht man ihn nicht, aber 
auf Assemblerebene ist er da....

Autor: Stefan Ernst (sternst)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Andreas Galauner wrote:

> Was macht man da nu?

Das, was du schon angedeutet hast. Alle Daten, die zu einer Queue 
gehören (Puffer, Indizes, etc), in eine Struktur packen (das ist dann 
quasi dein Objekt) und den Funktionen jeweils einen Pointer auf solch 
eine Struktur mitgeben.

> Wahrscheinlich werde ich zumindest nichtt um den Pointer auf die struct
> herumkommen.

Genauso wenig, wie du bei OOP um das konkrete Objekt herumkommst.

OOP:
ObjTyp Objekt;

Objekt.MethodeA(...);
Objekt.MethodeB(...);

C:
ObjTyp Objekt;

MethodeA(&Objekt,...);
MethodeB(&Objekt,...);

Bei OOP hast du nur bei der Implementierung der Methoden eine etwas 
kürzere Schreibweise beim Datenzugriff (jedenfalls meistens, je nach 
Sprache).

OOP:
RetTyp ObjTyp:MethodeA (...) {

    Member1 = 1;
    Member2 = 2;

C:
RetTyp MethodeA (ObjTyp *this, ...) {

    this->Member1 = 1;
    this->Member2 = 2;


Du siehst, die Unterschiede sind bei relativ simplen Objekten nicht sooo 
groß.

Autor: P. S. (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Noch einfacher ist natuerlich, man nimmt einfach C++. Nur auf virtuals 
musst du verzichten, die funktionieren nach meiner Erfahrung nicht. Wenn 
du ohne nicht auskommst, musst du eben Funktionspointer nehmen.

Sorgen wuerde ich mir eher ueber Speicherfragmentierung bei Verwendung 
von dynamischen Strukturen machen...

Autor: Andreas G. (andy1988)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hm, naja.
Ich hab damit größeres vor. Evtl. nehm ich doch C++. Eine 
Speicherverwaltung will ich eh implementieren. Das ganze soll ein 
Experiment werden, bei dem ich mal versuche nen kleineren 
Betriebssystemkern zu implementieren.
Ja, ich weiß. Das gibt es schon. Das bringt mich aber insofern nicht 
weiter, da ich das ganze für ein Fach im Studium machen möchte. Deswegen 
die ganze Arbeit.

Da ich da jedem "Prozess", der vom Scheduler verwaltet wird, die 
Möglichkeit geben möchte Speicher, auch auf dem Heap, nicht nur auf dem 
Stack, zu allokieren, muss ich da irgendwie getrennte Adressräume 
reinbekommen. Ist ja alles möglich. Zumindest in C++ kann ich das schön 
mit dem new und delete Operator überwachen und verwalten. Jeder Prozess 
bekommt eine bestimmte Menge an Arbeitsspeicher zugewiesen. Ist der 
voll, ist das halt so. Da hab ich dann als Entwickler drauf zu achten. 
Die Adressräume sind also in der Größe statisch, auch, wenn kein 
Speicher benutzt wird. Das ganze ohne MMU dynamisch zu machen ist 
einfach zu viel für nen kleinen AVR.
Hab nur gedacht, dass es in C vielleicht angebrachter wäre sowas zu 
machen.

Ich will das ganze auf nem AVR machen, da ich gedacht habe, dass es 
einfacher sei den Kram zu implemtieren, als auf der x86 Architektur. Nur 
frag ich mich langsam, ob das so richtig ist :D
Um nen externen SRAM werd ich wahrscheinlich auch nicht rumkommen. 
Wieder mehr Aufwand.
Verglichen mit dem ganzen x86 spezifischen Kram sollte sich das aber 
wieder relativieren. Protected/Real mode, VESA implementierung für ne 
vernünftige Grafikausgabe, GDT und IDT und der ganze Rattenschwanz dazu.

Ich glaub ich fang einfach mal in C++ an und schuster mir ne 
Speicherverwaltung. Dann werd ich sehen, wie gut oder schlecht das geht 
:D

Aber danke schonmal für die Tipps.

Autor: daniel (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
@  Andreas Galauner

da hast du dir etwas interessantes vorgenommen.

>Ich glaub ich fang einfach mal in C++ an und schuster mir ne
>Speicherverwaltung. Dann werd ich sehen, wie gut oder schlecht das geht.

Würde ich vielleicht auch so machen. Viele Featers von C++
wirst eh nicht brauchen. Nachträglich in C zu übertragen
wäre auch keine grosse Sache.

Berichte mal ab und zu wie du vorankommst.

grüsse, daniel

Autor: Andreas G. (andy1988)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Interessant auf jeden Fall. Ich werde mich, soweit zeitlich möglich (mir 
sitzt da leider sone fiese Matheprüfung im Nacken), erstmal versuchen 
mir über die Speicherverwaltung Gedanken zu machen. ich hab da in meiner 
Studentenbude ein hübsches Buch über den Linux Kernel. Mal sehen 
inwieweit mich das weiterbringt ohne MMU und meiner Vereinfachung.
Falls jemand interessante Verbesserungsvorschläge oder weitere Ideen 
hat, kann er die gerne einbringen.

Ich will halt erstmal für mich lernen, daher kann ich nur daraus 
profitieren ;)

So... jetzt widme ich mich wieder meiner Zigarre und meinem "Lecker 
Bierchen" von Horst Lichter ;)
Zum wohlsein!

Autor: mgiaco (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Also ohne Vererbung ist Kapselung einfach. Kleines Beispiel eine 
Saturation.

saturation.h
#ifndef SATURATION_H_
#define SATURATION_H_

/* "class" Saturation */
typedef struct SaturationTag Saturation;

struct SaturationTag {
  float max;
  float min;
  boolean saturate;
};

extern void Saturation_ctor(Saturation *me, float max, float min);
extern float Saturation_saturate(Saturation *me, float in);
extern boolean Saturation_isSaturated(Saturation *me);

#endif /* SATURATION_H_ */


saturation.c
#include "types.h"
#include "Saturation.h"

void Saturation_ctor(Saturation *me, float max, float min) {
  me->max = max;
  me->min = min;
}

float Saturation_saturate(Saturation *me, float in) {
  if (in > me->max) {
    me->saturate = TRUE;
    return me->max;
  } else
    me->saturate = FALSE;

  if (in < me->min) {
    me->saturate = TRUE;
    return me->min;
  } else
    me->saturate = FALSE;

  return in;
}

boolean Saturation_isSaturated(Saturation *me) {
  return me->saturate;
}

Anwenden:

static Saturation sat1;
static Saturation sat2;

Saturation_ctor(sat1, 10, -10);
Saturation_ctor(sat1, 5, 0);

usw...

So kannst du auch deine Queue implementieren und X mal verwenden.

Wenn du auch Vererbung brauchst schau mal hier:

http://www.emilmont.net/doku.php?id=c:object_oriented_c

oder besser

http://www.state-machine.com/devzone/cookbook.htm

ganz unten C+

mfg mgiaco

Autor: Andreas G. (andy1988)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hmm, das is ja mal voll gut!
Hab erstmal mit C++ angefangen. Um die Vererbung rumzukommen ist gar 
nicht so einfach. Vielleicht steig ich dann doch um.

Bin grade dabei mal n grundlegendes Klassendesign zu implementieren. 
Port- und Registerzugriff funktioniert schon. Darauf aufbauend 
implementier ich ne Debugging Konsole übers USART, womit ich mir n paar 
Statistiken und RAM Dumps usw. holen kann.

Mein selbstgebauter JTAG Adapter funktioniert nicht und ich hab jetzt 
keinen Bock nach dem Fehler zu suchen ;)

Autor: daniel (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
um die virtuelle Funktionen nachzubilden, kann man zum Trick greifen

struct Counter {
   struct Operations * ops;
   int cnt;
}; 

// die aktuellen implementierungen der methoden von A
void increment(const struct A * self) { self->cnt++; }
void decrement(const struct A * self) { self->cnt--; }

// ersetze implementierung
void fancy_increment(const struct A * self) { self->cnt+=2; }

// das ist quasi ein singleton mit allen methoden von A
static struct AOperations {
void (*inc)(const struct A *);
void (*dec)(const struct A *);
} AOps = {increment, decrement};

void AConstr(const A * self) {
    self->cnt = 0;
    self->ops = &AOps;
}

int main() {
    struct a,b;
    b->ops->inc = fancy_increment;
    AConstr(&a);
    AConstr(&b);
    a->ops->inc(&a);
    b->ops->inc(&b);
}


virutelle Methode ist einfach ein Wechsel der Implementierung

grüsse, daniel

Autor: daniel (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
A sollte Counter heissen!

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.