Herzlich Willkommen, lieber Gast!
  Sie befinden sich hier:

  Forum » C / C++ (WinAPI, Konsole) » Maximale Größe von Arrays?

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 ]
000
26.06.2007, 09:23 Uhr
~piependeckel
Gast


Hallo allerseits,
ich habe ein Problem mit Feldern (glaube ich jedenfalls).
ein programm nutzt drei felder je der dimension [2][400][400] mit float variablen.
kompilieren funzt. nur leider stürzt das programm, sobald es rechnen soll ab.
reduziere ich die größe der felder jedoch auf [2][200][200] läuft es.
habt ihr vllt. ne idee woran das liegen könnte.

unten mal der code. benutzt eclipse mit mingw zum kompilieren.

danke für antworten
piependeckel


nicht sehr elegant.


C++:
#include <stdio.h>
#include <iostream>
#include <math.h>
#include <fstream.h>

#define PI 3.141592653
#define P0 1.0
#define R0 0.2
#define X0 1.0
#define Y0 1.0
    
using namespace std;



int main()
{
    int nx=400;
    int ny=400;
    int nt;
    int i,j,k,ii,jj;
    
    cout<<"Geben Sie an, wieviele Zeitschritte Sie rechnen wollen: ";
    cin>>nt;
    
    const float deltax=2.0/nx;
    const float deltay=2.0/ny;
    const float deltat=0.01,mx=0.0,my=0.0;
    float u[2][nx+2][ny+2],v[2][nx+2][ny+2],p[2][nx+2][ny+2];
    
//Anfangsbelegung


        for (i=0;i<=nx+1;i++)
        {
            for (j=0;j<=ny+1;j++)
            {
                u[0][i][j]=1.000;
                v[0][i][j]=1.000;
                p[0][i][j]=0.000;
                float R=sqrt(pow(((i-1)*deltax-X0),2.0)+pow(((j-1)*deltay-Y0),2.0));
                if (R<=R0)
                {
                    p[0][i][j]=16.0*exp(-(R/(0.5*R0))*(R/(0.5*R0)));
                }
            }
        }
        
        
        
        cout << "Gesamtspeicherbedarf von float p: ";
    cout << sizeof(p) << endl;
    cout << "Speicherbedarf eines Elements: ";
    cout << sizeof(p[0][0][0]) << endl;
    cout << "Anzahl der Elemente: ";
    cout << sizeof(p) / sizeof(p[0][0][0]) << endl;
        
        
//Berechnung mit Lax Wendroff

for (k=0;k<=nt;k++)
{
    for (i=1;i<=nx;i++)
    {
        for (j=1;j<=ny;j++)
        {

                u[0][nx+1][j]=u[0][1][j];                //periodische Randbedingung bei x=0 und x=1
                v[0][nx+1][j]=v[0][1][j];
                p[0][nx+1][j]=p[0][1][j];        
                u[0][0][j]=u[0][nx][j];
                v[0][0][j]=v[0][nx][j];
                p[0][0][j]=p[0][nx][j];
                
                u[0][i][ny+1]=u[0][i][1];                //periodische Randbedingung bei y=0 und y=1
                v[0][i][ny+1]=v[0][i][1];
                p[0][i][ny+1]=p[0][i][1];        
                u[0][i][0]=u[0][i][ny];
                v[0][i][0]=v[0][i][ny];
                p[0][i][0]=p[0][i][ny];

            
            
            
            float dxu=1/(2*deltax)*(u[0][i+1][j]-u[0][i-1][j]);
            float dyu=1/(2*deltay)*(u[0][i][j+1]-u[0][i][j-1]);
            float dxxu=1/(deltax*deltax)*(u[0][i+1][j]-2.0*u[0][i][j]+u[0][i-1][j]);
            float dyyu=1/(deltay*deltay)*(u[0][i][j+1]-2.0*u[0][i][j]+u[0][i][j-1]);
            float dxyu=1/(4*deltax*deltay)*((u[0][i+1][j+1]-u[0][i-1][j+1])-(u[0][i+1][j-1]-u[0][i-1][j-1]));
            
            float dxv=1/(2*deltax)*(v[0][i+1][j]-v[0][i-1][j]);
            float dyv=1/(2*deltay)*(v[0][i][j+1]-v[0][i][j-1]);
            float dxxv=1/(deltax*deltax)*(v[0][i+1][j]-2.0*v[0][i][j]+v[0][i-1][j]);
            float dyyv=1/(deltay*deltay)*(v[0][i][j+1]-2.0*v[0][i][j]+v[0][i][j-1]);
            float dxyv=1/(4*deltax*deltay)*((v[0][i+1][j+1]-v[0][i-1][j+1])-(v[0][i+1][j-1]-v[0][i-1][j-1]));            
            
            float dxp=1/(2*deltax)*(p[0][i+1][j]-p[0][i-1][j]);
            float dyp=1/(2*deltay)*(p[0][i][j+1]-p[0][i][j-1]);
            float dxxp=1/(deltax*deltax)*(p[0][i+1][j]-2.0*p[0][i][j]+p[0][i-1][j]);
            float dyyp=1/(deltay*deltay)*(p[0][i][j+1]-2.0*p[0][i][j]+p[0][i][j-1]);
            float dxyp=1/(4*deltax*deltay)*((p[0][i+1][j+1]-p[0][i-1][j+1])-(p[0][i+1][j-1]-p[0][i-1][j-1]));            
            
            
            
            
            
            
            u[1][i][j]=u[0][i][j]-deltat*(mx*dxu+dxp+my*dyu)+(deltat*deltat)/2*((mx*mx+1)*dxxu+2*mx*dxxu+2*mx*my*dxyu*1.0*dxyv+2*my*dxyp+my*my*dyyu);
            
            v[1][i][j]=v[0][i][j]-deltat*(mx*dxv+my*dyv+dyp)+(deltat*deltat)/2*((mx*mx)*dxxv+1.0*dxyu+2.0*mx*my*dxyv+2.0*mx*dxyp+(my*my+1.0)*dyyv+2.0*my*dyyp);
            
            p[1][i][j]=p[0][i][j]-deltat*(1.0*dxu+mx*dyp+dyv+my*dyp)+(deltat*deltat)/2*((2.0*mx)*dxxu+(mx*mx+1.0)*dxxp+2.0*my*dxyu+2.0*mx*dxyv+(2.0*mx*my)*dxyp+2.0*my*dyyv+(my*my+1.0)*dyyp);

            


            }
    }
    
        for (ii=1;ii<=nx;ii++)
    {
        for (jj=1;jj<=ny;jj++)
        {
            u[0][ii][jj]=u[1][ii][jj];
            v[0][ii][jj]=v[1][ii][jj];
            p[0][ii][jj]=p[1][ii][jj];
        }
    }
}
    
    
    
//Ausgabe
    
    ofstream druck ("druck.dat");    
    for (j=1;j<=ny;j++)
    {
        for (i=1;i<=nx;i++)
        {
            druck<<"  "<<(i-1)*deltax<<"  "<<(j-1)*deltay<<"  "<<p[0][i][j]<<endl;        
        }
        
    }
    
    ofstream geschwu ("geschwu.dat");    
    for (j=1;j<=ny;j++)
    {
        for (i=1;i<=nx;i++)
        {
            geschwu<<"  "<<(i-1)*deltax<<"  "<<(j-1)*deltay<<"  "<<u[0][i][j]<<endl;        
        }
        
    }
    
    ofstream geschwv ("geschwv.dat");
    for (j=1;j<=ny;j++)
    {
        for (i=1;i<=nx;i++)
        {
            geschwv<<"  "<<(i-1)*deltax<<"  "<<(j-1)*deltay<<"  "<<p[0][i][j]<<endl;        
        }
        
    }
    
    

    
    return 0;
}



