Problem mit Klassen

[Nicolas]

Hallo!

Ich habe eine Klasse Test und eine Klasse TestType1 und eine Klasse TestType2 (Kindklassen von Test). In TestType1 hab ich eine Funktion output, die "Type1" auf den Bildschirm schreibt und TestType1 hat auch eine Funktion output, die "Type2" schreibt. Ist es dann eigentlich möglich dass wenn ich die Klasse Test mit Test test(1) initialisere und dann, wenn ich test.output() ausführe dass er die Funktion output von TestType1 ausführt und wenn ich die Klasse Test mit Test test(2) initialisere, daass dann die Funktion output von TestType2 ausgeführt wird.
Ich wollte halt gern wissen ob das geht und wenn ja wie.

Nicolas

[axeljaeger]

output ist virtuell definiert oder was? Du kannst die Originalversion von output aus Test mit

TestType1.Test::output();

aufrufen. Wenn ich was falsch verstanden habe, nochmal nachfragen

[Nicolas]

Eigentlich hab ich das anders gemeint: Wenn ich in meinem Code
Test test(1);
eingebe, soll er die Klasse TestType1 initialisieren und wenn ich in meinem Code
Test test(2);
eingebe, soll er die Klasse TestType2 initialisieren.

[anda_skoa]

Hmm, welcher Pattern wäre das?
Bridge?
Proxy?
Strategy?



class TestIface
{
public:
virtual void output() = 0;
};

class TestTyp1 : public TestIface
{
public:
virtual void output() {
}
};

class TestTyp2 : public TestIface
{
public:
virtual void output() {
}
};

class Test : public TestIface
{
public:
Test(int type) {
switch (type)
{
case 1:
m_impl = new TestType1();
break;
case 2:
m_impl = new TestType2();
break;
default:
m_impl = 0;
break;
}
}

~Test() {
if (m_impl != 0)
delete m_impl;
}

void output() {
if (m_impl != 0)
m_impl->output();
}

private:
TestIface* m_impl;
};


Ciao,
_

[tkortkamp]

Ich hoffe ich habe dich richtig verstanden:


#include <iostream>

class TestTypeDummy
{
public:
TestTypeDummy() {}
~TestTypeDummy() {}

virtual void output() = 0;
};

class TestType1 : public TestTypeDummy
{
public:
TestType1() {}
~TestType1() {}

void output()
{
std::cout << "TestType1" << std::endl;
}
};

class TestType2 : public TestTypeDummy
{
public:
TestType2() {};
~TestType2() {};

void output()
{
std::cout << "TestType2" << std::endl;
}
};

class Test
{
protected:
TestTypeDummy *testType;

public:
Test(int n)
{
if(n == 1)
{
testType = new TestType1();
}
else if(n == 2)
{
testType = new TestType2();
}
}

~Test()
{
if(testType)
{
delete testType;
}
}

void output()
{
testType->output();
}
};

int main(int argc, char **argv)
{
Test t1(1);
Test t2(2);

t1.output();
t2.output();

return 0;
}


EDIT: Ach mist! anda_skoa war wohl schneller ;)
c ya,
Tobias

[Nicolas]

Danke für eure Antworten. Aber eigentlich wollte ich ein Wörterprogramm bauen in das ich dann Wörter eingeben kann und dafür hab ich mir gedacht, ich mache eine Klasse Wort und davon die Unterklassen Substantiv, Adjektiv, Verb. Dann hab ich mir das so gedacht. Das ich die Klasse initialisiere mit:
Wort wort1("Haus", SUBSTANTIV);
Wort wort2("weiß", ADJEKTIV);
Dann hat vielleicht die Klasse Adjektiv die Funktionen steigern und das Substantiv wieder nicht. Dann klappt das mit der von euch beschriebenen Methode doch gar nicht, oder? :confused:
Außerdem werden das doch ziemlich viele Methoden und dann wird das doch auch recht umständlich.

Nicolas

[anda_skoa]

Hmm.

Unsere Beispiel bezogen sich auf die Annahme, dass sich eine Klasse abhängig von einem Parameter anders verhalten soll.

Vielleicht hilft dir das:



class Wort
{
public:
Wort(string wort)
{
m_wort = wort;
}

string wort()
{
return m_wort;
}

protected:
string m_wort;
}

class Adjektiv : public Wort
{
public:
Adjeltiv(string wort) : Wort(wort) {};

void steigern();
}

class Substantiv : public Wort
{
public:
Substantiv(string wort) : Wort(wort) {};
}

class WortErzeuger
{
public:
enum Typ {
Adjektiv,
Substantiv
};

static Wort* erzeugeWort(string wort, Typ typ)
{
switch (typ)
{
case Adjektiv:
return new Adjektiv(wort);
case Substantiv:
return new Substantiv(wort;
}
}
}

int main()
{
Wort* wort1 = WortErzeuger::erzeugeWort("weiß", WortErzeuger::Adjektiv);
}


Ciao,
_

[Nicolas]

Danke für deine Antwort. Ich habe mir auch schon überlegt, es so zu machen wie du, aber ich kann ja auch in der Funktion, in der die Wortklassen erzeugt werden, das erledigen, was du in die Klasse WortErzeuger geschrieben hast.

Nicolas

[anda_skoa]

Original geschrieben von Nicolas
Danke für deine Antwort. Ich habe mir auch schon überlegt, es so zu machen wie du, aber ich kann ja auch in der Funktion, in der die Wortklassen erzeugt werden, das erledigen, was du in die Klasse WortErzeuger geschrieben hast.


Klar!

Das mit der Factory Method (so heißt dieses Entwurfsmuster bzw Design Pattern) ist nur dann besonders praktisch, wenn man an verscheidenen Stellen Objekte erzeugen muß, von denen man die genaue Klasse nicht kennt.

Ciao,
_