---

Hej

Jeg har lige pløjet mig igennem Teach Yourself C in 21 days, og
forsøger nu at lave et lille program der kan læse en
semikolon-separeret tekst.

Programmet indlæser teksten fra en fil til et område i
hukommelsen. Herefter udskifter det ';' med '\0' og gemmer
adressen på næste tegn i en pointer i et array. Hver pointer
peger nu på første tegn efter hver semikolon. Så langt så godt.

Problemet er, at jeg gerne vil skabe det her array dynamisk og
udvidde det i takt med at der findes semikolon i teksten. Jeg har
en idé om at det kan gøres med realloc(), men jeg har ikke fået
det til at virke. Problemet er nok at jeg er i tvivl om hvordan
jeg skal 'deklarere' et array af pointere så det kan udviddes.

Samtidig har jeg et andet ønske, nemlig at mit array skal være
to-dimensionelt - derfor de to variabler lines og rows. Skal
arrayet deklareres på en speciel måde for at gøre det
to-dimensionelt?


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

int main()
{
   FILE *fp;
   long filesize=0L, count=0L;
   int rows=0, lines=0;
   char *ptext, *parray[10];

   if ((fp = fopen("semi.txt", "rb")) == NULL)
   {
      fprintf(stderr, "Error opening semi.txt");
      exit(1);
   }

   rewind(fp);
   fseek(fp, 0L, SEEK_END);
   filesize = ftell(fp);
   rewind(fp);

   ptext = malloc((size_t) filesize);

   fread(ptext, sizeof(char), (size_t) filesize, fp);
   fclose(fp);

   parray[0] = ptext;

   for (count = 0; count <= filesize; count++)
   {
      if (ptext[count] == ';')
      {
         ptext[count] = '\0';
         rows++;
         //realloc(parray, sizeof(parray) + sizeof(char));
         parray[rows] = &ptext[count+1];
      }
      else if (ptext[count] == 13)
      {
         ptext[count] = '\0';
         count += 2;
         parray[rows] = &ptext[count];
         lines++;
      }
   }

   for (count = 0; count <= rows; count++)
         printf("%s\n", parray[count]);

   free(ptext);

   return 0;
}
==========================================

På forhånd tak....



--
Med venlig hilsen
Thomas L. Christensen, Svendborg

---

"Thomas L. Christensen" <tlc@REMget2net.dk> wrote in message
news:s41cou4mfganuqjb81r6114fi3ocan3cd3@news.cybercity.dk...

> Jeg har lige pløjet mig igennem Teach Yourself C in 21 days, og

Hvad tog det så? 21 dage? :)

> Problemet er, at jeg gerne vil skabe det her array dynamisk og
> udvidde det i takt med at der findes semikolon i teksten. Jeg har
> en idé om at det kan gøres med realloc(),

Jep.

> men jeg har ikke fået
> det til at virke. Problemet er nok at jeg er i tvivl om hvordan
> jeg skal 'deklarere' et array af pointere så det kan udviddes.

Det kan man ikke - men du kan have en variabel som er en pointer til en
pointer. Den vil så pege på første element (som selv er en pointer) i dit
array.
I C er et array jo "næsten det samme som" en pointer til første element.

Sådan kan du gøre (skitse):

char ** p = (char **) malloc(array_size * sizeof(char*));
/* ... */
p = (char **) realloc(new_array_size * sizeof(char*));

> Samtidig har jeg et andet ønske, nemlig at mit array skal være
> to-dimensionelt - derfor de to variabler lines og rows. Skal
> arrayet deklareres på en speciel måde for at gøre det
> to-dimensionelt?

Ved statisk allokering: (char*) p [lines][rows];

Ved dynamisk allokering:
(char*) p [][rows] = ( (char*)[][rows]) malloc
(lines*rows*sizeof(char*));
(tror jeg nok)
men det kræver at du kender "rows" statisk (dvs. det er en konstant).
Hvis ikke, kan du ikke bruge multidimensionale arrays, men må kode det
direkte (ved selv at beregne index i det endimensionale array). Derved får
du også et problem når du realloc'er med at udvide antallet af rows - der
skal noget speciel kopiering til (linie for linie) og så er du måske bedst
tjent med at malloc'e og kopiere, frem for at realloc'e.

Endelig er der den mulighed at du laver et array af arrays.
Så får du tripple-pointere, og så er det altså lige før det ikke er sjovt
længere .


Mvh. Bjarke

---

"Bjarke Dahl Ebert" <bebert@worldonline.dk> wrote:

>> Jeg har lige pløjet mig igennem Teach Yourself C in 21 days, og
>
>Hvad tog det så? 21 dage? :)

Nej, faktisk kun en 10 dages tid. Men jeg havde også smugtrænet
lidt i forvejen...

Og ja, det kunne godt være at jeg skulle have givet mig lidt
bedre tid, så jeg også havde _forstået_ lidt mere af det.
Specielt det her med pointere og arrays... :-/

[snip snip snip]

>Sådan kan du gøre (skitse):
>
>char ** p = (char **) malloc(array_size * sizeof(char*));
>/* ... */
>p = (char **) realloc(new_array_size * sizeof(char*));
>

[snip - to-dimensionelt?]
>
>Ved statisk allokering: (char*) p [lines][rows];
>
>Ved dynamisk allokering:
> (char*) p [][rows] = ( (char*)[][rows]) malloc
>(lines*rows*sizeof(char*));
>(tror jeg nok)

Jeg synes det ser urimeligt kompliceret ud, men hvis det er sådan
det skal være, så er det vel sådan... Det der med at 'rows' skal
være statisk er ikke det store problem - jeg kan lave en funktion
der tæller antallet af semikolon indtil første linieskift. Der er
det samme antal 'rows' i hver linie, så det er bare en enkelt
gang den skal køre.

Du skal have tak for dit svar. Jeg vil lige prøve at arbejde
videre med det og se hvad jeg kan fuske mig frem til. I'll be
back...


--
Thomas L. Christensen - Svendborg
Take a class. Read a book. Don't expect computers to be simple
because they are not!

---

[ Thomas L. Christensen ]

[ ... ]

> Jeg har lige pløjet mig igennem Teach Yourself C in 21 days,


Uff, uff!


> Programmet indlæser teksten fra en fil til et område i hukommelsen.
> Herefter udskifter det ';' med '\0' og gemmer adressen på næste tegn
> i en pointer i et array. Hver pointer peger nu på første tegn efter
> hver semikolon. Så langt så godt.


Mao. du vil stykke opp en fil i "linjer" der ';' er linjeslutt samt at
du skal ha en array der hvert i'te element er en peker til i'te linje?


> Problemet er, at jeg gerne vil skabe det her array dynamisk og
> udvidde det i takt med at der findes semikolon i teksten. Jeg har en
> idé om at det kan gøres med realloc(), men jeg har ikke fået det til
> at virke. Problemet er nok at jeg er i tvivl om hvordan jeg skal
> 'deklarere' et array af pointere så det kan udviddes.


Selv om C i sin nyere utgave fikk VLA'er[*], må man nok krype til
korset og bruke de gamle teknikkene -- du vil ha en peker til en rekke
av elementer av type T, der hver T representerer dine linjer. Denne
"rekken" skal kunne utvides dynamisk.

Det første skrittet er å uttrykke dette på engelsk:

T => pointer to char
result => pointer to T, iow pointer to pointer to char

Og så forteller man dette til cdecl[**]:

$ cdecl
Type `help' or `?' for help
cdecl> declare filedata as pointer to pointer to char
char **filedata
cdecl>

Altså, skal man ha "char **filedata". Det neste skrittet er å
konsultere postinger til Chris Torek[***] eller å slå opp i en
skikkelig bok om akkurat dette emnet[****].


> Samtidig har jeg et andet ønske, nemlig at mit array skal være
> to-dimensionelt - derfor de to variabler lines og rows. Skal arrayet
> deklareres på en speciel måde for at gøre det to-dimensionelt?


Som sagt, du vil neppe ha en array, da disse er objekter hvis
størrelse er kjent compile time (man har VLA'er i C99, men jeg tror
ikke det hjelper her).

Det du vil ha, derimot, er en funksjon, som gitt en "filedata" slik
deklarert over, øker den, slik at du kan legge inn en og en linje,
uten å måtte bry deg om masse annet fjas.

Hvis man tegner dette i ASCII art (bruker fast fontbredde), ser dette
slik ut:

datafilen:
[start]
a quick;brown;fox;jumps;over;a;lazy;dog
[end]

ptext
+-------------------------------------------------+
|a\0quick\0brown\0fox\0jumps\0over\0a\0lazy\0dog\0|
+-------------------------------------------------+
^ ^ ^ ^ ^
| | | | |
| | -----+ | |
| / / +---------+ |
| | | | -----------------------------+
| | | / /
+|+|+|+|+ +|+
|||||||| ... |||
+-+-+-+-+ +-+
parray


> #include <stdio.h>
> #include <stdlib.h>
>
> int main()
> {
>    FILE *fp;
>    long filesize=0L, count=0L;
>    int rows=0, lines=0;
>    char *ptext, *parray[10];


char *ptext = NULL, **parray = NULL;

Det er litt viktig å initialisere disse.


>    if ((fp = fopen("semi.txt", "rb")) == NULL)
>    {
>       fprintf(stderr, "Error opening semi.txt");
>       exit(1);
>    }
>
>    rewind(fp);
>    fseek(fp, 0L, SEEK_END);
>    filesize = ftell(fp);
>    rewind(fp);
>
>    ptext = malloc((size_t) filesize);


/* to compensate for the terminating '\0' */
ptext = malloc( (size_t)filesize + 1UL );


>    fread(ptext, sizeof(char), (size_t) filesize, fp);


ptext[ filesize ] = '\0';


>    fclose(fp);


Du trenger ikke sizeof( char ), den _skal alltid_ være 1.

Bruk _aldri_ magiske koder à la 13. Dersom du mener '\n', si nettopp
det. 13 er bare slitsomt å se på.

Herfra kan man gjøre det slik -- løper gjennom ptext og teller hvor
mange ';'-linjer det skal være, samtidig som man "vokser" parray:

/* how many elements have been allocated in parray */
size_t allocated = 1UL;
/* how many lines have been processed */
size_t line_count = 0UL;
/* logical line delimiters in the file */
const char delimiters[] = ";\n";
/* allocate 1 line to begin with */
parray = grow_array( parray, allocated );

char *token = strtok( ptext, delimiters );
while ( token ) {
/* there isn't enough space for the next line */
if ( allocated <= line_count ) {
   /* double parray in size */
allocated *= 2;
   parray = grow_array( parray, allocated );
}

parray[ line_count ] = token;
++line_count;
token = strtok( NULL, delimiters );
}
parray[ line_count ] = NULL;

Utskriften kan ordenes således:

size_t index;
for ( index = 0UL; parray[ index ] != NULL; ++index )
printf( "line %zo: %s\n", index, parray[ index ] );

Evt., dersom kompilatoren dni ikke vet hva %zo er, bruker man %ull:

printf( "line %ull: %s\n", (unsigned long long)index, parray[ index ] );

Du kan naturligvis referere til en enkel bokstav i hver linje som
parray[ line ][ column ] (dog, vær forskiktig med hvilke verdier
column antar). Dette er ikke helt det samme som todimensjonal array,
men kanskje det er tilstrekkelig for dine behov?

Det nest siste skrittet er å lage grow_array. Som du antydet, bruker
man realloc til formålet:

void*
grow_array( char **old, size_t new_size )
{
void *tmp = realloc( old, new_size * sizeof *old );
/* error checking */
return tmp;
}

Det aller siste skrittet er å innse begrensninger av løsningen:

* den takler dårlig filer som inneholder '\0'
* den bruker kanskje relativt mye minne (fordobling av størrelsen er
en vanlig "vokseteknikk", men det har sine ulemper)
* strtok har sine særegenheter som man er nødt til å være klar over
* Noe annet?

Som sagt, bare et eksempel.





ivr
[*] Variable Length Arrays. Dog, jeg har vansker med å se hvordan
VLA'ene skulle ha hjulpet her. Man kan selvsagt løpe gjennom dataene
to ganger -- en for å telle antall "linjer" du skal ha, og den andre
for å fikse pekere i parray, men det kan man like gjerne greie seg
uten VLA'ene
[**] cdecl er et fryktelig nyttig program. Det å dekode deklarasjonen
av signal på SYS V er _ikke_ enkelt den første gangen man ser den.
[***] Chris Torek skrev utallige ganger på njus hva en peker og en
array er. Ta en titt fx. her <URL:http://67.40.109.61/torek/c/pa.html>
[****] Peter van der Linden har skrevet en av de bedre bøkene om C --
"Expert C Programming: Deep C Secrets". I tillegg til å ha valgt en svært
humoristisk fremstilling av de mindre finere deler av C, synes det at
mannen jobbet for SunSoft og han mobber Microsoft for alt han er god
for. Dette er en veldig underholdende og lærerik bok.
--
<peder> igorr: tcl ja... det er fra de dypeste avgrunnene i helvete det...
<peder> php er bare fra foajeen
            -- pederst på irc

---

igorr@ifi.uio.no (Igor V. Rafienko) wrote:

>[ Thomas L. Christensen ]
>> Jeg har lige pløjet mig igennem Teach Yourself C in 21 days,
>
>Uff, uff!
>
Hehe... arh, der findes vel værre bøger? Jeg har egentlig været
lidt positivt overrasket over den. Jeg kendte godt lidt til C i
forvejen, men ville gerne friske det lidt op, specielt have lidt
bedre styr på det med pointere. Som en bog til begynderen synes
jeg den er god, fordi den præsenterer stoffet i en meget let
læselig form. Gode eksempler, god pædagogik. Jeg er lidt skuffet
over de sidste syv dage, som er de mere avancerede emner - her
synes jeg det bliver gået for let hen over det.

Det er specielt irriterende når de samtidig har valgt at bogen
skal indholde en "bonus-uge" om OOP, C++ og JAVA. De 150 sider
var bedre brugt på at gå i dybden med C - man køber sgu da ikke
en bog om C for at læse om JAVA! Argh...!!


[snip snip snip]


Det er et imponerende grundigt svar du giver. Jeg læste det i går
aftes og kan se at der er mange guldkorn. Jeg skal lige bruge
lidt tid på at gå lidt mere i detaljer med det og prøve det af,
hvilket jeg nok først rigtig får tid til her i næste weekend. Jeg
vender tilbage - hvis ikke med flere spørgsmål, så med en bud på
hvordan jeg vil lave løsningen.

Du skal have tak for et meget grundigt og fyldigt svar.

--
Thomas L. Christensen - Svendborg
GEOS? - www.tvakatter.com

---

On 16 Sep 2002 21:44:49 +0200, igorr@ifi.uio.no (Igor V. Rafienko)
wrote:

>Det nest siste skrittet er å lage grow_array. Som du antydet, bruker
>man realloc til formålet:
>
>void*
>grow_array( char **old, size_t new_size )
>{
> void *tmp = realloc( old, new_size * sizeof *old );
> /* error checking */
> return tmp;
>}
>
>Det aller siste skrittet er å innse begrensninger av løsningen:
>
>* den takler dårlig filer som inneholder '\0'
>* den bruker kanskje relativt mye minne (fordobling av størrelsen er
> en vanlig "vokseteknikk", men det har sine ulemper)
>* strtok har sine særegenheter som man er nødt til å være klar over
>* Noe annet?
Er det ikke noget "snask", som du selv siger bruger denne løsning
MEGET hukommelse. Det bliver vel en noget langsom funktion.

/Thomas

---

[ Thomas Lykkeberg ]

[ ... ]

> >void*
> >grow_array( char **old, size_t new_size )
> >{
> > void *tmp = realloc( old, new_size * sizeof *old );
> > /* error checking */
> > return tmp;
> >}

[ ... ]

> Er det ikke noget "snask", som du selv siger bruger denne løsning
> MEGET hukommelse. Det bliver vel en noget langsom funktion.


Gjennomsnittlig konstant tidsforbruk er egentlig ikke så veldig ille.
Og i verste tilfellet O(2N) plass, der N er antall linjer. Om antall
tegn ikke er så veldig høyt, kan man ta en konservativ antagelse:

parray = malloc( (filesize / 2) * sizeof *parray );

Rent pragmatisk, dersom antall linjer nærmer seg en markant del av
hukommelsen på maskinen, bør man vurdere en annen stragegi.





ivr
--
<peder> igorr: tcl ja... det er fra de dypeste avgrunnene i helvete det...
<peder> php er bare fra foajeen
            -- pederst på irc

---

[ Igor V. Rafienko ]

[ ia32 asm tar hardt på mine skriftlige evner ]

[ ... ]

> Rent pragmatisk, dersom antall linjer nærmer seg en markant del av
> hukommelsen på maskinen, bør man vurdere en annen stragegi.


.... enn dobling.

I tillegg, setningen i min opprinnelige posting skulle være

"the quick brown fox jumps over a lazy dog"

Beklager.





ivr
--
<peder> igorr: tcl ja... det er fra de dypeste avgrunnene i helvete det...
<peder> php er bare fra foajeen
            -- pederst på irc

---

On Mon, 16 Sep 2002 19:37:56 +0200, Thomas L. Christensen
<tlc@REMget2net.dk> wrote:

>Samtidig har jeg et andet ønske, nemlig at mit array skal være
>to-dimensionelt - derfor de to variabler lines og rows. Skal
>arrayet deklareres på en speciel måde for at gøre det
>to-dimensionelt?
Et array af pointere er faktisk to-dimentionalt til den type der peges
på.

char *array[10];

array[0][0] ... dette er den første 'char' i det første array.

>Problemet er, at jeg gerne vil skabe det her array dynamisk og
>udvidde det i takt med at der findes semikolon i teksten. Jeg har
>en idé om at det kan gøres med realloc(), men jeg har ikke fået
>det til at virke. Problemet er nok at jeg er i tvivl om hvordan
>jeg skal 'deklarere' et array af pointere så det kan udviddes.
Hvis jeg har forstået din ide rigtigt, er det du skal, at lave en
"kædet" liste. Dvs. en række sammen kædede structurer. Det gøres ved
at oprette en struktur som indeholder en pointer af samme type,
hvilket betyder at denne type kan pege på en type af samme slags.

Mit forslag er vist herunder, som tilføjelser til din kode. Håber du
kan se ideen ud fra det jeg har tilføjet...

/Thomas

>==========================
>#include <stdio.h>
>#include <stdlib.h>
========
Lav typen:

typedef struct LineTag
{
char *ptext;
Line *nextLine;
} Line;
========
>int main()
>{
>   FILE *fp;
>   long filesize=0L, count=0L;
>   int rows=0, lines=0;
=========
>   char *ptext, *parray[10];
Lav det om til:

char *ptext;
Line *firstLine = NULL;
Line *currentLine = NULL;
=========
>   if ((fp = fopen("semi.txt", "rb")) == NULL)
>   {
>      fprintf(stderr, "Error opening semi.txt");
>      exit(1);
>   }
>
>   rewind(fp);
>   fseek(fp, 0L, SEEK_END);
>   filesize = ftell(fp);
>   rewind(fp);
>
>   ptext = malloc((size_t) filesize);
>
>   fread(ptext, sizeof(char), (size_t) filesize, fp);
>   fclose(fp);
>
==========
>   parray[0] = ptext;
Lav om til:

/* Opret en "Linie" og sæt firstLine til at pege på den */
firstLine = malloc(sizeof(Line));
/* Sæt elementet ptext til at pege på det første tegn i "filen" */
firstLine->ptext = &ptext[0];
/* Terminer nextLine elementet, bruges senere som afslutning på den
kædede liste */
firstLine->nextLine = NULL;

/* Sæt currentLine til at pege på firstLine */
currentLine = firstLine;
==========
>   for (count = 0; count <= filesize; count++)
>   {
>      if (ptext[count] == ';')
>      {
>         ptext[count] = '\0';
>         rows++;
>         //realloc(parray, sizeof(parray) + sizeof(char));
==========
>         parray[rows] = &ptext[count+1];
Lav om til:

/* Alloc plads til en ny "Line", og sammenkæd med forgående "Line" */
currentLine->nextLine = malloc(sizeof(Line));
/* currentLine peger på den nye "Line" */
currentLine = currentLine->nextLine;
/* Gem &ptext[count+1] i den nye "Line" */
currentLine->ptext = &ptext[count+1];
/* Terminer !! */
currentLine->nextLine = NULL;
==========
>      }
>      else if (ptext[count] == 13)
>      {
>         ptext[count] = '\0';
>         count += 2;
==========
>         parray[rows] = &ptext[count];
Lav om til:

/* Samme som ovenfor */
currentLine->nextLine = malloc(sizeof(Line));
currentLine = currentLine->nextLine;
currentLine->ptext = &ptext[count];
currentLine->nextLine = NULL;
===========
>         lines++;
>      }
>   }
>
==========
>   for (count = 0; count <= rows; count++)
>         printf("%s\n", parray[count]);
Lav om til:

/* Forbered gennemløb af den kædede liste */
currentLine = firstLine;
do
{
/* Udskriv indholdet a ptext i nuværende "Line" */
printf("%s\n",currentLine->ptext);
/* Flyt pointer til næste "Line", dvs. den sammekædede liste */
currentLine = currentLine->nextLine;
/* Bliv ved indtil "terminering" findes */
} while(currentLine != NULL);
==========
>
>   free(ptext);
===========
Tilføj:

/* Samme som ovenfor, men frigøres den hukommelse som blev allokeret
til alle "Line" objekterne */
currentLine = firstLine;
do
{
firstLine = currentLine->nextLine;
if(currentLine != NULL)
free(currentLine);
currentLine = firstLine;
} while(currentLine != NULL)
===========
>   return 0;
>}
>==========================================
>
>På forhånd tak....

---

Thomas Lykkeberg <thomasDOTlykkeberg@privatDOTdk> wrote:

[snip]
>Hvis jeg har forstået din ide rigtigt, er det du skal, at lave en
>"kædet" liste. Dvs. en række sammen kædede structurer.

Nej, det er ikke helt det jeg vil. Jeg har faktisk lige læst om
kædede lister i 'TYC in 21 days', og jeg tænkte også først at det
var løsningen på mit problem. Men jeg vil svært gerne kunne tilgå
mine data, dvs. en semikolonsepareret tekstfil, via et
to-dimensionelt array (array[lines][rows]). Grunden er, at jeg
skal kunne sortere linierne efter fx alfabetisk orden i en af
kolonnerne. Man kan naturligvis godt sortere indholdet i en kædet
liste, men hvis det skal sorteres på basis af indholdet i hver 8.
struktur, så bliver det lidt kringlet. Jeg vil i hvert fald
foretrække et array - selvom det heller ikke er helt enkelt med
pointere til pointer af type char...

Jeg er lige kommet hjem fra arbejdet og er lidt træt i hovedet,
så jeg har ikke kigget nærmere på dit foreslag. Jeg vil kigge på
det her en af de nærmeste dage og se om der alligevel skulle være
noget af det jeg kan bruge. Jeg vender tilbage...


--
Thomas L. Christensen - Svendborg
There are 10 types of people.
Those who understand binary, and those who don't...

---

On Tue, 17 Sep 2002 20:11:51 +0200, Thomas L. Christensen
<tlc@REMget2net.dk> wrote:

>Man kan naturligvis godt sortere indholdet i en kædet
>liste, men hvis det skal sorteres på basis af indholdet i hver 8.
>struktur, så bliver det lidt kringlet.
Ja, så skal du nok lige kigge på det igen, fordi hver "Line" objekt
representerer faktisk een linie i filen.

Hver 8. struktur!? Øhh..

/Thomas