Diese Seite ist unverschlüsselt! Um sicherzustellen, das Ihr Passwort nicht ausgelesen werden kann, sollten Sie auf die verschlüsselte Seite wechseln!

    Herzlich Willkommen, lieber Gast!
  Sie befinden sich hier:

  Forum » C / C++ (ANSI-Standard) » vector
Forum | Hilfe | Team | Links | Impressum | > Suche < | Mitglieder | Registrieren | Einloggen
  Quicklinks: MSDN-Online || STL || clib Reference Grundlagen || Literatur || E-Books || Zubehör || > F.A.Q. < || Downloads   

Autor Thread - Seiten: [ 1 ] [ 2 ] > 3 < [ 4 ] [ 5 ] [ 6 ]
020
25.09.2003, 12:02 Uhr
Windalf
Der wo fast so viele Posts wie FloSoft...
(Operator)


@beefy
nein mir ging es nicht darum es in zwei dateien zu trennen sondern das ganze wollte ich schon in eine Datei packen, nur wollte ich erst so wie gewohnt die Klasse deklarieren und da runter erst implementieren, weil mir das sonst zu unübersichtlich wurde. Ich hoffe jetzt ist klar was ich gemeint habe.
--
...fleißig wie zwei Weißbrote
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
021
25.09.2003, 12:19 Uhr
Windalf
Der wo fast so viele Posts wie FloSoft...
(Operator)


das z.b. habe ich mir zum matrix addieren geschrieben
funzt soweit auch

C++:
template <class Typ> CMatrix<Typ> CMatrix<Typ>::operator+(CMatrix& m){
    CMatrix rv(*this);
    for(int j=0;j<matrix[0].size();++j)
            for(int i=0;i<matrix.size();++i)
                rv[i][j]+=m[i][j];
    return rv;
}


Wie kann ich jetzt zur compilzeit abfangen, wenn zwei matrizen unterschiedlicher dimension addiert werden sollen, was ja nicht geht
--
...fleißig wie zwei Weißbrote
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
022
25.09.2003, 12:31 Uhr
0xdeadbeef
Gott
(Operator)


Dann musst du CMatrix auch die Dimension als Parameter mitgeben. Sowas in der Art:

C++:
template <typename data_t, int dim> class matrix
{
protected:
    data_t feld[dim][dim];
public:
    data_t &operator()(int, int);
}

template <typename data_t, int dim> data_t matrix<data_t, dim>::operator()(int x, int y) { return feld[x][y]; }

template <typename data_t, int dim>
matrix<data_t, dim> matrix<data_t, dim>::operator+(matrix<data_t, int> &m1, matrix<data_t, int> &m2) {
    matrix<data_t, dim> ret;
    for(int i = 0; i < dim; ++i)
        for(int j = 0; j < dim; ++i)
            ret[i][j] = m1[i][j] + m2[i][j];
    return ret;
}

//...

matrix<double, 3> meine_matrix; //<-- eine 3x3 double-Matrix

--
Einfachheit ist Voraussetzung für Zuverlässigkeit.
-- Edsger Wybe Dijkstra
Dieser Post wurde am 25.09.2003 um 12:32 Uhr von 0xdeadbeef editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
023
25.09.2003, 12:41 Uhr
Windalf
Der wo fast so viele Posts wie FloSoft...
(Operator)


so ein mist
das wollte ich erst so machen und dann habe ich mich entscheiden die dimensionen doch erst im konstruktor zu übergeben
na gut dann werd ich das noch ändern
was gibts denn sonst noch so an meiner bisherigen implementierung auszusetzen (ausser das kommentare fehlen)

C++:
#include <iostream>
#include <vector>

template <class Typ> class CMatrix{

    private:
        std::vector<std::vector<Typ> > matrix;

    public:
        CMatrix(int zeilen,int spalten,Typ value=0);
        CMatrix(int zeilen,int spalten,Typ* values);
        CMatrix(int zeilen,int spalten,Typ** values);
        CMatrix(std::vector<std::vector<Typ> > m);
        CMatrix(CMatrix&);        


        void operator=(CMatrix& m);
        bool operator==(CMatrix& m);
        std::vector<Typ>& operator[](int& index);
        
        CMatrix operator!();
    //    CMatrix operator~();

        CMatrix operator+(CMatrix& m);
        CMatrix operator-(CMatrix& m);
        CMatrix operator*(Typ& s);
        CMatrix operator*(CMatrix& m);
        CMatrix operator/(Typ& s);
        
        void Matrix_ausgeben();

};


