Fun-Soft - Programmierforum

Autor

Thread - Seiten: > 1 <

000
20.06.2005, 23:04 Uhr
~Moritz
Gast

Hallo,

ich komme mit der Spezialiserung von Templates nicht weiter.

Ich schreibe eine Klasse DreierVektor, die parametrisiert ist:
template <S>
class DreierVektor{
private:
S _x;
S _y;
S _z;
public:
...
S operator*(DreierVektor other);
...
S x();
...
};

dabei liefert operator* das Skalarprodukt zweier Vektoren.
Soweit so gut, jetzt muss ich aber, wenn S eine komplexe Zahl ist, sprich von complex erbt, die werte komplex konjugieren. D.h. ich brauche irgend eine Möglichkeit, entweder den Operator zu spezialisieren, oder eine Abfrage zu machen, ob S von complex erbt, und dann einen dynamic_cast zu probieren.
Allerdings kriege ich die Syntax nicht hin :( Wie gehts?
Ach ja, dummerweise ist complex selbst auch parametrisiert, und die Lösung sollte also für alle complex<*> funktionieren...

Leider kenn ich mich mit C++ nicht gut genug aus, um das hinzukriegen...

Vielen Dank im Voraus und Grüße.
Moritz

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

001
21.06.2005, 00:21 Uhr
(un)wissender
Niveauwart

Ich behauptet mal, man kann von complex nicht erben.
Ansonsten einen operator* definieren der explizit std::complex nimmt.
Oder gleich die ganze Klasse mit template <> class DreierVektor<std::complex<...> > machen.
Oder template metaprogramming: ein kleine Hilfeklasse die entscheidet, ob ein template parameter std::complex ist. Schau dir mal boost::mpl dazu an.

C++:

#include <complex>
#include <iostream>

template <typename T>
class DreierVektor{
private:
T _x;
T _y;
T _z;
public:
void test()
{
    std::cout << "DreierVektor\n";
}

};

template <typename T>
class DreierVektor<std::complex<T> >
{
private:
std::complex<T> _x;
std::complex<T> _y;
std::complex<T> _z;
public:
void test()
{
    std::cout << "DreierVektor<>\n";
}
};

int main()
{
    DreierVektor<int> i;
    i.test();
    DreierVektor<std::complex<int> > i2;
    i2.test();
}

--
Wer früher stirbt ist länger tot.

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

002
21.06.2005, 16:50 Uhr
~Moritz
Gast

Hallo,

vielen Dank für das Beispiel. Das löst mein Problem, dummerweise muss ich dann aber auch die anderen Member-Funktionen, die nicht speziell für complex sind, neu implementieren...

Aber besser als nix.

Grüße,
Moritz

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

003
21.06.2005, 20:37 Uhr
(un)wissender
Niveauwart

Das musst du nicht.

Du könntest dir boost::mpl ansehen (oder if_<> und equal_ selber schreiben) oder auch ein DreierVektorImpl einführen an das dann nur delegiert wird. Software schreiben heißt kreativ werden.
--
Wer früher stirbt ist länger tot.

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

004
22.06.2005, 07:59 Uhr
doppler

Mir scheint, dass dein Problem ist, keine Funktion zu haben, die alle Typen komplex konjugieren kann. Das kannst du aber selbst machen:

C++:

template<typename T>
class con {
private:
    T _t;
public:
    con(const T& t) {_t=t;};
    operator T() {return _t;};
};

template<typename T>
class con<complex<T> > {
private:
    complex<T> _t;
public:
    con(const complex<T>& t) {_t=conj(t);};
    operator complex<T>() {return _t;};
};

template<typename T>
T conjugate(const T& t) {return con<T>(t);};

Die Klasse con brauche ich, weil mein Compiler keine partiellen Spezialisierungen von Template-Funktionen akzeptiert.

Wenn du jetzt _x*conjugate(other._x)+... im Skalarprodukt zurücklieferst, sollte das sowohl für double als auch für complex<double> gehen. Allerdings mit einigen Laufzeit-Einbußen.

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

Seiten: > 1 < [ C / C++ (ANSI-Standard) ]

ThWBoard 2.73 FloSoft-Edition
© by Paul Baecher & Felix Gonschorek (www.thwboard.de)

Anpassungen des Forums
© by Flo-Soft (www.flo-soft.de)

Sie sind Besucher: