Herzlich Willkommen, lieber Gast!
  Sie befinden sich hier:

  Forum » C / C++ (ANSI-Standard) » großes array im DOS

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
09.10.2006, 14:13 Uhr
KBlaubaer



Hi Leute,
ich möchte mehr als 64k-Speicher dynamisch zuweisen, es klappt halbwegs, aber nicht so ganz... Wer kann helfen? Ich nutze MS-DOS, Borland-C, Speichermodell large, auch schon mit "huge" probiert, ändert aber nix, alle anderen Einstellungen auch schon durchgespielt (denke ich zumindest)
Ich brauche mehrere Felder, welche zum Teil im selben(!) Speicherbereich liegen sollen. Dazu initalisiere ich ein großes und verteile dann die Adressen der anderen darin.
Soweit so gut, das mit dem "wertptr_all" scheint auch gut zu funktionieren, doch mit dem Feld wert_a, gehts nicht, sobald ich über die magischen 64KB komme spiegelt der wieder in die niederen Adressen.(siehe 130) Das führt also zu folgender Ausgabe:
----------------------------
ok
add 0; wert 123
add 1; wert 124
add 16; wert 130
add 1600; wert 125
add 3200; wert 126
add 6400; wert 127
add 12800; wert 128
add 16360; wert 129
add 73727; wert 99
----------------------------

das Programm dazu:


Code:
#include <stdio.h>
#include <stdlib.h>
#include <alloc.h>

typedef unsigned long huge* wert_all;            // wert_all[0x12000L];
typedef unsigned long huge (*wert_a)[40][40];    // wert_a[40][40][40];
typedef unsigned long huge (*wert_b)[128][128];  // wert_b[4][128][128];
typedef unsigned long huge* wert_c;              // wert_c[4096];
typedef unsigned long huge* wert_d;              // wert_d[4096];

wert_all wertptr_all;
wert_a wertptr_a;
wert_b wertptr_b;
wert_c wertptr_c;
wert_d wertptr_d;

int main()
{
    unsigned long i;

    wertptr_all = (wert_all)farmalloc(0x12000L*sizeof(unsigned long));
    if(wertptr_all == NULL) printf("error\n");
      else printf("ok\n");

    // ich weise allen Feldern zunächst die selbe Startadresse zu
    wertptr_d = (wert_d)wertptr_all;
    wertptr_c = (wert_c)wertptr_all; //+ 0x1000);
    wertptr_b = (wert_b)wertptr_all; //+ 0x2000);
    wertptr_a = (wert_a)wertptr_all; //+ 0x2000);

    for(i=0;i<0x12000L;i++) wertptr_all[i] = 0L;    // alles 0

    wertptr_a[0][0][0] = 123;
    wertptr_a[0][0][1] = 124;
    wertptr_a[1][0][0] = 125;
    wertptr_a[2][0][0] = 126;
    wertptr_a[4][0][0] = 127;
     wertptr_a[8][0][0] = 128;
     wertptr_a[10][9][0] = 129;
     wertptr_a[10][10][0] = 130;

    wertptr_all[0x11fff] = 99;

    for(i=0;i<0x12000L;i++) if(wertptr_all[i] != 0L) printf("add %ld; wert %ld\n",i,wertptr_all[i]);

    getchar();
    return 0;
}

 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
001
09.10.2006, 15:17 Uhr
KBlaubaer



Ich habe das noch mal einfacher (anders) aufgeschrieben, das Problem ist scheinbar wirklich nur das große Feld. Als Ergebnis stehen die Werte jeweils in den 64kB nach oben und unten gespiegelt als Ergebnisse drin, also keine eindeutige Zuweisung möglich... grummel grummel...


Code:
#include <stdio.h>
#include <stdlib.h>
#include <alloc.h>

typedef unsigned long huge wert_a[40][40][40];    // wert_a[40][40][40];
wert_a *wertptr_a;

int main()
{
    unsigned int i,j,k;

    wertptr_a = farmalloc(256000L);
    if(wertptr_a == NULL) printf("error\n");
      else printf("ok\n");

    for(i=0;i<40;i++)
     for(j=0;j<40;j++)
      for(k=0;k<40;k++)
       (*wertptr_a)[i][j][k] = 0L;    // alles 0

    (*wertptr_a)[0][0][0] = 123;
    (*wertptr_a)[0][0][1] = 124;
    (*wertptr_a)[1][0][0] = 125;
    (*wertptr_a)[2][0][0] = 126;
    (*wertptr_a)[4][0][0] = 127;
     (*wertptr_a)[8][0][0] = 128;
     (*wertptr_a)[10][9][0] = 129;
     (*wertptr_a)[10][10][0] = 130;

    for(i=0;i<40;i++)
     for(j=0;j<40;j++)
      for(k=0;k<40;k++)
       if((*wertptr_a)[i][j][k] != 0L)
        printf("feld %d;%d;%d; wert %ld\n",i,j,k,(*wertptr_a)[i][j][k]);


    getchar();
    return 0;
}

 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
002
09.10.2006, 15:21 Uhr
KBlaubaer



nun auch noch mal der klassische Fall, wie es geht (aber eben fest statisch angelegt), alles steht dort im Ergebnis wo es hingehört:


C++:
#include <stdio.h>
#include <stdlib.h>
#include <alloc.h>

unsigned long huge wert_a[40][40][40];    // wert_a[40][40][40];

int main()
{
    unsigned int i,j,k;

    for(i=0;i<40;i++)
     for(j=0;j<40;j++)
      for(k=0;k<40;k++)
       wert_a[i][j][k] = 0L;    // alles 0

    wert_a[0][0][0] = 123;
    wert_a[0][0][1] = 124;
    wert_a[1][0][0] = 125;
    wert_a[2][0][0] = 126;
    wert_a[4][0][0] = 127;
     wert_a[8][0][0] = 128;
     wert_a[10][9][0] = 129;
     wert_a[10][10][0] = 130;

    for(i=0;i<40;i++)
     for(j=0;j<40;j++)
      for(k=0;k<40;k++)
       if(wert_a[i][j][k] != 0L)
        printf("feld %d;%d;%d; wert %ld\n",i,j,k,wert_a[i][j][k]);


    getchar();
    return 0;
}


Dieser Post wurde am 09.10.2006 um 20:07 Uhr von Pablo editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
003
09.10.2006, 15:24 Uhr
ao

(Operator)



Zitat von KBlaubaer:
Ich brauche mehrere Felder, welche zum Teil im selben(!) Speicherbereich liegen sollen. Dazu initalisiere ich ein großes und verteile dann die Adressen der anderen darin.

Was meinst du mit "im selben Speicherbereich"? Zusammenhängend? Warum?

Wenn das so sein muss, dann definier dir eine Struktur, die die Arrays enthält.

Wenn nicht, dann lass das mit dem großen Block und allozier die vier Arrays einzeln.

Bei den verlangten Größen (40 x 40 x 40 x sizeof (unsigned long)) musst du wohl huge nehmen, large geht nur bis 64 K Blockgröße. Und versuchs mal so:

C++:
typedef unsigned long huge *wert_a [40][40];  // keine Klammern um (*wert_a).


ao
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
004
09.10.2006, 15:26 Uhr
ao

(Operator)


Sonst schau doch mal in deiner Borland-Doku nach, wie man huge-Pointer richtig deklariert. Ich kann mich auch nicht mehr so genau erinnern, ist lange her, und ich hab mit huge nicht viel gemacht.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
005
09.10.2006, 15:34 Uhr
KBlaubaer



ich habe doch überall "ge-huge-t"...
Ich bin kein großer C-Guru, mache das als Hardwareentwickler eigentlich als notwendiges Übel mit... schnief. Ein Königreich für einen Controller mit linearem Adressraum, wo man einfach soviel Speicher nimmt, wie physikalisch vorhanden ist... aber ok, muß doch auch mit so 'ner Intel-DOS-connection irgendwie funktionieren...
Ohne die Klammern ok, ich bin für jeden Tipp zuhaben, gib bitte dazu dann auch die Form des Zugriffs auf das array an (z.B. wert_a[10][10][10] = 123
Danke.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
006
09.10.2006, 15:40 Uhr
ao

(Operator)



C++:
typedef unsigned long huge (*wert_a)[40][40];    // wert_a[40][40][40];

Ich bin nicht sicher, ob das wirklich ein huge-Pointer ist oder nur ein gewöhnlicher Pointer auf unsigned-long-Daten, die unsinnigerweise huge sind. Deshalb meine Idee, lass die Klammern weg.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
007
09.10.2006, 15:51 Uhr
KBlaubaer



ok, jetzt ohne Klammern...

hier meckert der Compiler nun: wertptr_a = (wert_a)wertptr_all;
und ist das dann noch die richtige Form des Zugriffs auf das Feld?
wertptr_a[0][0][0] = 123;

RTFM... hilfe ;-) Aber mal echt, ich konnte da nix gescheites rauslesen, dann noch mit pointern... Du, ich mache dir in der Zeit lieber 'ne Leiterplatte mit so 'nem Controller ;-)
Aber danke für jeden Tipp.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
008
09.10.2006, 21:06 Uhr
KBlaubaer



Abend Leute, ich muss noch mal nerven...
Ich muss zur Programmlaufzeit ein großes array anlegen, es geht also nur dynamisch, weil die Art des array erst während des Programm bestimmt wird. Also z.B: einmal eins mit:
unsigend long[40][40][40]
oder eins mit:
unsigend long[4][128][128]
ich kann immer nur eins anlegen, weil sonst der Speicher zu knapp ist.
Muss doch eine Möglichkeit geben die zu tun, so das es auch funktioniert.. grummel grummel...
Danke für Tipps.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
009
09.10.2006, 21:45 Uhr
ao

(Operator)



C++:
unsigned long *** p = malloc (sizeof (unsigned long) * 40 * 40 * 40);
...
p[0][1][2] = 3;
...
free (p);

 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
Seiten: > 1 < [ 2 ]     [ 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: