C - Zeilenanfang einer Datei bestimmen

[schorsch_76]

EDIT:
Zeile 28: matrix=(char**)malloc(zeile * sizeof(int *));
Wie viele Zeilen willst du den reservieren? Hier ist zeile noch 0. Oder schlimmer: Irgendein grosser Wert. Initialisiere immer erst deine Variablen.

Kannst du mir diese Zeile mal erklären?
(Vorallem, warum ich char** schreiben muss. Danke.

matrix ist vom Typ "char**". Matrix ist also ein pointer auf pointer auf char. malloc() gibt zwar void* zurück, aber wenn ich hier explizit auf (char**) caste, heist, dass, dass ich mir hier Gedanken gemacht habe, was ich hier eigentlich von malloc will.
Wenn du den gdb startest und an der stelle von malloc einen breakpoint setzt, dann ein "inspect zeile" dort machst, wirst du sehen, dass im Debugbuild zeile noch 0 ist. ABER: Im Releasebuild ist das nicht garantiert. Also sollte man bei der Deklarationd er Varaible diese immer initialisieren.

EDIT2:
Vermutlich bist du beim ermitteln der Zeilen/Spalten etwas unsicher gewesen oder weist nicht wie man das macht. Deshalb hier mein Beispiel für dich:

Code: Alles auswählen

	// Ermittle Anzahl der Zeilen / maximale anzahl der spalten
	char c = 0;
	j = 0;
	while ((c = fgetc(f)) != EOF)
	{
		// zeile
		if (c=='\n')
		{
			j = 0;
			zeile++;
		}

		if (j > spalte)
		{
			spalte = j;
		}
		j++;
	}
	fseek(f,0,SEEK_SET);	// Setze filepointer auf begin

Dass mit den Zeilen verstehe ich noch.
Aber wie meinst du das mit den Spalten?
Die Spalten sollen doch als char Array gespeichert werden, oder zähle ich so die Anzahl der Elemente und muss im Array noch das abschließende Terminierungszeichen '\0' anhängen?


Sorry für die vielen Fragen, aber habe noch nicht so ganz den Durchblick!
Hoffe, dass dies bald kommt...

Du kannst das ganze auf verschiedene Arten anpacken.
a) Mein Ansatz:
Hier ermittle ich erst die Anzahl der Zeilen und gleichzeitig die maximale Anzahl der Spalten (j). Dadurch kann ich beim malloc() für die jeweilige neue Spalte sicher sein, dass ich genug RAM reserviert habe. Kein Bedarf für realloc, ABER mehr Speicherverbrauch.

b) Weitere Möglichkeit: Gleichzeitiges Lesen aus dem File und reservieren des benötigten Speichers für die Zeile:
Lass das mit der Maximalen Anzahl der Spalten weg. Reserviere beim Erzeugen der jeweiligen Spalte char[100]. List du jetzt bsp. das 101 Zeichen einer Zeile, machst du ein realloc() mit bsp 200 bytes und liest danach weiter. Vorteil: Weniger Speicherverbrauch als die Variante a) aber mehr Programmieraufwand.

Das mit den Fragen ist kein Problem Deshalb nennt man das hier ja auch Forum

char** entspricht char[][].

Aber in C castet man die Rückgabe von malloc() üblicherweise nicht -- im Gegensatz zu C++.

In C++ würde ich hier das folgende schreiben:

Code: Alles auswählen

matrix = new char**[zeile];

Hier besteht kein Bedarf eines casts, da mir new schon einen Pointer auf den richtigen Datentyp zurück gibt.
Wäre die Variante mit malloc() ohne cast exakt dem Standard würde der gcc mit "gcc main.c -Wall" nicht eine warnung ausspucken

Gruß

schorsch

[schorsch_76]

Üblicherweise nimmt man ein Array von Zeilen, bei dem jede Zeile ein Array von char ist. Also anders rum wie du es hier siehst.

So meinte ich es. Hatte mich falsch ausgedrückt.

Siehst du, das meinte ich mit der Komplexität dieses Ansatzes. Warum das Programm nicht *erst* zeilenbasierend programmieren (dann brauchst du nämlich nur ein Array, für die eine Zeile).

Meinst du mit zeilenbasiert folgendes:
Eine Zeile einlesen, ausgeben und anschließend die nächste Zeile einlesen?