template <class Typ>CMatrix<Typ>::CMatrix(int zeilen,int spalten,Typ value):matrix(spalten,std::vector<Typ>(zeilen)){
    for(int j=0;j<zeilen;++j)
        for(int i=0;i<spalten;++i)
            matrix[i][j]=value;
}

template <class Typ>CMatrix<Typ>::CMatrix(int zeilen,int spalten,Typ* values):matrix(spalten,std::vector<Typ>(zeilen)){
    for(int j=0;j<zeilen;++j)
        for(int i=0;i<spalten;++i)
            matrix[i][j]=values[i+j*x];
}

template <class Typ>CMatrix<Typ>::CMatrix(int zeilen,int spalten,Typ** values):matrix(spalten,std::vector<Typ>(zeilen)){
    for(int j=0;j<zeilen;++j)
        for(int i=0;i<spalten;++i)
            matrix[i][j]=values[i][j];
}

template <class Typ>CMatrix<Typ>::CMatrix(std::vector<std::vector<Typ> > m):matrix(m){}

template <class Typ>CMatrix<Typ>::CMatrix(CMatrix& m):matrix(m.matrix){}


template <class Typ> void CMatrix<Typ>::operator=(CMatrix& m){
    if(matrix.size()!=m.matrix.size() || matrix[0].size()!=m.matrix[0].size()) return;
    for(int j=0;j<matrix[0].size();++j)
            for(int i=0;i<matrix.size();++i)
                matrix[i][j]=m[i][j];
}

template <class Typ> bool CMatrix<Typ>::operator==(CMatrix& m){
    if(matrix.size()!=m.matrix.size() || matrix[0].size()!=m.matrix[0].size()) return false;
    for(int j=0;j<matrix[0].size();++j)
            for(int i=0;i<matrix.size();++i)
                if(matrix[i][j]!=m[i][j])return false;
    return true;
}

template <class Typ> std::vector<Typ>& CMatrix<Typ>::operator[](int& index){
    return matrix[index];
}

template <class Typ> CMatrix<Typ> CMatrix<Typ>::operator!(){
    CMatrix rv(matrix.size(),matrix[0].size());
    for(int j=0;j<matrix[0].size();++j)
        for(int i=0;i<matrix.size();++i)
                rv[j][i]=matrix[i][j];
    return rv;
}


template <class Typ> CMatrix<Typ> CMatrix<Typ>::operator+(CMatrix& m){
    CMatrix rv(*this);
    for(int j=0;j<matrix[0].size();++j)
            for(int i=0;i<matrix.size();++i)
                rv[i][j]+=m[i][j];
    return rv;
}

template <class Typ> CMatrix<Typ> CMatrix<Typ>::operator-(CMatrix& m){
    CMatrix rv(*this);
    for(int j=0;j<matrix[0].size();++j)
            for(int i=0;i<matrix.size();++i)
                rv[i][j]-=m[i][j];
    return rv;
}

template <class Typ> CMatrix<Typ> CMatrix<Typ>::operator*(Typ& s){
    CMatrix rv(*this);
    for(int j=0;j<matrix[0].size();++j)
            for(int i=0;i<matrix.size();++i)
                rv[i][j]*=s;
    return rv;
}



template <class Typ> CMatrix<Typ> CMatrix<Typ>::operator*(CMatrix& m){
    CMatrix rv(matrix[0].size(),m.matrix.size());
    for(int j=0;j<rv.matrix[0].size();++j)
        for(int i=0;i<rv.matrix.size();++i)
            for(int h=0;h<matrix.size();++h)
                rv[i][j]+=matrix[h][j]*m[i][h];
    return rv;
}



template <class Typ> CMatrix<Typ> CMatrix<Typ>::operator/(Typ& s){
    return CMatrix(*this)*(1.0/s);
}


template <class Typ> void CMatrix<Typ>::Matrix_ausgeben(){
    std::cout<<std::endl;
    for(int j=0;j<matrix[0].size();++j,std::cout<<std::endl)
        for(int i=0;i<matrix.size();++i)
            std::cout<<matrix[i][j]<<"\t";
    std::cout<<std::endl;
}

--
...fleißig wie zwei Weißbrote
Dieser Post wurde am 25.09.2003 um 12:44 Uhr von Windalf editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
024
25.09.2003, 13:49 Uhr
Windalf
Der wo fast so viele Posts wie FloSoft...
(Operator)


und noch ne Frage
was ist der Unterschied zwischen CDU und SPD ne doch nicht
also was ist der Unterschied class und typename?
--
...fleißig wie zwei Weißbrote
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
025
25.09.2003, 13:57 Uhr
0xdeadbeef
Gott
(Operator)


Ich hab jetzt nicht das ganze Programm gedebuggt, aber es sieht soweit OK aus. Was die Dimensionen als Template-Parameter angeht - wenn du rechteckige Matrizen hast, kriegst du dabei Probleme mit den Zuweisungsoperatoren (*= zum Beispiel), es hängt also ein bisschen davon ab, was du machen willst.

Unterschied zwischen CDU und SPD: Kein allzugroßer mehr, nachdem die SPD den demokratischen Sozialismus streichen will. Derzeit einzige vernünftige Alternative: grün.

Unterschied zwischen class und typename: typename sieht professioneller aus.
--
Einfachheit ist Voraussetzung für Zuverlässigkeit.
-- Edsger Wybe Dijkstra
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
026
25.09.2003, 14:31 Uhr
virtual
Sexiest Bit alive
(Operator)


@Windalf
www.fun-soft.de/showtopic.php?threadid=3908&post_start=10
--
Gruß, virtual
Quote of the Month
Ich eß' nur was ein Gesicht hat (Creme 21)
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
027
25.09.2003, 14:35 Uhr
Windalf
Der wo fast so viele Posts wie FloSoft...
(Operator)


wie sieht es denn von der perfomance aus wenn man vector benutzt?
geht die gegenüber einem normalen Array total in den Keller?


sollte eigentlich ein dummer witz werden, jetzt habe ich schon wieder ein offtopic draus gemacht. Naja ist ja mal was anderes wenn jeder hier seine politische Meinung rumposaunt.

Von Grün halte ich nichts mehr seit dem die die Atomkraftwerke abbauen, damit dann die Fehlkapazitäten dann durch den Neubau von unsicheren Atomkraftwerken im Ostblock gedeckt werden. Starker beitrag für die Umwelt. Den einzigen Vorteil den ich dabei habe ist das ich im Fall des Falles nicht ganz so in der Nähe bin, dafür ist der GAU allerdings wahrscheinlicher geworden
Einziger Vorteil der Methode: Arbeitsplätze werden im Ausland beschafft und bei uns vernichtet.
Bei fast allem was die machen sind die Ideen gut aber die Umsetzungen schiessen total daneben, so dass am Ende nur Arbeitsplätze vernichtet werden und fast nichts für die Umwelt getan wird.

andere Frage:Seit wann geht ein Gott ein Souverän wählen (und erkennt ihn damit auch an)?

@virtual
hätte ich vielleicht mal nach suchen sollen. war wohl zu faul. danke
--
...fleißig wie zwei Weißbrote
Dieser Post wurde am 25.09.2003 um 14:36 Uhr von Windalf editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
028
25.09.2003, 14:43 Uhr
virtual
Sexiest Bit alive
(Operator)



Zitat:
Windalf postete
wie sieht es denn von der perfomance aus wenn man vector benutzt?
geht die gegenüber einem normalen Array total in den Keller?

Kommt drauf an, Du solltest grade bei Vectoren mit reserve arbeiten, wenn Du dîe größe des benötigten Speichers bereits kennst.

Bei deinem Speziellen Matrix Teil würde ich dir eh empfehlen, nicht einfach std::vector zu verwenden, sondern gleich ein std::valarray.
--
Gruß, virtual
Quote of the Month
Ich eß' nur was ein Gesicht hat (Creme 21)
Dieser Post wurde am 25.09.2003 um 14:43 Uhr von virtual editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
029
25.09.2003, 14:45 Uhr
0xdeadbeef
Gott
(Operator)


Die Performance dürfte unter einem vector eigentlich nicht allzusehr leiden, wobei es natürlich darauf ankommt, wie du ihn benutzt.

Was Politik angeht: Ich kann dir soweit zustimmen, dass in der momentanen Parteienlandschaft keiner den wirklich brillianten Masterplan hat. Aber was willst du den machen? Die CDU erzählte im letzten BuTaWaKa was davon, Ausländer auf Verdacht abzuschieben -> unwählbar aus moralischen Gründen. Die SPD will das S aus dem Namen streichen und macht sich damit selbst überflüssig. Die FDP ist mehr eine Lobby als eine Partei, die PDS ist genau das andere Extrem - sie hat vom Wirtschaftlichen nicht den geringsten blassen Schimmer. Was bleibt dann noch, wenn wir mal so realistisch sind und die "Sonstigen", die eh in kein Gremium Einzug nehmen, rauslassen?
--
Einfachheit ist Voraussetzung für Zuverlässigkeit.
-- Edsger Wybe Dijkstra
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
Seiten: [ 1 ] [ 2 ] > 3 < [ 4 ] [ 5 ] [ 6 ]     [ 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: