unendlich grosses File erzeugen

Du musst die Datei vor der Schleife öffnen und sie auch geöffnet halten. Write bekommt als Argument das Objekt (FILE*) übergeben und schreibt dann jeweils in die Datei.
Außerdem ist es normalerweise keine gute Idee, 1MB auf den Stack zu schieben. Du solltest den Speicher vorher auf dem Heap allokieren und diesen Bereich ebenfalls der Funktion als Argument übergeben.

volkard

[quote="Jey"]

#define _FILE_OFFSET_BITS 64 			//Damit grösser als 2GB
#include <stdio.h>
#include <stdlib.h>

#define DATAFILE "data.dat"				//dateiname festlegen

int main(int argc, char *argv[])
{
    FILE *fp;
    unsigned long long mbytes = 0;
    unsigned long long a = 0;
    unsigned char data[1024 * 1000];//malloc!

    fp = fopen(DATAFILE, "w+");fclose(fp); //unlink?

    printf("Bitte geben Sie die gewünschte Dateigrösse in MBs an: ");
    do{ scanf("%d", &mbytes); }while(getchar() != '\n');

    data[0] = '\0'; //memset!

    fp = fopen(DATAFILE, "a+b");
    for(a; a<mbytes; a++)
    {
        fwrite(&data, sizeof(data), 1, fp);
    }
    fclose(fp);
    //free!

    return 0;
}

Hallo

Geht bei mir wunderbar doch. wenn ich die datei wieder offnen will (nachdem ich sie geschlossen habe) dn funktioniert das schon nicht mehr !
Wie mach ich den das ?

gr.fr

Wutz

Das Problem ist der gewählte append-Modus bei fopen. Bei jeder Schreiboperation versucht dieser, ans Dateiende zu positionieren, was bei üblicher Definition von fpos_t==long genau LONG_MAX (auf 32-Bit Compilern 2^31) entspricht. Die Position vor dem Schreiben mit fwrite kann also max. LONG_MAX betragen.

_FILE_OFFSET_BITS ist kein ANSI C
unsigned long long ist kein C89
1024*1000 ist ungleich 1 MB
...

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

#define DATAFILE "data.dat"                //dateiname festlegen

int main()
{
    FILE *fp;
    long mbytes;
    unsigned char *data=calloc(1,1<<20L);

    printf("Bitte geben Sie die gewünschte Dateigrösse in MBs an: ");
    do{ scanf("%ld", &mbytes); }while(getchar() != '\n');

    if( fp = fopen(DATAFILE, "wb") )
    {
      while( mbytes-- )
        if( 1!=fwrite(data, 1<<20L, 1, fp) )
          perror(DATAFILE),fclose(fp),free(data),exit(1);
      fclose(fp);
    }    
    free(data);

    return 0;
}

Wutz schrieb:

1024*1000 ist ungleich 1 MB

Ja, stimmt. Bei 1024*1024 Bytes auf dem Stack dürfte sich das Programm aber auch kommentarlos verabschieden.

* Es sei denn, man reserviert zusätzlichen Speicher für Stack-Allokationen.

Hallo

Ja und jetzt ? gibt es nun eine Funktion mit der ich 10GB Files öffnen kann ?
Den Rest weiss ich alles.

gr.fr

volkard

fr schrieb:

Ja und jetzt ? gibt es nun eine Funktion mit der ich 10GB Files öffnen kann ?
Den Rest weiss ich alles.

Jetzt wäre es an der Zeit, open zu probieren?

Hallo

Danke.
Gibt es den auch etwas vergleichbares zu fseek(), da diese ja auch nur mit 32Bit umgehen kann !?

gr.fr

volkard

fr schrieb:

Hallo
Danke.
Gibt es den auch etwas vergleichbares zu fseek(), da diese ja auch nur mit 32Bit umgehen kann !?
gr.fr

Hier steht mehr: http://yfrog.com/9eopengp
Sagst mir bescheid, wenn ich nach unten scrollen soll oder einem Verweis folgen.

also ich hab mich mal hingesetzt und das etwas überarbeitet weil ich genau das gleiche vorhab das programm macht genau daas gleiche dauert halt nur eine weile

#define _FILE_OFFSET_BITS 64
#include <stdio.h>
#include <stdlib.h>
#include <fstream>
#include <iostream>
#define DATEN "data.bdn"
using namespace std;

void datei()
{     FILE *dat_ein;
      unsigned long long mb = 0;
      unsigned long long a = 0;
      dat_ein = fopen(DATEN, "a+");
      fclose(dat_ein);
      mb = 4096;
      for(a; a<mb; a++);
      {
      FILE *dat_ein;
      unsigned char data[1024*1000];
      data[0] = '\0';
      dat_ein = fopen(DATEN, "a+b");
      fwrite(&data, sizeof(data), 1, dat_ein);
      fclose(dat_ein);
      }
}

int schleife;

int main ()
{
  for (schleife = 1; schleife != 0; schleife++)
  {
    cout << "Programm wird Installiert: " << schleife << " Datens\x84tze kopiert." << endl;

    datei();
  }

return 0;
}

sry in der funktion datei wir mb der wert 4096 zugewiedes es muss 1024 heißen ich hatte nur den falschen code kopiert

Hallo

fr schrieb:
Hallo
Danke.
Gibt es den auch etwas vergleichbares zu fseek(), da diese ja auch nur mit 32Bit umgehen kann !?
gr.fr

Hier steht mehr: http://yfrog.com/9eopengp
Sagst mir bescheid, wenn ich nach unten scrollen soll oder einem Verweis folgen.

Du bist ja ein ganz böser

wieso hast du einen beitrag also code geschreiben? xD
naja egal also ist es ungefähr so ein programm das du suchst oder schreiben wolltest?

Hallo

Ja sorry. Ich suche aber was für Windows und nicht Linux !

open - hab ich zum öffnen von Dateien.
lseek - ist auch unter Windows vorhanden, doch diese arbeitet auch nur bis 32Bit.
Aber ich finde nichts für Windows das bis 64Bit Arbeitet !?

lseeki64 habe ich gefunden doch die scheint mein .....

Nachtrag :
Habe _lseeki64() gefunden und das ist genau das was ich gebraucht hatte.
Danke gleich ...

Danke

also das ist für windows...

falls du das hinbekommst dann poste bitte nocht mal den neuen code

Hallo

Warum sollte das nicht funktionieren ?

Hallo

Ich will die Datei auch noch öffnen können
Bei dir ist das mit fopen() nicht mehr möglich !

gr.fr

Hi

Dein Code ist ja auch zum .....

oleeiner schrieb:

void datei()
{     FILE *dat_ein;
      unsigned long long mb = 0;
      unsigned long long a = 0;
      dat_ein = fopen(DATEN, "a+");
      fclose(dat_ein);
      mb = 4096;
      for(a; a<mb; a++);
      {
      FILE *dat_ein;
      unsigned char data[1024*1000];
      data[0] = '\0';
      dat_ein = fopen(DATEN, "a+b");
      fwrite(&data, sizeof(data), 1, dat_ein);  <--- Falsch !!
      fclose(dat_ein);
      }
}

Als ersten ruft man fwrite() so auf !

fwrite(&data, 1, sizeof(data), dat_ein);

Das zweite ist, wie willst du das 4GB File mit fopen wieder öffnen ? Dazu brauchst du schon unter Windows:open() ,_lseeki64 ,_telli64().
Und auf die Unix/Linux Derivaten hat glaube ich schon Volkard hingewiesen.

lowbyte

Hi

Und wie Wutz schon darauf hingewiesen hat ist 1024 * 1000 byte ungleich 1MB.
Das sollte schon eher heissen 1024*1024 == 1MB.

lowbyte