Herzlich Willkommen, lieber Gast!
  Sie befinden sich hier:

  Forum » C / C++ (WinAPI, Konsole) » dynamisches 2 dimesionales Feld - zuweisungsproblem

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 <
000
26.06.2007, 02:29 Uhr
~pisdez
Gast


hallo leute,

habe schon wieder ein kleines prob und zwar

ich habe zwei dynamische felder (2D) die von typ complex sind (complex.h). wenn ich den wert vom ersten feld dem zweite feld übergebe, wird ein fehler ausgeworfen (debugmodus)
re,im (realteil,immaginaerteil) kann nicht ausgewertet werden.


Code:
template <typename T>
T cmatrix_operations<T>::determinante(T **det_matrix, int l_zeile)
{  
    T det;
    int i=0,k=0,j=0;
        
    if(l_zeile==2){
        det=det_matrix[0][0]*det_matrix[1][1]- det_matrix[1][0]*det_matrix[0][1];
       return det;
    }
    else{
        for(j=l_zeile;j>=0;j--){
           for(i=0;i<=l_zeile-1;i++){
               for(k=0;k<=l_zeile;k++){
                if(k<  j)  
                   untermatrix[i][k]=det_matrix[i][k];    // Hier wirft er mir diesen fehler aus
                if(k>j)
                    untermatrix[i][k-1]=det_matrix[i][k]; //und hier weil der Zugriff
           }                                                         // untermatrix[i][k-1].re
                                                                     // untermatrix[i][k-1].im nicht möglich ist
        }
        det=det+det_matrix[l_zeile][j]*determinante(untermatrix,l_zeile-1);
        
        }
    return det;
    }
}



wie kann ich dieses fehler beheben ?!?


hier ist meine complex.h


Code:
#ifndef _CComplex_
#define  _CComplex_

#include <cstdlib>
using namespace std;
class complex {
        private:
           // Real-, Imaginaerteil
        double re, im;
        
        public:    
          complex () // Konstruktor
          {
            re = 0.0;
            im = 0.0;
          };
            
            friend istream& operator >> (istream& is, complex& z);
            friend ostream& operator << (ostream& os, const complex& z);
            friend complex operator + (complex z1, complex z2);
            friend complex operator * (complex z1, complex z2);
            friend complex operator / (complex z1, complex z2);
            complex operator - (const complex&);
            complex operator += (const complex &z2);
            complex operator = (complex z2);
            complex operator = (complex **z2);
            complex operator = (double );
};


// Einagbe von komplexen Zahlen
istream& operator >> (istream& is, complex& z)
{
    char c[3];
    is >> z.re >> c[0] >> c[1] >> c[2];    
    is >> z.im;
    
    return is;
}

// Ausgabe von komplexen Zahlen
ostream& operator << (ostream& os, const complex& z)
{    os << z.re << "+i*" << z.im;
    return os;
}

// Operatorfunktion +, Addition komplexer Zahlen
complex operator + (complex z1, complex z2)
{
    complex erg;

    erg.re=z1.re+z2.re;
    erg.im=z1.im+z2.im;

    return erg;
}


// Operatorfunktion -, Subtraktion komplexer Zahlen
complex complex::operator - (const complex &zahl2)
{

    
    complex erg;
    erg.re = this->re - zahl2.re;
    erg.im = this->im - zahl2.im;



    return erg;
}

// Operatorfunktion *, Multiplikation komplexer Zahlen, friend
complex operator * (complex z1, complex z2)
{
    complex erg;

    erg.re=z1.re*z2.re-z1.im*z2.im;
    erg.im=z1.re*z2.im+z2.re*z1.im;

    return erg;
}

// Operatorfunktion /, Division komplexer Zahlen, friend
complex operator / (complex z1, complex z2)
{
    complex erg;
    float betrag;

    betrag=z2.re*z2.re+z2.im*z2.im;
    erg.re=(z1.re*z2.re+z1.im*z2.im)/betrag;
    erg.im=(z1.im*z2.re-z1.re*z2.im)/betrag;

    return erg;
}

// Operatorfunktion +=
complex complex::operator += (const complex &z2)
{
    re=re+z2.re;
    im=im+z2.im;

    return *this;
}

// Operatorfunktion =, Zuweisung komplexer Zahlen
complex complex::operator = (complex z2)
{    
    re=z2.re;
    im=z2.im;

    return *this;
}


// Operatorfunktion =, Zuweisung komplexer Zahlen
complex complex::operator = (complex **z2)
{    
    re=z2[1][1].re;
    im=z2[1][1].im;

    return *this;
}

// Operatorfunktion =, Zuweisung komplexer Zahlen
complex complex::operator = (double x)
{    
    re=x;
    im=x;

    return *this;
}


#endif /*_CComplex_H_*/




danke vorraus
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
001
26.06.2007, 10:15 Uhr
Kest
saint


Hi!

Was für 'n Compiler haste denn?

Außerdem sollten die Zuweisungsoperatoren eine Referenz auf sich zurückgeben. (Ob das Objekt an sich selbst zugewiesen wird, sollten auch geprüft werden.)
--
Wenn man einen Hufschlag hört, sollte man >Pferd< denken und nicht >Zebra<.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
Seiten: > 1 <     [ C / C++ (WinAPI, Konsole) ]  


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: