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) » dynamisches 2d-Array
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 ]
010
08.09.2011, 11:20 Uhr
FloSoft
Medialer Over-Flow
(Administrator)



Zitat:
mein code ist viel zu lang um ihn hier zu posten.


oder poste ihn nach nopaste.info und poste hier nur den link
--
class God : public ChuckNorris { };
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
011
08.09.2011, 11:45 Uhr
~leiti7
Gast


habe einen Fehler gefunden:

und zwar hab ich etwas so geschrieben:

float deltawinkel = 18/206;

das Problem ist, dass nach dieser Zeile auf der Variable deltawinkel immer
noch der Wert 0.0000 steht. wie kann das sein??

mfg
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
012
08.09.2011, 12:11 Uhr
0xdeadbeef
Gott
(Operator)


Integer-Division. int geteilt durch int gibt wieder int, und sowohl 18 als auch 206 sind int. Du musst mindestens eine der beiden Zahlen in ein Fließkommaliteral umwandeln, beispielsweise

C++:
double deltawinkel = 18.0 / 206;

@Lensflare: Eine Bereichsprüfung in beiden Dimensionen könnte man erreichen, indem man statt eines nackten Zeigers ein Proxy-Objekt zurückgibt, das seinen eigenen operator[] überlädt und darin die Prüfung durchführt. In diesem speziellen Fall finde ich die Idee aber eigentlich ziemlich unschön. Wir reden hier ja nicht über Java.
--
Einfachheit ist Voraussetzung für Zuverlässigkeit.
-- Edsger Wybe Dijkstra
Dieser Post wurde am 08.09.2011 um 12:13 Uhr von 0xdeadbeef editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
013
08.09.2011, 12:57 Uhr
ao

(Operator)



Zitat:
Du musst mindestens eine der beiden Zahlen in ein Fließkommaliteral umwandeln ...

... und wenn es sich in Wahrheit nicht um Literale, sondern um Variablen handelt, dann geht das so:

C++:
int zaehler = 18;
int nenner = 206;
double deltawinkel = (double) zaehler / (double) nenner;



Der Ausdruck "(double) zaehler" erzeugt eine temporäre namenlose Variable (*) vom Typ double mit dem Wert, der dem Wert von zaehler entspricht oder am nächsten kommt. Da der "/"-Operator hier auf Fließkomma-Objekte angewendet wird, wird auch eine Fließkomma-Division erzeugt.

Wobei es nach den Regeln der Sprache auch reicht, eine der beiden Variablen explizit umzuwandeln. Die andere wird dann automatisch vom Compiler angepasst, weil der /-Operator nur mit gleichen Typen auf beiden Seiten arbeitet.

Außer bei Überladung, aber das ist wieder ein anderes Thema.

(*) "Temporäre namenlose Variable" - das muss nicht heißen, dass hierfür Speicher belegt wird. Der Wert kann auch in einem CPU-Register zusammengebaut, für diesen einen Zweck verwendet und danach sofort wieder vergessen werden.
Dieser Post wurde am 08.09.2011 um 13:00 Uhr von ao editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
014
08.09.2011, 16:26 Uhr
Lensflare
Zitat von 0xdeadbeef:
@Lensflare: Eine Bereichsprüfung in beiden Dimensionen könnte man erreichen, indem man statt eines nackten Zeigers ein Proxy-Objekt zurückgibt, das seinen eigenen operator[] überlädt und darin die Prüfung durchführt. In diesem speziellen Fall finde ich die Idee aber eigentlich ziemlich unschön. Wir reden hier ja nicht über Java.


Das mit dem proxy objekt werde ich mal ausprobieren.
Ich habe es wie bei Java gemacht, das stimmt. Ich bin mir auch bewusst dass es meistens unnötig Performanz raubt, aber ich verwende diese Klasse nur in sehr speziellen Fällen, wenn Performanz keine Rolle spielt.

Boost.Multi-Array werde ich mir bei gelegenheit auch anschauen.
--
Wenn das Gehirn so einfach wäre, dass wir es verstehen könnten, wären wir so einfach, dass wir es nicht verstehen könnten.
(Emerson Pugh Trost)
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
015
12.09.2011, 09:13 Uhr
~leiti7
Gast



Zitat von FloSoft:

char **array;
array = new char*[1000]; // erste dimension
for(int i = 0; i < 1000; ++i)
{
array[i] = new char[2000]; // zweite dimension
}

// zugriff
array[x][y]

// aufräumen
for(int i = 0; i < 1000; ++i)
{
delete[] array[i];
}
delete[] array;


Bin immer noch beim rätseln wo mein felhler ist.
diese Code sollte doch mit float werten genauso funktionieren wie mit char oder?

hab das problem, dass ab einer gewissen anzahl von werten, die auf ein array geschrieben werden, sie die werte der verschiedenen arrays zu vermischen beginnen. Also werden zb. die werte die in das array1 geschrieben werden sollen, zuerst richtigerweise auf dieses geschrieben, dann aber ab einer gewissen anzahl ebenfalls auf das array2 geschrieben. ich schließe daraus, dass sich der speicherbereich der 2 arrays überlappt. aber wieso ist das so? und wie könnte ich den fehler beheben?

aja und wenn ich die initialisierung der arrays um einige zeilen verschiebe dann verschiebt sich auch dia anzahl der werte ab der die werte auf beide arrays gespeichert werden.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
016
12.09.2011, 10:53 Uhr
ao

(Operator)



Zitat:
ich schließe daraus, dass sich der speicherbereich der 2 arrays überlappt. aber wieso ist das so?


Wenn du es richtig machst, passiert das nicht, es muss also ein Fehler sein.

Vermute ich richtig, dass das Fragment da oben nicht der echte Code ist, der Probleme macht, sondern nur etwas, was du für ein Beispiel hältst?

Wenn der Originalcode zu lang ist, dann poste doch bitte mal zwei Auszüge:

1. Die Stelle, wo die Arrays angelegt werden, also die Schleife mit dem "new" drin. Und falls die angelegte Länge (new char [IRGENDWAS]) nicht als Zahlenliteral im Code steht, brauchen wir auch diesen Wert.

2. Die Stelle, die die Daten vermischt, mit dem umgebenden Schleifencode und Angabe der Schleifengrenzen und, wenn möglich, den Schleifenindex, bei dem die Vermischung beginnt, wenigstens ungefähr.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
017
12.09.2011, 11:46 Uhr
~leit7
Gast


bin grade drauf gekommen dass die 2 arrays die hauptsächlich ihre werte vertauschen eig 1d-arrays sind. allerdings ist das bevor ich die 2d arrays dynamisiert habe nicht passiert.
hier poste ich mal einige ausschnitte meines codes. vll kann mir jetzt jemand weiterhelfen.

Das einlesen der werte aus einer datei:

