unflexibles typedef struct { ...

erin

Hallo, ich brauche mal wieder etwas Unterstützung. Ich habe folgende Struktur deklariert, um mit Listen von Strings arbeiten zu können:

typedef struct {
  int count;
  int lng;
  char *lines[1000];
} list_t;

count enthält die Anzahl der Zeilen, lng die Anzahl der Zeichen, die für jede Zeile bei Bedarf bereitgestellt wird. Jeder Zugriff erfolgt über Funktionen, die count und lng benutzen, um Speicher zu schaffen, wieder freizugeben oder den Inhalt der Zeilen zu schreiben bzw. auszulesen. Alle Funktionen haben als ersten Parameter einen Zeiger auf die Variable dieser Struktur, z.B.

char * get_line (* list_t, int idx) 
{
  // liefert, falls idx ok, einen Zeiger auf die Zeile idx zurück
}

Ein möglicher Aufruf wäre also:

list_t liste;
char * zeile;

zeile = get_line (&liste, 45);

Soweit funktioniert auch alles ganz prächtig. Nur ist der Typ auf maximal 1000 Zeilen festgelegt. Versteht sich, dass ich die rund dutzend Funktionen auch mit größeren oder kleineren Arrays verwenden möchte, und da bin ich mit meinem Anfängerlatein am Ende.

CStoll

Du kannst auch mehrdimensionale Zeiger-Konstrukte erzeugen:

typedef struct
{
  int count;
  int lng;
  char **lines;
} list_t;

void create_list(list_t* tgt,int cnt,int ln)
{
  int i;
  tgt->count=cnt;tgt->lng=ln;
  tgt->lines=malloc(cnt*sizeof(char*));
  for(i=0;i<cnt;++i)
    tgt->lines[i]=malloc(ln);
}

erin

Zeiger -> Zeiger ->

> Wo ich bin, herrscht Chaos. Leider kann ich nicht überall sein.

Hoffentlich erzeugst Du mit deinem (wahrscheinlich einzig möglichen) Ansatz kein Chaos in meinem Kopf. Aber ich werd's wohl kapieren - ich muss es kapieren.
Vielen Dank

CStoll

erin schrieb:

Zeiger -> Zeiger ->

> Wo ich bin, herrscht Chaos. Leider kann ich nicht überall sein.

Ich sehe, meine Signatur fällt auf

(wahrscheinlich einzig möglichen)

Sicher gibt es noch andere Ansätze (z.B. verkettete Listen), aber die dürften noch komplizierter werden.

(PS: Wenn du C++ verwenden darfst, gibt es tatsächlich etwas einfacheres: std::vector<std::string> (damit mußt du noch nicht einmal die Größenangaben selber mitschleifen))

keksekekse

Ich hab da zufällig was vorbereitet...

#include <alloc.h>
#include <conio.h>
#include <io.h>
#include <stdio.h>
#include <string.h>

char *g_pcStringPool;
int g_iStringPoolSize;

char **g_ppcLines;
int g_iLinesCount;

char *StringPoolAddString(char *s)
{
  int ssize = strlen(s)+1;

  g_iStringPoolSize += ssize;
  g_pcStringPool = realloc(g_pcStringPool, g_iStringPoolSize);
  return strcpy(g_pcStringPool+g_iStringPoolSize-ssize, s);
}

char *AddLine(char *s)
{
  g_ppcLines = realloc(g_ppcLines, (g_iLinesCount+1)*sizeof(char *));
  g_ppcLines[g_iLinesCount] = StringPoolAddString(s);

  return g_ppcLines[g_iLinesCount++];
}

int Read(char *file)
{
  FILE *fp;
  char *pctext;
  int ifilelen;
  char *s, *e;

  if ((fp = fopen(file, "rb")) == 0)
      return 0;
  /* Text als Ganzes laden */
  ifilelen = filelength(fileno(fp));
  pctext = malloc(ifilelen+1);
  fread(pctext, 1, ifilelen, fp);
  pctext[ifilelen] = 0;
  fclose(fp);

  /* Zeile für Zeile als String speichern */
  for (s = pctext; (e = strchr(s, '\r')) != 0; s = e+2)
    { *e = 0;
      AddLine(s);
    }
  AddLine(s);

  free(pctext);
  return 1;
}

void Print(void)
{
  int i;

  for (i = 0; i < g_iLinesCount; i++)
      printf("%s\n", g_ppcLines[i]);
}

void Remove(void)
{
  free(g_pcStringPool);
  free(g_ppcLines);
}

int main()
{
  if (Read("TEXT.TXT"))
      Print();
  Remove();
  getch();
  return 0;
}