[c] regeltje uit tekstbestand lezen

[Rogier]

else {

fgets(dummy[m], 90, lijst);

Niet dummy[m], maar dummy.

Je hoeft die overgeslagen regels toch niet te onthouden?

[Jeroen]

Nee dat klopt, dat realiseerde ik me ook ineens, ik heb nu dus dummy staan waar eerst dummy[m] stond en ik heb dummy gedeclareerd als char *dummy, ik dacht dat ik char dummy [100] ook geprobeer had, maar dat werkte niet dacht ik, vandaar dat ik het met zon pointer probeerde.

Hij crashed trouwens wel nog steeds nu. Dat lijkt toch een probleem te blijven als ik het grote bestand wil lezen. Ik heb het bestand bijvoorbeeld even ingekort tot 1000 regels, dat gaat prima, dan doet hij precies wat ik wil. Maar als ik dan mijn grote bestand van 170000 regels pak crashed hij.

Enig idee hoe ik dat kan voorkomen?

[Rogier]

Je doet trouwens nog wat foute dingen. Je doet al n+=1 (overigens is n++ m.i. bondiger en duidelijker) voor de eerste keer dat je regel[n] gebruikt. Dus regel[0] bevat op het eind nog ongeïnitialiseerd geheugen (lees: random crap ) en de laatste regel[n] die je vult valt buiten je buffer (je overschrijft dan een random deel ergens in het geheugen).

Daarnaast nog wat dingen die niet strikt onjuist zijn, maar wel veel handiger zijn om het anders te doen:

- Hoe kom je aan aantal_regels, of hoe wordt dat gedefinieerd? Ik zou zeggen: je gaat bijvoorbeeld eerst het hele bestand een keer langs (voor iedere regel een fgets(dummy)) en telt zodoende het aantal_regels (en daarna een rewind om echt te gaan lezen). Maar aantal_regels is bij jou zo te zien geen variabele, anders kun je geen dingen als int id[aantal_regels] enzo doen...? (dat kan namelijk alleen met constantes)

- In plaats van tien keer ((aantal_regels/3)+1) te gebruiken, eenmalig een aantal_zinnige_regels ofzo definiëren

- Die str0, str4 en str7 hoef je waarschijnlijk niet voor alle (zinnige) regels te bewaren. Je bewaart immers ook al de complete regels, en de geconverteerde waarden (id, type1, en type2).

- In plaats van die str0, str4 en str7 en dan atoi() kun je met sscanf ook rechtstreeks naar integers lezen. Zet op die plaatsen %d in plaats van %s in de format string, en geef pointers naar ints mee in plaats van pointers naar char pointers.

- Je alloceert nu voor alle (zinnige) regels het maximale aantal karakters (100), terwijl de meeste regels waarschijnlijk niet zo lang zijn. Nou is dat voor 300.000 regels van ieder max 100 bytes geen probleem, maar beter zou zijn om van te voren te bepalen hoe groot die data van alle zinnige regels in totaal is (dat kan bijvoorbeeld in die eerste stap waar je aantal_regels bepaalt), dan één buffer alloceren, en de regel pointers naar de juiste plekken in die ene grote buffer laten pointen.

- Grote buffers (of buffers waarvan je van te voren niet weet of en hoe groot ze zijn) moet je met malloc of new alloceren.

[Jeroen]

Ok, bedankt voor alle tips, ik zal hier morgen eens mee aan de slag gaan.

Die "aantal_regels" komt trouwens hiervandaan (staat boven die andere code):

FILE* lijst;

char line[90];

int aantal_regels=0;

lijst = fopen("Test_mergers.dat","r");



while ( fgets(line, 90, lijst) != NULL) aantal_regels++; //Telt de regels

printf("Dit bestand heeft %d regels.\n\n", aantal_regels);

rewind(lijst);

Maar het is dus wel een constante, dit blijft hetzelfde door het hele programma heen.

[Jeroen]

Ik heb wat dingetjes aangepast, dit staat nu in de main():

FILE* lijst;

int lengte_regel=90;

int lengte_string=10;

char line [lengte_regel]; //dummy

int aantal_regels=0;

int i=0,n=0;

lijst = fopen("Test_mergers.dat","r");

while ( fgets(line, lengte_regel, lijst) != NULL) aantal_regels++; //telt aantal regels

printf("Dit bestand heeft %d regels.\n\n", aantal_regels);

rewind(lijst);

int size = ((aantal_regels/3) - 1); //grootte van de gebruikte data (1/3 van de regels, -1 omdat de array bij nul begint)

char regel[size] [lengte_regel];

char *dummy;

//char str0[size] [lengte_string]; //id

//char str4[size] [lengte_string]; //type1

//char str7[size] [lengte_string]; //type2

int id[size];

int type1[size];

int type2[size];

for (i=0;i<aantal_regels;i++){

Als ik die str0,4 en 7 niet meer gebruik gaat het ineens fout, dan crashed hij. Daarvoor gaat alles prima ( met die atoi() ), waarom crashed hij nu ineens?

[Jeroen]

Doordat je wat extra had vertelt over pointers enzo, bedacht ik me dat ik in een voorbeeld ook & tekentjes zag staan. Nu werkt dat wel.

Maar waar 1 probleem is opgelost ontstaat er vanzelf wel weer een ander...

Ik heb nu wat proberen te doen met calloc en malloc. Ik heb dit in bovenstaand programma aangepast:

char *dummy;

int *id;

int *type1;

int *type2;



id = (int*) calloc (size,sizeof(int));

type1 = (int*) calloc (size,sizeof(int));

type2 = (int*) calloc (size,sizeof(int));



dummy = (char*) malloc (lengte_regel + 1);

Dat werkt allemaal, maar als ik ditzelfde wil toepassen (die malloc) voor "line" helemaal bovenin mijn programma, dan crashed hij ineens. Hiervan weet ik echt niet waar het door kan komen, dus hier heb ik wel hulp nodig ben ik bang...

[Rogier]

Ik zie zo gauw dit:

int size = ((aantal_regels/3) - 1); //grootte van de gebruikte data (1/3 van de regels, -1 omdat de array bij nul begint)

Die -1 lijkt me fout, dat een array bij index 0 begint te tellen wil niet zeggen dat hij een element minder hoeft te bevatten.

Als size=10 dan heeft de array voorbeeld[size] ruimte voor tien elementen, met index [0] t/m [/9].

Wat voor compiler gebruik je trouwens? Want die arrays met grootte [size] (waarbij size een variabele is, ook al bepaal je hem eenmalig en verandert hij daarna niet meer) zou niet moeten kunnen, dat moet normaal -vanuit de compiler's perspectief- een constante zijn,

[Jeroen]

Ik gebruik het programma devcpp, dat gebruikte we op school ook.

Is dat gedoe met malloc en calloc wel goed? Want als het werkt hoeft het blijkbaar niet meteen goed te zijn.