C programozás

Kezdőlap Fórumok Programozás C programozás

10 bejegyzés megtekintése - 281-290 / 352
  • Szerző
    Bejegyzés
  • #2016376
    sipdav
    Felhasználó

      Más. Azt hogyan lehet kezelni, hogyha nem tudom előre a várható sormennyiséget (ami a konkrét esetben char *tomb[20]; – ra van beégetve)

      #2016377
      uzsolt
      Felhasználó
        sipdav wrote:
        Köszi, de ezt hogyan is?:)

        strdup

        sipdav wrote:
        Más. Azt hogyan lehet kezelni, hogyha nem tudom előre a várható sormennyiséget (ami a konkrét esetben char *tomb[20]; – ra van beégetve)

        char **tomb

        #2016378
        gabaman
        Felhasználó
          sipdav wrote:
          Eddig többnyire perlben dolgoztam ezért kissé még sokatlan ez a pointer-tömbös játék

          Ez esetben könnyebb lehet a C++ használata (kivétel- és hibakezelés nélkül):

          Code:
          #include
          #include
          #include
          #include

          #define HOSSZ 255

          void fileReader ();
          void fileWriter (std::vector &tomb);

          int main (int argc, char *argv[])
          {
          fileReader ();
          return 0;
          }

          void fileReader () {
          std::vector tomb;

          std::ifstream file („/home/cucc/szoveg.txt”);
          char sor[HOSSZ];

          while(!file.eof()) {
                          file.getline (sor,HOSSZ);
          tomb.push_back (sor);
          }
          fileWriter (tomb);
          }

          void fileWriter (std::vector &tomb) {
          for (int index = 0; index < tomb.size(); ++index) std::cout << tomb[i]; }

          #2016379
          sipdav
          Felhasználó

            Köszi – az indexelés gondolom csak elgépelés volt (i):
            void fileWriter (std::vector &tomb) {
            for (int index = 0; index < tomb.size(); ++index)
            std::cout << tomb[index];
            }
            De így sem olvassa be a szövegfájlt – nekem legalábbis.

            #2016380
            gabaman
            Felhasználó
              sipdav wrote:
              Köszi – az indexelés gondolom csak elgépelés volt (i):
              void fileWriter (std::vector &tomb) {
              for (int index = 0; index < tomb.size(); ++index)
              std::cout << tomb[index];
              }

              Sorry, tényleg elgépelés.

              sipdav wrote:
              De így sem olvassa be a szövegfájlt – nekem legalábbis.

              Ez két ok miatt is lehetséges, vagy kicsi az olvasási puffer (növeld meg), vagy a hiányzó sor vége jel miatt egybefolyik. Nem tudom hogy dolgozod fel, két helyen is módosítni lehet:

              Code:
              file.getline (sor,HOSSZ);
              tomb.push_back (sor);
              tomb.back() += „n”;

              vagy

              Code:
              for (size_t index = 0; index < tomb.size(); ++index) std::cout << tomb[index] << std::endl;

              Ha teszel bele hibakezelést is, látni fogod ha nem a kódolás miatt következik be a probléma.

              #2016381
              sipdav
              Felhasználó

                Köszi…megnézem.
                Tényleg van olyan szituáció, amikor jobb C-ben megírni valamit mint c++ – ban?

                #2016382
                sipdav
                Felhasználó

                  Amúgy továbbra sem ír ki semmit. Fut, majd egy idő után kiírja az eclipse konzoljára:
                  terminate called after throwing an instance of ‘std::bad_alloc’
                    what():  std::bad_alloc

                  #2016383
                  sipdav
                  Felhasználó

                    C-ben végülis így oldottam meg – a javaslat alapján cilusba tettem a memória allokációt (+ a vizsgélatot újabb függvénybe)
                    int memOccSucceed (char *par) {
                    if (par == NULL) {
                    exit(1);
                    }
                    else {
                    return 0;
                    }
                    }

                    int fileReader () {
                    FILE *FILEIN;
                    char *tomb[20];
                    int i=0;

                    FILEIN = fopen(„/home/cucc/szoveg.txt”, „r”);
                    char *sor;
                    size_t hossz=255;
                    sor = malloc(hossz);

                    memOccSucceed(sor);
                    while(getline(&sor,&hossz,FILEIN) != -1) {
                    tomb=sor;
                    i++;
                    sor = malloc(hossz);
                    memOccSucceed(sor);
                    }
                    free(sor);
                    fileWriter (tomb, i);
                    return 0;
                    }

                    #2016384
                    pointux
                    Felhasználó

                      Ha szabad még belekotyogni, akkor itt egy lehetséges megoldás:

                      Code:
                      #include
                      #include
                      #include #include

                      /* Ez nyugodtan lehet egy jóval nagyobb szám is, hátha hosszabb a sor
                        (végül is 1x kell neki lefoglalni a memóriát)
                        a 4096 egy elég nagy szám
                      */
                      #define MAX_LENGTH 4096

                      /* Én osztályokkal oldanám meg, mert elegánsabb, áttekinthetőbb (de nem lényeges)
                          Konstruktor jó, ha van, mert egyébként csinál magának „valamit”; destruktor is lehet, de nem feltétlen szükséges
                          Ha már tároló tárolójáról van szó, én listába tenném; a random iterátoros dolog itt erős túlzás
                          Ha a filenév nem változhat, akkor legjobb eleve a konstruktorba tenni
                      */
                      class FileClass {
                          std::list < std::string > lineList;
                         
                          public:

                      FileClass () {};

                      void reader ( const std::string& fileName );
                      void writer ();
                      };

                      /* A file nyitásban, sor olvasásban és a listaelem hozzáadásában lehet hiba
                          Javaslom a throw, a fügvény hívásakor a try catch használatát – elvégre C++
                          Nem elfeletkezni a file lezárásáról sem
                          A puffer lehet dinamikus, de ekkora méret esetén fölösleges
                          Ha nem kell külön sor(t kezelni), akkor én egy sztringbe olvasnám be
                      */
                      void FileClass::reader ( const std::string& fileName ) {
                          std::ifstream file;
                          char charBuf [ MAX_LENGTH ];
                         
                          file.open ( fileName.c_str () );
                             
                          while ( file.good () ) {
                      file.getline ( charBuf, MAX_LENGTH );
                      lineList.push_back ( std::string ( charBuf ) );
                          }
                         
                          file.close ();
                      }

                      /* Sima egymás utáni iterátoros adatelérés – a következő mutatót közvetlenül a struktúra adatából veszed, tehát elég gyors
                          Endlt javaslom a n helyett, mert egyből kiírja a puffert – itt ugyan mindegy, sőt elvileg a n gyorsabb, de hiba esetén jól jön
                      */
                      void FileClass::writer () {
                          for ( std::list < std::string > ::iterator lineIterator = lineList.begin (); lineIterator != lineList.end (); lineIterator ++ )
                      std::cout << *lineIterator << std::endl; } /* Mi sem egyszerűbb */ int main ( int argc, char *argv [] ) {     FileClass fileClass;     fileClass.reader ( "a file neve" );     fileClass.writer ();     return 0; }

                      #2016385
                      pointux
                      Felhasználó

                        Hát a sok kommentár miatt valami komolynak látszik :))), de amúgy egyszerű és jóval áttekinthetőbb, mint egy C kód.

                      10 bejegyzés megtekintése - 281-290 / 352
                      • Be kell jelentkezni a hozzászóláshoz.