4. array[2000][2000] nicht möglich?

array[2000][2000] nicht möglich?

  • M

    hmmm...
    bei mir klappte es nur mit der von mir beschriebenen modifikation.....???

    0
  • J
     

    calloc(SIZE * sizeof(double *),sizeof(double *))

    Somit reservierst du "sizeof(double *)" und füllst aber einen Bereich von "SIZE * sizeof(double *)" mit Nullen. Das kann nicht gut gehen.

    Auszug aus den manpages:
    calloc(size_t number, size_t size);

    Wie gesagt, ich hab den Code mehrfach getestet und es klappt.

    0
  • M

    hmm....aber das tue ich doch beim ersten auch oder nicht? Du sagst doch im ersten argument die anzahl von dem was im zweiten argument gespeichert werden soll oder net?

    warums bei dir klappt verstehe ich nicht....bei mir gehts nur über die zweite variante...und da auch locker mit dimensionen über 2000 . Ausgabe funzt und der rest auch....verstehe ich net jetzt....*grmpf

    0
  • J

    ich kann mich eigentlich nur wiederholen.
    Erst musst du platz für 2000 Zeiger schaffen.
    Dannach für jeden eizelnen Zeiger Platz schaffen damit 2000 double Werte reinpassen.
    Das ist alles 😉
    Und natürlich sollte man mit calloc nicht mehr Speicherbereich mit Nullen füllen als man eigentlich reserviert hat.

    Hier mal ein Link wo dynamische Arrays sehr gut beschrieben werden.
    http://www.pronix.de/pronix-762.html

    0
  • M

    grmpf....müsste dann nicht in der zweiten calloc anweisung aber das so sein wie ichs habe? Weil hier alloziiere ich ja dann nochmal 2000 double werte...

    ich les den link mal...danke

    0
  • J

    Mati schrieb:

    Weil hier alloziiere ich ja dann nochmal 2000 double werte...

    Falsch, hier alloziierst du das erste mal Speicher für double Werte. Beim ersten mal alloziierst du Speicher für double Zeiger.

    Du hast hier kein "normales Array", sondern ein Array von Zeigern.

    0
  • M

    hmm ok...danke...
    aber leider läufts bei mir so net - segmentation fault - mitten drin in der schleif nach ein paar hundert iterationen....

    0
  • J

    Also nochmal mit Schritt für Schritt:

    Der Speicher für n "double Zeiger" wird alloziiert. In deinem Fall 2000 Zeiger:

    array = (double **)calloc(SIZE * sizeof(double *), SIZE * sizeof(double *));

    Für jede Zeile wird jetzt Speicher von "n * sizeof(double)" alloziiert. In deinem Fall 2000 double Werte:

    for(i = 0; i < SIZE; i++)
   array[i] = (double *)calloc(SIZE * sizeof(double), SIZE * sizeof(double));
    0
  • M

    danke für deine geduld job...

    ich verstehe natürlich irgendwo deine argumentation aber im netz finde ich beispiele wie diese hier die mich etwas verwirren:

    int rows = ***;
