Template ableiten & erweitern & typedef

stimpleton

Hallo!

Ich denke gerade darüber nach die Numerik-Vektor-Klasse von uBLAS ein
wenig anzupassen. (z.B. anderen << Operator). Teoretisch kann ich mir ja was eigenes ableiten und ein paar Sachen überladen:

template<typename T>
class myvector : public boost::numeric::ublas::vector<T>
{};

Und da ich eh' stets double verwende kommt noch:

typedef myvector<double> Vector;

Leider bemeckert das der Compiler. Und selbst wenn er es nicht täte, ist mir nicht ganz wohl bei der Sache.

Was mache ich falsch? Oder ist das generell keine gute Idee?

Vielen Dank,
Stimpy

.filmor

Du machst nichts falsch und es ist imo keine schlechte Idee. Was sagt denn der Compiler? Meiner schluckt das ohne Fehler.

stimpleton

Er meckert, weil er den Konstruktor nicht mehr findet:

Vector x; // das ist OK
Vector x(3); // das nicht

Fehlermeldung:

main.cpp:8: error: no matching function for call to `myvector<double>::myvector(int)'
numeric.h:15: note: candidates are: myvector<double>::myvector()
numeric.h:15: note: myvector<double>::myvector(const myvector<double>&)

miller_m

du musst deinen ctor für einen int parameter überladen

Konrad Rudolph

Konstruktoren werden nicht vererbt. Die muss man also neuschreiben.

stimpleton

Nichts leichter als das. Das wird ja nur durchgereicht an das Original.
Habe ich schon öfter gesehen, war mir nur nie klar, daß die nicht
einfach übernommen werden.

Wieder was Grundlegendes gelernt.
Vielen Dank!

stimpleton

So schluckt's der Compiler (auch ohne typedef):

class Vector : public boost::numeric::ublas::vector<double>
{
public:
	Vector(int size) : boost::numeric::ublas::vector<double>::vector(size) {}
};

Blöd ist nur, daß er jetzt gewisse Konvertierungen offenar nicht mehr hinbekommt.

Vector bb = prod(a,x);

main.cpp:39: error: conversion from `boost::numeric::ublas::matrix_vector_binary1<boost::numeric::ublas::matrix<double, boost::numeric::ublas::basic_row_major<size_t, ptrdiff_t>, boost::numeric::ublas::unbounded_array<double, std::allocator<double> > >, boost::numeric::ublas::vector<double, boost::numeric::ublas::unbounded_array<double, std::allocator<double> > >, boost::numeric::ublas::matrix_vector_prod1<double, double, double> >' to non-scalar type `Vector' requested

Schuld sind wohl die Expression-Templates. Da müßte ich wohl die Konvertierungen auch alle nochmal hinschreiben. Ich schätze mal das ist nicht so ganz trivial...
Das wird mir langsam etwas heftig, oder hat jemand noch einen spontanen Einfall?

LordJaxom

So schwer sind die Konvertierungen nicht, wenn die Ableitung keine eigenen Member hat kannst Du hier auch an die Basis durchreichen:

class Vector : public boost::numeric::ublas::vector<double>
{
public:
    Vector(int size) : boost::numeric::ublas::vector<double>::vector(size) {}
    Vector(const boost::numeric::ublas::vector<double>& rhs) : boost::numeric::ublas::vector<double>::vector(rhs) {}
    Vector& operator=(const boost::numeric::ublas::vector<double>& rhs)
    { boost::numeric::ublas::vector<double>::operator=(rhs); return *this; }
};

stimpleton

Im Prinzip ist es doch vielleicht nur eine Fleißarbeit.
Durch die Template-Zaubereien entstehen noch mehr Klassen, die in Vector
konvertiert werden müssen. (z.B. boost::numeric::ublas::matrix_vector_binary1)
An sich sollte das aber immer nach dem gezeigten Schema laufen.

Da forsche ich morgen mal weiter.
Danke erstmal!

camper

für den anfang reicht möglicherweise auch

class Vector : public boost::numeric::ublas::vector<double>
{
    typedef boost::numeric::ublas::vector<double> base;
public:
    template<typename T>
    Vector(const T& arg) : base(arg) {}
    template<typename T>
    Vector& operator=(const T& rhs)
    {
        base::operator=(rhs);
        return *this;
    }
};

andere funktionen werden ja nicht verdeckt.

stimpleton

Hallo,

die uBLAS Templatezaubereien machen wohl folgendes:

- jede Binäre Operation wird zu einem Objekt erklärt
- wenn jemand das Ergbnis als vector<double> sehen will,
wird der Ausdruck ausgewertet (z.B. im Zuweisungsop.)
- die Umwandlung Operation -> vector<double> ist ein Schritt
und wird daher implizit ausgeführt
- die Umwandlung Operation -> "Mein Vector" hingegen nicht mehr,
da das zwei Schritte sind
- daher glaube ich, daß ich sämtliche Umwandlungen, die uBLAS
vorsieht selbst klöppeln muß (und das sind sicher einige)

Darauf deutet auch die obengenannte Fehlermeldung hin:

error: conversion from `boost::numeric::ublas::matrix_vector_binary1< ...blabla ...>' to non-scalar type `Vector' requested

Oder mir gelingt es, dem Compiler klar zu machen,
daß die zusätzliche Wandlung vom uBLAS vector<double> in meinen 'Vector' kein Problem ist.

Template ableiten &amp; erweitern &amp; typedef

Template ableiten & erweitern & typedef