Objekt-Modul mit dynamischem Parameter

tollelege

Hallo zusammen,

in folgendem Szenario bin ich mir etwas unschlüssig, wie ich das Programmdesign gestalten soll, und wäre daher sehr dankbar für Eure Vorschläge.

Hier der Zusammenhang:

Das eigentliche Projekt soll eine bestimmte Objektklasse benutzen, die in eigenen Dateien deklariert und implementiert wird. Sie soll auch für andere Projekte zur Verfügung stehen.
Das Verhalten dieser Klasse (genauer, einige ihrer Methoden) hängen aber von (skalaren) Parametern ab.
Diese Parameter werden sich nicht nur zwischen verschiedenen Projekten unterscheiden, sonder können und sollen sich sogar noch zur Laufzeit ändern.

Daher ist mir nicht ganz klar, in welcher Form an welcher Stelle diese Parameter leben sollen.

Ein (Fast-)Minimalbeispiel für so ein Klassenmodul, das die Sache etwas klarer machen dürfte:

// die Parameter, mit denen ich nicht weiß wohin, zu Beginn:
bool NIMMS_GENAU = false;
double TOLERANZ = 5;

class ungefaehrZahl {
    private:
        double zahl;
    public:
        bool operator< (const ungefaehrZahl b) const {
            if (NIMMS_GENAU) return zahl < b.zahl;
            return zahl < b.zahl + TOLERANZ;
        };
};

Die hier dargestellte Variante, die Parameter wie Konstanten in der Kopfdatei zu definieren, taugt natürlich nicht, da man außerhalb in Programmen, die diese Datei nur einbinden, darauf keinen Zugriff hat.

Die naheliegende Variante ist natürlich, alle Parameter beim Erschaffen einer Klasseninstanz zu initialisieren (über Argumente des Kostruktors oder, in deren Abwesenheit, mit Vorgabewerten). Dann müsste man zumindest neue Klassen verwenden, wenn man die Parameter ändern möchte.
Flexibler in der Verwendung, aber umständlicher beim Programmieren wäre es, bei allen Funktionen diese Argumente zu übergeben (auch ggf. ersetzt durch Vorgabewerte). Das ist insbesodere bei Operatoren wie oben unschön.

Gibt es eine Möglichkeit, in der Headerdatei zu sagen "es wird noch einer kommen, der diese Variable setzt, vertrau mir" und in einer Quelldatei, die diese inkludiert, das auch zu tun? Das wäre so etwas wie das Ideal, das ich mir vorstellen würde.

Ich freue mich auf Eure Anregungen!

Mechanics

Es kommt natürlich drauf an, was das alles für Parameter sind, wie oft und von wem sie geändert werden usw.
Wenn das wirklich "globale" Parameter sind, die von jeder Instanz deiner Klassen berücksichtigt werden müssen, könnte man sie schon global machen, vielleicht mit einer zusätzlichen Klasse, mit der man sie überschreiben kann. z.B. so:

GlobalParamModifier(true, 6); //NIMMS_GENAU und TOLERANZ wird überschrieben
//rechne irgendwas
//im Destruktor setzt GlobalParamModifier die Parameter wieder auf die vorherigen Werte zurück

Den Parametersatz könnte man dann evtl. auch pro Thread verwalten.

Die Parameter würden sich dann aber auch auf die bereits bestehenden Instanzen deiner Klassen auswirken. Ob du das willst, musst du selber wissen.

minastaros

Statische Klassenvariable, dann bleibt es in der "Familie" und ist dennoch für alle Instanzen gültig.
Die Operator-Überladung ist zwar fragwürdig (was erwarten die Benutzer von einem <-Operator? Es gibt nur ein "kleiner", daher keine Überraschungen!), aber zumindest zu der Sache mit den Variablen:

class ungefaehrZahl {
    private:
        const double TOLERANZ = 5;
        double zahl;

    public:
        static bool isGenau;

        bool operator< (const ungefaehrZahl b) const {
            if (isGenau) return zahl < b.zahl;
            return zahl < b.zahl + TOLERANZ;
        };
};

(isGenau im cpp initialisieren)

Wenn es noch mehr Klassen gibt, die nach den gleichen Toleranz-Pfeifen tanzen sollen: Basisklasse, vielleicht auch namespace

Oder wie Machanics sagt, ein globales Objekt GlobalParamModifier , dieses und ungefaehrZahl in einen gleichen namespace bringen (z.B. namespace FuzzyCalc). In der Header-Datei, in dem die Klasse von GlobalParamModifier deklariert wird, wird die Instanz mit extern bekanntgegeben. Bindet dein Code diese Header ein, "weiß" er über die globalen Einstellungen bescheid.

tollelege

Das klingt schon sehr interesant, ich komme aber noch nicht ganz damit klar.

@minastaros, Deinen ersten Vorschlag (konstante Objekteigenschaft) fand ich interessant. Dann kann ich ihn aber auch tatsächlich nicht mehr im eigentlichen Programm ändern, wie ich es vorhatte.

@Mechanics (und minastaros), ich glaube, den Vorschlag mit der ändernden Klasse kann ich nicht ganz nachvollziehen - egal wie ich es aufbaue, es wird nicht richtig konsistent. Mir ist anhand Deines Beitrags allerdings klar geworden, dass es funktionieren könnte mit der Haupt-Quelldatei wie folgt:

bool NIMMS_GENAU = false;
double TOLERANZ = 5;

#include "ungefaehr_Zahl.h"

...

... und dann könnte man die Parameter auch noch im weiteren Code-Verlauf ändern, und sie wirken sich auf alle Instanzen der betroffenen Klassen aus.

Die Idee, diese Abänderung zu kapseln, leuchtet mir auch noch ein. Aber die Parameter selbst müssten weiterhin auf globaler Ebene (also in der oben skizzierten Haupt-Quelldatei) deklariert werden? Und dann würde ich die header-Datei, in der ParameterAendern deklariert wird, dort einbinden?
Und in "ungefaehrZahl.h/.cpp" verwende ich weiterhin einfach die globalen Variablennamen?

tollelege

Hättet Ihr noch eine Erläuterung für mich?

Ich verstehe wirklich nicht genau, welcher Code in welchen Kontext gehört bzw. wie die beiden Klassen konkret gebaut werden sollte. Könntet Ihr bitte noch eine Code-Skizze darstellen?

Vielen Dank!

c-freak83

Das käme auch mir recht gelegen.