int columns = ***;
/* Allokieren des 2D-Speichers, sollte die Anfrage
     fehlschlagen den gesamten Prozess beenden */
  int** ptr=(int**)(calloc(rows,sizeof(int*)));
  if(ptr!=NULL)
  {

    for (i=0;i<rows;i++)
    {
      ptr[i]= (int*)(calloc(columns,sizeof(int)));
...
    0
  • J

    Also ich hab mir jetzt noch ein paar Fehlermeldungen eingebaut, und es gibt denk ich mal eine einfache Erklärung wieso es bei so einem großen Array fehlschlägt.
    Es wird einfach kein zusammenhängender Speicherbereich mehr gefunden.

    0
  • F

    array = (double **)calloc(SIZE * sizeof(double *), SIZE * sizeof(double *));

    Warum calloc(SIZE * sizeof(double *), SIZE * sizeof(double *)? Sollte das nicht eher calloc(SIZE, sizeof(double *)) sein..

    The calloc() function allocates space for number objects, each size bytes
    in length. The result is identical to calling malloc() with an argument
    of ``number * size'', with the exception that the allocated memory is
    explicitly initialized to zero bytes.

    Ausserdem castet man in C malloc/calloc nicht.

    0
  • J

    Ihr habt Recht, irgendwie klappt das mit calloc nicht so richtig.

    der richtige code mit malloc wäre:

    array = (double **)malloc(SIZE * sizeof(double *));
array[i] = (double *)malloc(SIZE * sizeof(double));

    Jetzt muß sich nur noch wer finden der das auf calloc ummünzt 😉

    Sorry wegen der Verwirrung, aber da ich calloc eigentlich nie nutze hab ich es irgendwie verbockt 🙄

    Aber der obige code mit malloc ist definitiv korrekt :p

    Also wenn ich jetzt wild drauf losrate würde ich sagen der Code wäre:

    array = (double **)calloc(SIZE, sizeof(double *));
array[i] = (double *)calloc(SIZE, sizeof(double));

    feigling schrieb:

    Ausserdem castet man in C malloc/calloc nicht.

    Also hier http://www.pronix.de/pronix-753.html
    steht folgendes:

    Zitat:
    Das Typencasting der Funktion malloc() ist in C nicht notwendig und kann auch weggelassen werden. ANSI C++ schreibt allerdings ein Casten des Typs void * vor.
    Zitat Ende.

    Demzufolge ist es ja nicht falsch.

    0
  • F

    Wir sind hier nicht in Ansi C++ 😉

    Vor ein paar Tagen wurde in einem Thread gepostet, warum man nicht casten soll. Finde den jetzt auf die schnelle nicht mehr wieder. Vielleicht hat ja noch jemand den Link, der dort gepostet wurde.

    0
  • J

    feigling schrieb:

    Wir sind hier nicht in Ansi C++ 😉

    Hab ich auch nie behauptet? Der vorige Satz war von Bedeutung.

    jbo75 schrieb:

    Das Typencasting der Funktion malloc() ist in C nicht notwendig und kann auch weggelassen werden.

    Du meinst sicherlich diesen Thread: http://www.c-plusplus.net/forum/viewtopic-var-t-is-162330.html

    Ich les' ihn mir mal durch, man lernt ja nie aus 😃

    //Edit:

    Also ich hab mir den Thread mal durchgelesen, und am Ende kommt auch nur raus das es zum jetzigen Zeitpunkt relativ egal ist ob man castet oder nicht. Aber ich denke mal ich werde es in Zukunft auch weglassen 😃

    0
  • ?

    jbo75 schrieb:

    Also ich hab mir den Thread mal durchgelesen, und am Ende kommt auch nur raus das es zum jetzigen Zeitpunkt relativ egal ist ob man castet oder nicht. Aber ich denke mal ich werde es in Zukunft auch weglassen 😃

    Viel passieren wird idR wirklich nicht. Aber es ist einfach nicht schön an diesen Stellen zu casten. Casts sollten dann (und imho nur dann) eingesetzt werden wenn der Programmierer genau weiss (besser als der Compiler) was er macht. Außerdem hilft ein (bestenfalls) sinnloser Cast der Lesbarkeit auch nicht. Anders ausgedrückt: Wie dereferenzierst du einen Zeiger? Etwa so?

    foo = *(&(*ptr));

    😉

    0
  • H
     

    #include <stdio.h>
#include <stdlib.h>

int main() 
{ 
       double my;
       // Als Zeiger sieht ein  Array double matrix[2000][2000] so aus:
       // double (*matrix)[2000]
       // zum casten (rechts vom Zuweisungsoperator) sieht er so aus:
       // double(*)[2000]
       // Der Einfachheit halber schreibt man sich ein typedef 
       typedef double (*ptr)[2000];
       // Jetzt steht ptr für diesen Zeiger double(*)[2000], und zwar noch ohne Name
       ptr matrix = malloc(2000*2000*(sizeof(double)));  // als *.c compiliert
       //ptr matrix = (ptr)malloc(2000*2000*(sizeof(double))); // als *.cpp compiliert
       //ohne typedef kann man so schreiben:
       //double(*matrix)[2000] = malloc(2000*2000*(sizeof(double))); // als *.c compiliert
       //double(*matrix)[2000] = (double(*)[2000])malloc(2000*2000*(sizeof(double))); // als *.cpp compiliert
       matrix[1999][1999] = 47.11; 
       my = matrix[1999][1999];  // my = 47.11
       free(matrix); 
       ptr matrix2 = (ptr)calloc(2000*2000, sizeof(double));
       //ohne typedef müsste man so schreiben:
       //double (*matrix2)[2000] = (double(*)[2000])calloc(2000*2000, sizeof(double));
       my = matrix2[1999][1999]; // my = 0
       free (matrix2);
       return 0; 
}
    0
Anmelden zum Antworten