C++:
void einlesen(void)
{
    i=0;

    strcpy(pfad,"H:\\Leitgeb\\p3_N400_250711.in");

    inFile = fopen(pfad,"r");

    if( !inFile )
    {
        printf( "konnte Datei %s nicht öffnen!\n \n",pfad );

        quelleeingeben();

    }

    while( fgets(Line,sizeof(Line),inFile))    // Inputfile wird zeilenweise eingelesen
    {
        


        

        zerl = strtok(Line,"    ");        // Die als ganzer String eingelesene Zeile wird bei jedem Tabulator in einzelne
                                        // Strings zerlegt.
        j=0;                            // Nun steht in "zerl" ein Teil der zerlegten Zeile

        while(zerl!=0)
        {
        
            

            if(!isdigit(zerl[0]))        // hier wird der Teil der gerade in "zerl" steht überpüft ob es sich um
            {                            // eine Zahl handelt.
                if(!isdigit(zerl[1]))    // Da bei dieser Überprüfung nur das erste Zeichen des sich in "zerl" befindenden strings
                {                        // überprüft wird, werden Zahlen vor denen ein "-" steht als keine Zahlen eingestuft.
                    isnum = false;        // Darum wird als nächstes noch das zweite Zeichen des strings überprüft und erst wenn
                }                        // es sich hierbei ebenfalls um keine Zahl handelt wird die variable "isnum" auf "false"
            }                            // gesetzt.
            else(isnum = true);

            if(isnum && z<=11)
            {
                if(z==3)                    // Speichern der Radien an denen sich die Messpunkte befinden.
                {radien[0]=atof(zerl);}
                if(z==4)
                {radien[1]=atof(zerl);}
                if(z==5)
                {radien[2]=atof(zerl);}
                if(z==6)
                {radien[3]=atof(zerl);}
                if(z==7)
                {radien[4]=atof(zerl);}
                if(z==8)
                {radien[5]=atof(zerl);}

                if(z==9)                    // Speichern mit welcher Feinheit die Druckpunkte berechtnet werden soll
                {deltaR=atof(zerl);}        // vertikal (Radien)

                if(z==10)
                {
                    zeilenanz=atof(zerl);    // horizontal (Winkel)
                }
            
            
            }


            if(isnum && z>11)
            {


                array[i][j]=atof(zerl);        // Speichern der Winkelwerte und der dazughörigen Druckwerte in ein 2-dinemsionales array

                j++;

                

            }

            zerl = strtok(NULL,"    ");
            

        }

        if(z>11)
        {
            i++;
        }

        z++;

    }

    


    if( !feof( inFile ) )
    {
        printf( "Fehler beim Lesen\n" );
    }

    fclose( inFile );



}



ermitteln des anzahl der zwischenradien (zwischenRanz) und der werte der zwischenradien (zwischenR).

C++:
float* zwischenR = new float [zwischenRanz];



void zwischenRadien(void)
{
    zwischenRanz=(radien[5]-radien[0])/deltaR;    // größter Radius - kleinster Radius und dividiert durch die Feinheit
    
    i=0;

    while(i<zwischenRanz)    
    {
        zwischenR[i]=radien[0]+i*deltaR;
        i++;
    }
}


definieren der restlichen benötigten dynamischen arrays:

C++:
float* winkel = new float [zeilenanz];

float* zwpkte = new float [zwischenRanz];

float* a = new float [zeilenanz];

float* C0_0 = new float [zeilenanz];
float* C0_1 = new float [zeilenanz];
float* C0_2 = new float [zeilenanz];
float* C0_3 = new float [zeilenanz];

float* C0 = new float [zeilenanz];
float* C1 = new float [zeilenanz];
float* C2 = new float [zeilenanz];
float* C3 = new float [zeilenanz];
float* C4 = new float [zeilenanz];

float* B0 = new float [zeilenanz];
float* B1 = new float [zeilenanz];
float* B2 = new float [zeilenanz];
float* B3 = new float [zeilenanz];
float* B4 = new float [zeilenanz];

float* A0 = new float [zeilenanz];
float* A1 = new float [zeilenanz];
float* A2 = new float [zeilenanz];
float* A3 = new float [zeilenanz];
float* A4 = new float [zeilenanz];



float** m;
float** p;
float** q;
float** l;
float** n;
float** druck;
float** deltadruck;
float** werte;
float** xwerte;
float** ywerte;
float** einzelfl;
float** druckmw;
float** einzelkraft;

void arraydim(void)
{
    m = new float*[zeilenanz]; // erste dimension

    p = new float*[zeilenanz]; // erste dimension

    q = new float*[zeilenanz]; // erste dimension

    l = new float*[zeilenanz]; // erste dimension

    n = new float*[zeilenanz]; // erste dimension

    druck = new float*[zeilenanz]; // erste dimension

    deltadruck = new float*[zeilenanz]; // erste dimension

    werte = new float*[zeilenanz]; // erste dimension

    xwerte = new float*[zeilenanz]; // erste dimension

    ywerte = new float*[zeilenanz]; // erste dimension

    einzelfl = new float*[zeilenanz+1]; // erste dimension

    druckmw = new float*[zeilenanz]; // erste dimension

    einzelkraft = new float*[zeilenanz]; // erste dimension


    for(i = 0; i < zeilenanz; ++i)
    {
        m[i] = new float[6]; // zweite dimension

        p[i] = new float[6]; // zweite dimension

        q[i] = new float[6]; // zweite dimension

        l[i] = new float[6]; // zweite dimension

        n[i] = new float[6]; // zweite dimension

        druck[i] = new float[6]; // zweite dimension

        deltadruck[i] = new float[6]; // zweite dimension

        werte[i] = new float[zwischenRanz]; // zweite dimension

        xwerte[i] = new float[zwischenRanz]; // zweite dimension

        ywerte[i] = new float[zwischenRanz]; // zweite dimension

        einzelfl[i] = new float[zwischenRanz]; // zweite dimension

        druckmw[i] = new float[zwischenRanz]; // zweite dimension

        einzelkraft[i] = new float[zwischenRanz]; // zweite dimension
    }

}


vermischungspunkt: hier werden, aus welchem grund auch immer, werte die eigentlich in das arraywinkel[] gehören ind das array zwischenR[] geschrieben, obwohl dieses in dieser funktion gar nie verwendet wird.


C++:
void umspeichern(void)
{
    i=0;

    while(i<zeilenanz)
    {
        winkel[i]=18.0/zeilenanz*i; //array[i][0];    // 1d-array für die Winkel: beinhaltet die Werte der ersten Spalte des ursprünglichen
        i++;                        // 2d-arrays.
    }

    i=0;
    j=1;

    while(i<zeilenanz)
    {
        druck[i][0]=0.00;        // der Druck am innersten Radius (Radius[0]) ist immer 0.00
        
        while(j<5)
        {
            druck[i][j]=array[i][j];    // 2d-array für die Druckwerte beinhaltet alle Werte ab der zweiten Spalte des
            j++;                        // ursprünglichen 2d-arrays
        }

        druck[i][5]=0.00;        // der Druck am äußersten Radius (radius[5]) ist immer 0.00

        i++;
        j=1;
    }

}
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
018
12.09.2011, 12:28 Uhr
ao

(Operator)



C++:
float* zwischenR = new float [zwischenRanz];

Woher kennst du an dieser Stelle den Wert für zwischenRanz?

Der wird doch erst hier berechnet:

C++:
void zwischenRadien(void)
{
    zwischenRanz=(radien[5]-radien[0])/deltaR;    // größter Radius - kleinster Radius und dividiert durch die Feinheit
    
    i=0;

    while(i<zwischenRanz)    
    {
        zwischenR[i]=radien[0]+i*deltaR;
        i++;
    }
}


Eigentlich müsstest du hier :
1. zwischenRanz berechnen
2. das Array zwischenR in der richtigen Größe anlegen
3. zwischenR-Elemente in der Schleife zuweisen.

Wenn du mit dem Array winkel und dem Wert zeilenAnz dasselbe gemacht hast wie oben, dann wundert es mich nicht, dass die Größen nicht passen. Du musst zuerst die richtige Größe haben und dann new aufrufen.

Dann nochn Tipp:


C++:
    i=0;
    while(i<zwischenRanz)    
    {
        zwischenR[i]=radien[0]+i*deltaR;
        i++;
    }

Es ist zwar nicht falsch, hier eine while-Schleife zu verwenden. Tatsächlich handelt es sich aber um eine Zählschleife (von 0 bis zwischenRanz - 1), ohne Abhängigkeit von anderen Bedingungen.

Es ist guter Stil, "eng an der Wahrheit" zu programmieren, sprich, wenn gezählt wird, nimmt man eine for-Schleife, und wenn Bedingungen ausgewertet werden, eine while- oder do-Schleife, je nachdem.

Es anders zu machen zwingt den Leser, den Ablauf genau nachzuvollziehen, und wenn man dann feststellt, hier wurde einfach nur eine Zählschleife umständlich ausgedrückt, dann denkt man erst mal "o Mann, das geht doch auch einfacher".
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
019
12.09.2011, 12:35 Uhr
~leiti7
Gast


danke ich werde das mal versuchen.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
Seiten: [ 1 ] > 2 < [ 3 ] [ 4 ]     [ 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: