Načítanie zo súbora

ado130 · Napísal **ado130**: 01.11.2013 14:21

Dobrý deň,
prosím vás, mám takýto vstup:

Vstup.in: zobraziť

A ten by som potreboval nejakým spôsobom načítať, aby som mal prístup ku každému znaku(jednotlivé čísla), resp. slovu(zatancuj si so mnou...) alebo celému riadku(ako je otočený ten nápis "LENKA", ktorý budem musieť potom v prog. správne vypísať).

Zatiaľ mám niečo takéto:

Riadky: zobraziť

Alebo toto

Riadky: zobraziť

To nie je moc vhodné.
Čo v podstate funguje, lenže to mi len prečíta po riadkoch a vypíše ho, takže ho nemám nikde uložený(som myslel, že ten riadok uložiť do pola, následne ho "rozstrihať" napr. pomocou strtok a potom tak k nemu pristupovať) a aj počet riadkov píšem len manuálne. Tam som skúšal niečo takéto, tu mi aj vypíše číslo 23, lenže následne vypisuje len prázdne riadky.

Počet riadkov: zobraziť

BTW ide o C.
Vopred ďakujem za akúkoľvek pomoc.

BX · Napísal BX: 01.11.2013 15:04

No a kde máš problém? Nevieš pracovať s polom? Riadok načítať vieš...

ado130 · Napísal autor témy **ado130**: 01.11.2013 15:14

Áno, neviem ako by som jednotlivé riadky zapísal do pola.
Napr. riadok[0] - 1. riadok, riadok[1] - 2. riadok, atď.
Takže potom by som mohol k ním tak pristupovať, následne si ich cez http://www.cplusplus.com/reference/cstring/strtok/ rozdeliť na jednotlivé časti, ktoré budem potrebovať.

BX · Napísal BX: 01.11.2013 15:30

No princíp je jednoduchý. Ak to ale má byť v čistom C-čku, tak sa trochu veru potrápiš na réžií pola. Potrebuješ totiž pole zväčšiť podľa potreby.
Povedzme, že sa môžeš aspoň spoliehať na nejakú maximálnu dĺžku riadka. Tak si urobíš (dynamicky!) pole[10][MAX_DLZKA_RIADKA], takže predpokladáš 10 riadkov. Tak prečítaš riadky (trebárs cez funkciu gets) a ukladáš ich postupne do pola.
Ak ale prídeš k 11. riadku, musíš pole zväčšiť cez funkcie realloc, alebo znovu free+malloc.

Takto to nacpeš všetko do pamäte, ale porozmýšľaj skôr, či riadky nemôžeš spracovávať postupne. Bolo by to rozumnejšie.

ado130 · Napísal autor témy **ado130**: 01.11.2013 15:39

No ja počet riadkov budem vedieť. Keďže budem mať k dispozícií vstupný súbor, tak počet riadkov si môžem odčítať, prípadne si to vypíšem celé a pridám aj riadkovanie, takže zistím koľko riadkov má súbor.

Kód:

for(i=1;i<=23;i++) {
    printf("%d. ", i);
    do {
         riadok = fgetc(fr);
         fputc(riadok, stdout);
     } while (riadok != '\n'); 
}

Len neviem ako tie riadky dám do poľa.

BX · Napísal BX: 01.11.2013 15:45

Kód:

char ** pole = malloc( 23 * sizeof(pole) );
for(i=0;i<23;i++) { // pole sa indexuje od nuly!
    printf("%d. ", i);
    pole[i] = malloc( 256 * sizeof(char) ); // max dĺžka riadka je 256
    gets( pole[i] );
}

malo by to ísť, snáď som to nedoplietol.

Videl si už niečo takéto vôbec?

ado130 · Napísal autor témy **ado130**: 01.11.2013 15:51

To je dobrá otázka, práve že ani nie, resp. nejak neviem ako mi to teraz v tomto konkrétnom probléme pomôže, pri zapisovaní riadka do toho poľa.

BX · Napísal BX: 01.11.2013 15:51

Vieme čo je pole? A ako sa s ním v C-čku pracuje?

ado130 · Napísal autor témy **ado130**: 01.11.2013 15:58

Áno, teda podľa toho akú prácu, ale bohužiaľ len nejaké začiatky.
Asi som sa pustil do moc zložitej úlohy, išlo mi totiž len o to načítanie riadku a následnú prácu s ním.

BX · Napísal BX: 01.11.2013 16:02

Tak si urob pre začiatok pole staticky, na začiatku ako pole[25][256] a urob (pre jednoduchosť si požičiam kód z http://www.cplusplus.com/reference/cstdio/fgets/ Ak ti niečo nebude jasné, študuj v dokumentácií)

Kód:

#include <stdio.h>

int main()
{
   FILE * pFile;
   char pole[25][256];
   int r = 0, i;

   pFile = fopen ("file.txt" , "r");
   if (pFile == NULL) perror ("Error opening file");
   else {
     if ( fgets (pole[r] , 256, pFile) != NULL )
     {
          r++;
     }
     fclose (pFile);
   }

   for( i = 0; i < r; i++ )
       puts( pole[i] );

   return 0;
}

Funguje to?

(btw. pred tým som písal o funkcií gets, mala to byť samozrejme fgets pre čítanie zo súboru, pardon)

ado130 · Napísal autor témy **ado130**: 01.11.2013 16:09

Ten prog. čo si poslal teraz, tak mi vypisuje 1. riadok zo súboru file.txt

BX · Napísal BX: 01.11.2013 16:15

Hej, teraz som si to všimol. Je tam jednoduchá chyba. Aby si tomu viac porozumel, skús prísť na to, kde je

ado130 · Napísal autor témy **ado130**: 01.11.2013 16:21

Len trochu neviem čo chceš aby to robilo?

BX · Napísal BX: 01.11.2013 16:24

Uloží všetky riadky súboru do pola. Na konci ich cez for vypíšeš pre kontrolu. To snáď chceš, nie?

ado130 · Napísal autor témy **ado130**: 01.11.2013 16:25

Áno presne to, tak skúsim nájsť tú chybu.

Edit: Keď ma aj zastrelíš neviem, netuším kde, resp. v čom je tá chyba.
Jedine čo ma napadlo, je

Kód:

#include <stdio.h>

int main()
{
   FILE * pFile;
   char pole[25][256];
   int r = 0, i, lines;

   pFile = fopen ("file.txt" , "r");
   if (pFile == NULL) perror ("Error opening file");
   else {
   for(lines=0;lines<=9;lines++){
     if ( fgets (pole[r] , 256, pFile) != NULL )
     {
          r++;
     }
   }
     fclose (pFile);
   }

   for( i = 0; i < r; i++ )
       puts( pole[i] );

   system("PAUSE");
   return 0;
}

Takže by to mohlo vyzerať nejak takto?:

Spoiler: zobraziť

BX · Napísal BX: 01.11.2013 16:50

Poznáš aj iný cyklus ako for? Čo taký while? Nehodil by sa tam niekde?

ado130 · Napísal autor témy **ado130**: 01.11.2013 17:06

Tak môže byť, napríklad takto?:

Kód:

#include <stdio.h>

#define LINES 9

int main()
{
   FILE * pFile;
   int r = 0, i, j, line;
   char ** pole = malloc( LINES * sizeof(pole) );

   pFile = fopen ("file.txt" , "r");
   if (pFile == NULL) perror ("Error opening file");
   else {
        
        for(i=0;i<LINES;i++) { 
        pole[i] = malloc( 256 * sizeof(char) ); 
        }
        
         while(r != LINES){
                if ( fgets (pole[r] , 256, pFile) != NULL ) r++;
         }
         fclose (pFile);
   }

   for( j = 0; j < r; j++ )
       puts( pole[j] );


   system("PAUSE");
   return 0;
}

BX · Napísal BX: 01.11.2013 17:10

Joj nie, to čo je :lol:

Kašli teraz na dynamickú alokáciu. Nechaj to staticky ako som to napísal.

Takto, funkcia fgets načíta jeden riadok a vráti NULL, ak už nemá čo načítavať. A teda vtedy, keď už všetko prečítala. Takže potrebujem cyklus
kým( funkcia fgets() nevráti NULL ) posuň index riadku;

Takže v tom mojom chybnom kóde stačí nahradiť slovícko if za slovíčko while a voala...

ado130 · Napísal autor témy **ado130**: 01.11.2013 17:20

Áha, to ma mohlo napadnúť, pozerám všetko robím nejakým ďalším zbytočným pridávaním premenných, funkcií, cyklov, ...
Takže už je to v podstate tak, ako som pôvodne chcel a môžem si tie riadky rozdeliť atď ako budem potrebovať.

Tebe patrí veľká vďaka, by som nad tým ešte asi mesiac maturoval..

Kód:

#include <stdio.h>

int main()
{
   FILE * pFile;
   char pole[25][256];
   int r = 0, i;

   pFile = fopen ("Vstup.in" , "r");
   if (pFile == NULL) perror ("Error opening file");
   else {
     while ( fgets (pole[r] , 256, pFile) != NULL )
     {
          r++;
     }
     fclose (pFile);
   }

   for( i = 0; i < r; i++ )
       puts( pole[i] );

   system("PAUSE");
   return 0;
}

BX · Napísal BX: 01.11.2013 17:24

A dokonca pozri, čo C-čko dokáže

Poriadne študuj teóriu čo ako funguje, veľmi ti to pomôže a všetko budeš robiť jednoducho a rýchlo

Kód:

else {
     while ( fgets (pole[r++] , 256, pFile) != NULL );
     fclose (pFile);
   }

ado130 · Napísal autor témy **ado130**: 01.11.2013 17:29

Áno máš pravdu, musím si lepšie prezrieť ten úvod, tak ešte raz vďaka.
Takže toto je staticky, ale hovoríš, že lepšie by bolo keby to bolo pomocou dynamickej alokácie pamäti?

BX · Napísal BX: 01.11.2013 17:30

Pri malých súboroch je to jedno, ale áno, všeobecne je vždy lepšie na väčší objem dát (ako napr. text) využívať dynamickú alokáciu pamäte.

ado130 · Napísal autor témy **ado130**: 01.11.2013 17:32

Aha tak, keď už sme pri tom, bolo by to nejako takto?:
Pri tom vstupe z 1. príspevku.

Kód:

#include <stdio.h>

int main()
{
   FILE * pFile;
   char ** pole = malloc( 23 * sizeof(pole) );
   int k = 0, i, j;

   pFile = fopen ("file.txt" , "r");
   if (pFile == NULL) perror ("Error opening file");
   else {
     for(i=0;i<23;i++) pole[i] = malloc( 256 * sizeof(char) ); // max dĺžka riadka je 256
     while ( fgets (pole[k++] , 256, pFile) != NULL );
     fclose (pFile);
   }

   for( j = 0; j < k-1; j++ )
       puts( pole[j] );

   system("PAUSE");
   return 0;
}

BX · Napísal BX: 01.11.2013 17:36

Ak to ide, tak je to správne. Ale tu je trochu zbytočné najprv prechádzať 23 krát a alokovať a potom znovu načítavať.
Môžeš naalokovať len prvý riadok (pole[0] = malloc...) a potom v tele cyklu while alokovať stále ďalší potrebný.

ado130 · Napísal autor témy **ado130**: 01.11.2013 19:20

Prosím ťa/vás, vedel by niekto zhruba poradiť, ako môžem rozdeliť daný ten riadok, ktorý mám uložený v poli, na jednotlivé znaky? Viem, teda myslím si, že to bude nejako pomocou funkcie http://www.cplusplus.com/reference/cstring/strtok/ ale vôbec neviem prísť nato.
Čiže podľa vstupu(1. príspevok), tak napr. v riadok[0] mám "9 66", a z toho potrebujem nejako dostať jednotlivé čísla 9 a 66.

Kód:

int a=1;
char *token;

token[0] = strtok(riadok[0], " ");
   while( token[0] != NULL ) 
   {  
      token[a] = strtok(NULL, " ");
      a++;
   }

Lenže, až tak "jednoducho" to nejde, ako som očakával.

Vopred veľmi ďakujem.

Celý_kód: zobraziť

BX · Napísal BX: 01.11.2013 19:59

ado130 píše:

Kód:

int a=1;
char *token;

token[0] = strtok(riadok[0], " ");
while( token[0] != NULL ) 
{  
   token[a] = strtok(NULL, " ");
   a++;
}

Aby si mohol robiť toto, potrebuješ zase dvojrozmerné pole - resp. pole reťazcov (keďže vieme, že v C-čku je reťazec pole znakov)
Takže toto ti pôjde

Kód:

char * token = strtok(pole[i], " \n\r");
while( token != NULL )
{
    printf( "token('%s')\n", token );
    token = strtok(NULL, " \n\r");
}

Ak chceš mať pole tokenov, musíš urobiť pole reťazcov, takže char * token[32]; {obmedzím max počet tokenov na 32} a až vtedy môžeš robiť to, čo robíš s premennou a.

ado130 · Napísal autor témy **ado130**: 01.11.2013 20:17

Neviem či som dobre pochopil ako myslíš, no dám sem radšej celý kód.
Inak len, vlastne toto celé sa snažím pochopiť z dôvodu, ako načítať ten súbor tak, aby som mohol pracovať s tými číslami(použiť ich pri výpočtoch), teda aby som mal v nejakých premenných alebo poli tie čísla : 9, 66, 52, ..., prípadne v jednom reťazci celý riadok http://paste2.org/4AMJa4CU(8.-14.)

Kód:

#include <stdio.h>

int main()
{
   FILE * rFile;
   FILE * wFile;
   int k = 0, j, a=0;
   char riadok[23][256];
   char * token[40];
   
   rFile = fopen ("Vstup.in" , "r");
   if (rFile == NULL) perror ("Error opening file");
   else {
     while ( fgets (riadok[k++] , 256, rFile) != NULL );
     fclose (rFile);
   }

   for( j = 0; j < k-1; j++ ) {
     printf("%d. ", j);
     puts( riadok[j] );
   }
   
   token[a] = strtok(riadok[a], " ");
   while( token[a] != NULL ) 
   {  
      a++;
      token[a] = strtok(NULL, " ");
   }
   
   system("PAUSE");
   return 0;
}

BX · Napísal BX: 01.11.2013 20:48

Veď dávaj si kus pozor na to indexovanie. Máš v ňom bordel. Uvedom si čo indexuješ čím.
Inak to robí presne to, čo chceš. Len si v tom musíš ešte utobiť nejaký systém a uložiť všetko, čo potrebuješ. Už vieš ako.

ado130 · Napísal autor témy **ado130**: 01.11.2013 21:24

Vlastne áno, tamto funguje pre 1. riadok, takže v token[0]=9 a token[1]=66, len neviem ako to "zopakovať" pre každý riadok
Nejaké 2 upozornenia:
24 [Warning] assignment makes pointer from integer without a cast --> token[a] = strtok(riadok[a], " ");
28 [Warning] assignment makes pointer from integer without a cast --> token[a] = strtok(NULL, " ");

A ako píšeš, mám v tom už asi pekný bordel..

BX · Napísal BX: 01.11.2013 21:34

Každé pole si predsa musíš indexovať samostatne. Ak chceš 1.,2.,3. token z prvého riadku, tak musíš urobiť niečo ako token[0] = strtok(riadok[0]...); token[1] = strtok(riadok[0]...); token[2] = strtok(riadok[0]...);
Nemôžeš preto všetko indexovať jednou premennou (a)
A ak chceš uložiť tokeny pre každý riadok, tak aj to musíš mať v dvojrozmernom poli (pole tokenov pre každý riadok)

Načítanie zo súbora

Podobné témy