Bearbeitung von 0xdeadbeef:

cpp-tags eingefügt. Nächstes mal selbst machen.


Dieser Post wurde am 26.06.2007 um 16:40 Uhr von 0xdeadbeef editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
001
26.06.2007, 10:10 Uhr
Kest
saint


Hi!

Weil du schlicht zu viel Speicher brauchst, so viel aber steht nicht zur Verfügung. Bei den meisten Compilern, wenn nötig, lässt sich die Größe explizit angeben.
--
Wenn man einen Hufschlag hört, sollte man >Pferd< denken und nicht >Zebra<.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
002
26.06.2007, 13:30 Uhr
~piependeckel
Gast


danke für die schnelle antwort.

heisst das, dass ich im compiler mehr speicher für die variablen vergeben kann?
weiß zufällig jemand, wie das mit eclipse geht?


bzw. gibt es eine andere möglichkeit die daten zu speichern?

piependeckel
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
003
26.06.2007, 13:40 Uhr
Kest
saint


Ja, das heißt es.

>Eclipse< ist doch 'ne Entwicklungsumgebung? Was für 'n Compiler benutzste denn?
--
Wenn man einen Hufschlag hört, sollte man >Pferd< denken und nicht >Zebra<.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
004
26.06.2007, 14:07 Uhr
~piependeckel
Gast


der compiler ist MinGW.

piependeckel
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
005
26.06.2007, 16:37 Uhr
Blubber2063



Leg dir Variable entweder auf dem Heap an(new) oder als globale Variable, dann kannst du mehr Speicher nutzen.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
006
26.06.2007, 16:41 Uhr
0xdeadbeef
Gott
(Operator)


Lass das mit der globalen Variable bloß sein, und pack den Kram auf den Heap.

Übrigens - der C++-Standard gibt diese Art der dynamischen Stackallokation eigentlich (noch) nicht her. Gut vorstellbar, dass du da nen Stack-Overflow für kriegst.
--
Einfachheit ist Voraussetzung für Zuverlässigkeit.
-- Edsger Wybe Dijkstra
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
007
26.06.2007, 19:07 Uhr
~piependeckel
Gast


@0xdeadbeef: danke für die cpp tags ....bin das erste mal in diesem forum


aber noch ne frage....
programmiere noch nicht lange in c++, deshalb: wie lege ich die arrays auf den Heap...normal werden sie ja in den stack gelegt, oder?

grüße
piependeckel
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
008
26.06.2007, 19:33 Uhr
~piependeckel
Gast


für ein 2 dim feld habe ich diese möglichkeit gefunden...
wie müsste es für ein [2][200][200] feld aussehen...
oder ist das totaler unsinn?


C++:
// Allocate
char **feld = new float *[200];

for(int i = 0; i < 200; ++i)
feld[i] = new float[200];

// Delete
for(i = 0; i < 200; ++i)
delete [] feld[i];

delete [] feld;

 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
009
26.06.2007, 21:31 Uhr
Kest
saint


Zuerst zu dem Stack:
theoretisch musste an den Linker eine Option übergeben: >--stack "stack size"<. (dabei >stack size< = neu stack Größe. In deinem Fall so um ca. ... 0x400000)



C++:
int*** a=new int**[2];
    a[0]=new int*[200];
    a[1]=new int*[200];

    for(size_t i=0; i<2; ++i)
        for(size_t j=0; j<200; ++j)
            a[i][j]=new int[200];

--
Wenn man einen Hufschlag hört, sollte man >Pferd< denken und nicht >Zebra<.

Dieser Post wurde am 26.06.2007 um 21:32 Uhr von Kest editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
Seiten: > 1 < [ 2 ]     [ 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: