ich steh grad irgendwie auf der Leitung... Es geht um Konstruktoren.

Ich habe ein Programm geschrieben, das ein Textfile erzeugt und innerhalb eines bereits bestehenden Programms aufgerufen wird.

Jetzt kam aber noch ein weiteres Programm dazu, das eigentlich ähnliche Funktionen hat und nun gibt es einiges doppelt.

Jetzt wollte ich die Initialisierung mit Hilfe von Konstruktoren erledigen, so dass es für beide Programme funktioniert, aber nur einmal aufgerufen werden muss. Und genau da liegt das Problem. Irgendwie komm ich mit den Konstruktoren nicht wirklich klar.

Hier ein Beispiel:

// Meine Klasse
class Beispiel
{
public:
Beispiel(); // Constructor
~Beispiel(); // Destructor

void testfunktion(string kreuz, int i, string gitter, string typ);
void weitereFunktion(string kreuz, string quer, string verzeichnis, int n, int i, string gitter, string typ, string name);
};

// Mein 1. Programm:
Beispiel::Beispiel()
{ }

Beispiel::~ Beispiel()
{ }

void Beispiel::testfunktion(string kreuz, int i, string gitter, string typ) {

    Beispiel Testfall;

    Testfall.kreuz = kreuz;
    Testfall.gitter = gitter;
    Testfall.aktiv = i + 1;
    Testfall.typ = typ;

    Testfall.eins = geteins();
    Testfall.zwei = getzwei();
    Testfall.drei = getdrei();

    Testfall.vier = Testfall.eins / Testfall.zwei;
    Testfall.fuenf = Testfall.zwei / Testfall.drei;
    Testfall.sechs = Testfall.vier * Testfall.fuenf;

    Testfall.h = getH(i,0);
}

// Wird folgendermaßen in der main-Funktion aufgerufen:
Beispiel ABCD;
ABCD.testfunktion(kreuz, i, gitter, typ);

// Mein 2. Programm:
Beispiel::Beispiel()
{ }

Beispiel::~ Beispiel()
{ }

void Beispiel::weitereFunktion(string kreuz, string quer, string verzeichnis, int n, int i, string gitter, string typ, string name) {

    Beispiel Test;
    Test.kreuz = kreuz;
    Test.quer = quer;
    Test.verzeichnis = verzeichnis;
    Test.ecken = n;
    Test.gitter = gitter;
    Test.aktiv = i + 1;
    Test.typ = typ;
    Test.name = name;

    Test.eins = geteins();
    Test.zwei = getzwei();
    Test.drei = getdrei();

    Test.vier = Test.eins / Test.zwei;
    Test.fuenf = Test.zwei / Test.drei;
    Test.sechs = Test.vier * Test.fuenf;

    Test.h = getH(i,0);
}

wird folgendermaßen in der main-Funktion aufgerufen:
Beispiel ABCD;
CFXpre.weitereFunktion(kreuz, quer, verzeichnis, n, i, gitter, typ, name);

Die Beispiele zeigen jetzt jeweils nur Ausschnitte mit den betreffenden Teilen.
In den beiden Programmen kommt also einiges doppelt vor, lediglich bei dem 2. Programm werden mehr Parameter übergeben und initialisiert.
Wenn ich das Ganze jetzt mit Konstruktoren realisieren will, dann muss es doch irgendwie so gehen:

In der Klasse brauche ich also zusätzlich zum Default-Konstruktor mehr Konstruktoren:

Beispiel();
Beispiel(string kreuz, int i, string gitter, string typ);
Beispiel(string kreuz, string quer, string verzeichnis, int n, int i, string gitter, string typ, string name);

Dann stünde ja in meinem 1. Programm folgendes:

Beispiel::Beispiel() {
    Beispiel::eins = geteins();
    Beispiel::zwei = getzwei();
    Beispiel::drei = getdrei();

    Beispiel::vier = Beispiel::eins / Beispiel::zwei;
    Beispiel::fuenf = Beispiel::zwei / Beispiel::drei;
    Beispiel::sechs = Beispiel::vier * Beispiel::fuenf;

    Beispiel::h = getH(i,0);
}

Beispiel::Beispiel(string kreuz, int i, string gitter, string typ) {
    Beispiel::kreuz = kreuz;
    Beispiel::gitter = gitter;
    Beispiel::aktiv = i + 1;
    Beispiel::typ = typ;
}

Beispiel::~ Beispiel()
{ }

void Beispiel::testfunktion() {
// hier stehen jetzt also nur noch die direkten Aufrufe, um das Textfile zu erzeugen
}

Jetzt müssen dann aber doch irgendwie mehrere Objekte beim Aufruf erzeugt werden, oder? Und wie kann das im 2. Programm dann auch verwendet werden?

Vielleicht könnt Ihr mir ja etwas auf die Sprünge helfen.
Danke!

(wobei - innerhalb einer "Beispiel"-Methode ein weiteres Objekt vom Typ "Beispiel" anzulegen, ist in den meisten Fällen nicht notwendig ;))

Ich habe 2 Funktionen in ein bestehendes Programm integriert.
Es läuft alles, aber jetzt habe ich gesehen, dass einiges in den beiden Funktionen doppelt vorkommt. In beiden Funktionen werden eben am Anfang einige Variablen initialisiert.

Ich möchte jetzt also, dass bei den doppelten Initialisierungen nur noch eine übrig bleibt. Funktioniert das denn nicht mit einem Konstruktor?

Das Problem ist halt nur, dass die Parameter, die den Funktionen vom Programm übergeben werden, unterschiedlich sind. D.h. ich brauche auch mehrere verschiedene Konstruktoren, oder?

Wenn ich in der einen Funktionen jetzt einen Konstruktor erstelle, der die Variablen initialisiert, dann muss ich genau diesen Konstruktor ja auch in der anderen Funktion aufrufen, aber irgendwie will das nicht so recht funktionieren...

Wie funktioniert das denn prinzipiell mit mehreren Konstruktoren in verschiedenen Funktionen...?

1. Du Hast zwei Programme, welche ähnliche Funktionalitäten aufweisen.
2. Diese beiden Programme sollen daher auf eine gemeinsame Code-Basis (ich nenne das mal "Module") aufbauen, welche die von beiden Programmen geteilten Funktionalitäten bereitstellt.

Ich sehe hier noch keinen Grund, welcher Klassen rechtfertigte. Es ist durchaus möglich, Funktionalitäten in Klassen zu pressen (via statischer Methoden / Klassenmethoden).

Es macht meines Erachtens jedoch keinen Sinn, die (unterschiedlichen) Funktionen aus (unterschiedlichen) Programmen in einer Klasse bereitzustellen.

Mein Lösungsansatz wäre:
Analysieren, welche Funktionalitäten von beiden Programmen geteilt werden. Diese können dann in einer Klasse gepresst werden (alternativ "tun" es auch freidefinierte Funktionen ggf. in einem Namespace).

Benötigt nun ein einzelnes Programm alternative oder geänderte Funktionalitäten, kann es die vorher definierte Klasse ableiten (Stichwort: Vererbung) und die neu benötigten Funktionalitäten hinzufügen oder redefinieren.

Grüße...

Heiko