Genau so ist es Duff. So arbeitet auch der C++ Ansatz von oben

Gruß

schorsch

[Meillo]

Aber in C castet man die Rückgabe von malloc() üblicherweise nicht -- im Gegensatz zu C++.

Wäre die Variante mit malloc() ohne cast exakt dem Standard würde der gcc mit "gcc main.c -Wall" nicht eine warnung ausspucken

Ich lag falsch. Auch im K&R wird gecastet.

(... aber irgendwo habe ich da mal was Gegenteiliges gehört oder gelesen, weiß nur nicht mehr wo.)

[Duff]

Siehst du, das meinte ich mit der Komplexität dieses Ansatzes. Warum das Programm nicht *erst* zeilenbasierend programmieren (dann brauchst du nämlich nur ein Array, für die eine Zeile).

Meinst du mit zeilenbasiert folgendes:
Eine Zeile einlesen, ausgeben und anschließend die nächste Zeile einlesen?

[lemak]

@Duff ich will dich nicht noch mehr irritieren, da du anscheinend noch bei den Grundlagen Probleme hat. (Ich weiss es ja nicht) und bei mir Sitzt das alles auch nicht 100% deswegen halte ich mich hier etwas raus um dich nicht zu verwirren wenn ich etwas dann doch flasch erzähle. bin eh kein guter Erklärer

Aber ich will dennoch folgenden Code Posten.
btw: Man muss logisch char für die matrix nehmen denn Strings sind in C char-Arrays keine int-Arrays

Code: Alles auswählen

#include <stdio.h>
#include <string.h>
 
int main (void)
{
         char ** matrix,zeile=0,spalte;
 
         char * daten = "in der linearen Algebra die horizontalen Einträge einer Matrix (Mathematik)\n";
 
        /* Speicher reservieren fuer die int-Zeiger (zeilen) */
        matrix = malloc(zeile+1 * sizeof(char *));

        /* jetzt noch Speicher reservieren für die einzelnen Spalten */
        matrix[zeile] = malloc(strlen(daten) * sizeof(char));

        strncpy(matrix[zeile], daten, strlen(daten));
        daten = NULL; /* müsste man eigentlich mal überschreiben */
        printf("daten:%s\nzeile:%s\nlänge:%d\n", daten, matrix[zeile],strlen(matrix[zeile]));

        for (spalte=0; spalte != strlen(matrix[zeile]); spalte++)
        {
                 printf("[%c] ", matrix[zeile][spalte]);
         }
 
         return 0;
  }
  

Sonst lass diesen Post von mir links liegen, denn wie Meillo schon sagt ist es Sehr sinnvoll zu Beginn erst den Ansatz Zeile einlesen -> Bearbeiten -> Ausgeben umzusetzen.

[Duff]

So, mein Programm sieht bisher wie folgt aus (zeilenweise einlesen). [1]

Gerne würde ich jetzt auf die Konstante BUF verzichten und mit malloc den Speicher dynamisch anfordern.
Nur verstehe ich noch nicht ganz, wie ich dies in meinem Beispiel realiseren kann.

Meine Textdatei sieht so aus:

Code: Alles auswählen

daniel@marge:~/scripts/C$ cat test.file 
# Kommentar
var1=bla bla

# noch
# mehr
# Kommentar, Kommentar, etc.
var2=var1


var3=
var4=was auch immer

# Kommentar
# Schluß

Eine Ausführung meines Programms, bei der die Zeilennummer, die Länge des Arrays und das gesamte Array ausgegeben werden:

Code: Alles auswählen

daniel@marge:~/scripts/C$ ./edit_file1 test.file 
Nr. : Strl : String
2   : 13   : var1=bla bla
7   : 10   : var2=var1
10  : 6    : var3=
11  : 20   : var4=was auch immer

[1] http://nopaste.debianforum.de/31515

Danke.

[schorsch_76]

Hi Duff,

das must du durch eine eigene Funktion machen. Bsp.:

Code: Alles auswählen

// dont forget to free that memory
char* myfgets(FILE* f)
{
	static const size_t memory_chunk_size = 100;

	char c;

	char* buffer = 0;
	size_t allocated_buffer_length = 0; 	
	size_t position = 0; 	

	while ((c = fgetc(f)) != EOF)
	{
		// create the first buffer
		if (buffer == 0)
		{
			buffer = (char*) malloc(memory_chunk_size + 1); // +1 because of ending '\0'
			allocated_buffer_length = memory_chunk_size;

			if (buffer==NULL)
			{ 
				perror ("Error allocating memory"); 
				exit (1);
			}
		}

		// check if we need to realloc
		if (allocated_buffer_length <= position)
		{
			buffer = realloc(buffer, allocated_buffer_length + memory_chunk_size + 1); //+1 because of ending '\0'
			allocated_buffer_length += memory_chunk_size;

			if (buffer==NULL)
			{ 
				perror ("Error reallocating memory"); 
				exit (1);
			}
		}

		// insert our read char into the buffer
		buffer[position] = c;
		position++;
	}

	// append '\0' to the buffer
	buffer[position] = '\0';

	// now realloc to our string length
	buffer = realloc(buffer,strlen(buffer)+1);

	return buffer;
}

Gruß

schorsch

EDIT: Die whileschleife muss noch angepasst werden.Es muss auf EOF oder '\n' geprüft werden.

[Duff]

Danke.

D.h., dass ich bei der Verwendung von fgets kein malloc verwenden kann. Ich muss auf fgetc zurück greifen.

Wieso wird in deinem Programm die vorletzte Zeile

Code: Alles auswählen

   // now realloc to our string length
   buffer = realloc(buffer,strlen(buffer)+1);

benötigt?

Ich muss extra ein realloc durchführen, weil ich zuvor das Stringende-Zeichen '\0' ans Array gehangen habe?

[schorsch_76]

Ne, das hab ich gemacht, dass du genau nur soviel Arbeitsspeicher reservierst wie diese Zeile Bytes hat.

Gruß

schorsch

[Meillo]

die Konstante BUF

Es war übrigens schon Absicht, dass ich BUFSIZ geschrieben habe, denn diese Konstante ist in stdio.h definiert und hat die Größe des Lese/Schreibpuffers bei der verwendeten Implementierung. Es ist sinnvoll diese Kontante für sowas zu verwenden.

Das aber nur am Rande, denn du du verwendest ja jetzt malloc() stattdessen.

[schorsch_76]

die Konstante BUF

Es war übrigens schon Absicht, dass ich BUFSIZ geschrieben habe, denn diese Konstante ist in stdio.h definiert und hat die Größe des Lese/Schreibpuffers bei der verwendeten Implementierung. Es ist sinnvoll diese Kontante für sowas zu verwenden.

Das aber nur am Rande, denn du du verwendest ja jetzt malloc() stattdessen.

Gut zu wissen. Hab ich nicht gewusst

[lemak]

Ich habe mal meine beiden Fetzen zu einem zusammen gefasst.
So könnte man eine Datei komplett in ein 2D-Array einlesen und jede Zeilen wie einen String behandeln bis auf dass das '\0' am Ende fehlt - also doch kein String sondern nur ein char-Array^^.

// now realloc to our string length
buffer = realloc(buffer,strlen(buffer)+1);

Hab nun icht mit implementiert, ist aber immer ein gute Idee!

Code: Alles auswählen

#include <stdlib.h>
#include <stdio.h>
#undef BUFSIZ
#define BUFSIZ 1
int
main(int argc, char ** argv)
{
   char ** matrix, c;
   int row = 0, col = 0, rowcnt=BUFSIZ, colcnt=BUFSIZ;
   FILE * f = fopen(argv[1], "r");

   matrix = (char **) malloc(rowcnt * sizeof(char *));
   matrix[row] = (char *) malloc(colcnt * sizeof(char));

   while ( f && !feof(f) && !ferror(f) )
   {
      c = fgetc(f);
      matrix[row][col] = c;
      printf("POS %d,%d (MEM %d,%d) [%c] ", row, col, rowcnt, colcnt, matrix[row][col]);
      col++;
      if (c == '\n')
      {
         printf("\nNEXT LINE\n");
         row++;
	 if (rowcnt == row)
         {
            rowcnt += BUFSIZ;
            matrix = (char **) realloc(matrix, rowcnt * sizeof(char *));
         }
         colcnt = BUFSIZ;
         matrix[row] = (char *) malloc(colcnt * sizeof(char));
         col = 0;
         continue;
      }
      else if (colcnt == col)
      {
         colcnt += BUFSIZ;   
         matrix[row] = (char *) realloc(matrix[row], colcnt * sizeof(char));
      }
   }
   if ( !f || ferror(f) )
   {
      perror(argv[1]);
      return -1;
   }
   return 0;
}

MfG i

Edit: Habe den code mal ausgebessert so sollte auch die Kontrolle richtig sein.

[Meillo]

Code: Alles auswählen

$ cc -Wall a.c 
a.c:2:1: warning: "BUFSIZ" redefined
In file included from a.c:1:
/usr/include/stdio.h:174:1: warning: this is the location of the previous definition
a.c: In function 'main':
a.c:10: warning: implicit declaration of function 'malloc'
a.c:10: warning: incompatible implicit declaration of built-in function 'malloc'
a.c:24: warning: implicit declaration of function 'realloc'

Es fehlt `#include <stdlib.h>' für malloc() und Co.

Und das mit BUFSIZ hast du noch nicht so recht verstanden. Diese Konstante ist in stdio.h schon definiert, und zwar auf die Größe des Lese/Schreibpuffers der Implementierung.

Zudem schreibt dein Programm ein 0xff ans Ende der Ausgabe. Habe aber nicht nachgeforscht weshalb.

Code: Alles auswählen

char ** matrix, c;

Sowas will man besser nicht schreiben. Es ist zwar korrekt, führt aber oft zu Verwirrungen. Besser in zwei Zeilen:

Code: Alles auswählen

char ** matrix;
char c;

[lemak]

Es fehlt `#include <stdlib.h>' für malloc() und Co.

stimmt thx (blindfisch^^)

Und das mit BUFSIZ hast du noch nicht so recht verstanden. Diese Konstante ist in stdio.h schon definiert, und zwar auf die Größe des Lese/Schreibpuffers der Implementierung.

Das ist Absicht! Ich wollte es einfach auf 1 haben.

Zudem schreibt dein Programm ein 0xff ans Ende der Ausgabe. Habe aber nicht nachgeforscht weshalb.

Das sollte das EOF sein.

[GoKi]

c wird nie etwas zugewiesen. Damit tut der Code nicht das, was er tun soll. Ich vermute zumindest mal, dass er was anderes tun soll.
Derzeit wird höchstwahrscheinlich der komplette Inhalt der Datei (+EOF) in matrix[0] abgelegt.

[schorsch_76]

Hi i,

hier ein paar Kommentare von mir zu deinem Code

Code: Alles auswählen

   matrix = (char **) malloc(BUFSIZ * sizeof(char *));
   matrix[row] = (char *) malloc(BUFSIZ * sizeof(char));
   rowcnt = BUFSIZ;
   colcnt = BUFSIZ;

BUFSIZ ist ein define auf 1. Also reservierst du nur soviel Platz wie ein "char*" braucht (auf i386 4 Bytes, amd64 8 Bytes). Danach reservierst du Platz für genau 1 char. Das wird vermutlich nicht so gedacht sein

Code: Alles auswählen

      matrix[row][col++] = fgetc(f);
      if (c == '\n')
      {...}

Hier liest du ein Zeichen aus den File und packst es in matrix[row][col].
a) Wie soll c den Inhalt '\n' jemals bekommen, wenn das Zeichen nicht erst über c und dann nach matix geht?
b) Beim zweiten Zeichen ist col ja auf 1. ABER: Du hast nur Platz für genau einen char reserviert. Das ist eine Speicherverletzung. Dieser Speicher "gehört" dem Program noch nicht. Du hast ihn ja nicht angefordert. Ursache siehe oben

EDIT: Grad den realloc gesehen

Gruß

schorsch

[Duff]

Ich scheitere schon bei der "einfachen" Variante mit einem eindimensionalen Array.


Entweder versuche ich die Eingabe per while(*p++ != EOF), so wird jeder Character in einer neuen Zeile ausgegeben, oder ich mache ein while(*p++ != NULL), so erhalte ich einen Speicherzugriffsfehler oder aber ich versuche es in einer for-Schleife mit for(i=0;i<sizeof(p)/sizeof(char);i++) { printf("%c ",p); }, so erhalte ich als Ausgabe Kommen.

Was mache ich falsch?

http://nopaste.debianforum.de/31609

[GoKi]

Der String ist null-terminiert.

Code: Alles auswählen

while (*p != '\0')
  putchar(*p++);

Aber wieso nicht direkt:

Code: Alles auswählen

printf("%s", p);

Davon abgesehen liest dein Code immer noch die gesamte Datei. Es wurde weiter oben erwähnt, wie das anzupassen ist.

[lemak]

Hier liest du ein Zeichen aus den File und packst es in matrix[row][col].
a) Wie soll c den Inhalt '\n' jemals bekommen, wenn das Zeichen nicht erst über c und dann nach matix geht?

c wird nie etwas zugewiesen. Damit tut der Code nicht das, was er tun soll. Ich vermute zumindest mal, dass er was anderes tun soll.
Derzeit wird höchstwahrscheinlich der komplette Inhalt der Datei (+EOF) in matrix[0] abgelegt.

Ja man sollte immer zuerst einen Gedanken bis zum Ende Schreiben und dann eine neue Idee Anfangen.
Warum ich das nicht mehr gesehen habe...
BUFSIZ 1 ist vllt albern -ja- aber ich wollte das zur Kontrolle so habe.

, aber er bringt dich zum Lachen...

Hoffe das Chaos ist nicht zu schlimm und Duff ist mir nicht böse dass ich seinen theard mit benutze.
Ich habe meinen Code nun mal verbesser (keine Compiler Fehler mehr) und die Kontrolle sollte so nun auch stimmen.
viewtopic.php?f=34&t=115665&start=30#p735025

sry i

[Duff]

Davon abgesehen liest dein Code immer noch die gesamte Datei. Es wurde weiter oben erwähnt, wie das anzupassen ist.

Verstehe ich nicht.

Meinst du, dass ich die Datei zum Lesen und Schreiben öffnen soll, um dann direkt Änderungen darin zu machen?

[GoKi]

Meinst du, dass ich die Datei zum Lesen und Schreiben öffnen soll, um dann direkt Änderungen darin zu machen?

Okay, vielleicht habe ich auch nicht verstanden, was du machen willst. Wollte nur anmerken, dass dein Code die gesamte Datei in der char* Variable p ablegt. Ich hätte eher gedacht, dass Du Zeile für Zeile in p einlesen willst, dann irgendwas damit machst... Aber lass Dich durch meine Aussagen nicht verwirren.

[schorsch_76]

Ich scheitere schon bei der "einfachen" Variante mit einem eindimensionalen Array.


Entweder versuche ich die Eingabe per while(*p++ != EOF), so wird jeder Character in einer neuen Zeile ausgegeben, oder ich mache ein while(*p++ != NULL), so erhalte ich einen Speicherzugriffsfehler oder aber ich versuche es in einer for-Schleife mit for(i=0;i<sizeof(p)/sizeof(char);i++) { printf("%c ",p); }, so erhalte ich als Ausgabe Kommen.

Was mache ich falsch?

http://nopaste.debianforum.de/31609

Sorry Duff, da hab ich im Eifer des Gefechts was vergessen

Hier die neue Version

Gruß

schorsch

[Meillo]

So, jetzt auch mal ein bisschen Code von mir: 31636

Die Eingabe (von stdin) wird ein 2D-Array gelegt (char* matrix[]). Der Speicher wird dynamisch alloziert.

Der Code soll in erster Linie als Beispiel angesehen werden.

[lemak]

Code: Alles auswählen

$ gcc 31636.c -Wall
$ ./a.out 
test
( 0/ 6 |  5/ 8): test
Das ist doch mein Ansatz in Perfektion :)
( 1/ 6 | 42/64): Das ist doch mein Ansatz in Perfektion :)
Wobei ich mich in keinster Weise auf die selbe Stufe stellen will.        
( 2/ 6 | 67/128): Wobei ich mich in keinster Weise auf die selbe Stufe stellen will.
^C

Sogar die Speicher-Vergrößerung machst Du -imo- wie bei einem C++ Vektor.
Cool - Was gute Planung so ausmachen kann.

[Danielx]

So, jetzt auch mal ein bisschen Code von mir: 31636

Hm, wäre anstatt

Code: Alles auswählen

                while (strlen(matrix[row]) == linelen-1) {

nicht das hier richtig

Code: Alles auswählen

                while ((strlen(matrix[row]) == linelen-1) && (matrix[row][linelen-2] != '\n')) {

Gruß,
Daniel