Pascal-String einlesen

Vielen Dank für die Antworten!

Ich hab mir deinen Code angesehen aber ich versteh nicht wirklich was du genau machst bzw. was passiert. Kannst du mir vielleicht erklären was genau passiert?

lg ALex
 
Hallo,

if(NULL == (ret = (char **)malloc(sizeof(char *) * (*a)))) e = 1;


Was wird a beim ret = gemacht? Mir sagt das irgendwie nichts.
Was heisst char **?

lg
 
Char** ist ein Pointer zu einem char-Pointer.
Bei diesem Code wird die erste Dimension des char** alloziert.

Suche doch einfach einmal nach Pointern im Internet. Da kriegst du massig Informationen. Das wurde schon oft erklärt und ich kann das sicher nicht so gut wie andere im Netz.

Gruss
cwriter
 
hi leute also ich glaub mein anfängerdasein wir mir bei der aufgabe echt zum Verhängnis ..
ich schaff es eine Binärdatei zu schreiben und auch auszulesen aber das mit dem pascalstring krieg ich einfach nicht hin ?! :(
 
Zuletzt bearbeitet:
OT:
Der Thread ist irgendwie seltsam geworden.
Einer fragt, ein anderer bedankt sich für die Antworten,
ein Dritter stellt eine weitere Frage zum Thema...
Telepathie? Drei Accounts der selben Person?

Es würde wahrscneinlich helfen, wenn Scal und Jester
eigene Threads machen und dort erst mal ihre Probleme/Fragen hinschreiben.

Und bitte keine Pushposts.


@wolfi, zu http://www.tutorials.de/c-c/396376-pascal-string-einlesen.html#post2047233:
Versuch doch selbst mal nach und nach. (übrigens, "rd" ist nichts für fopen).
Grobe Ablaufbeschreibung vom Programm folgt, als Anstoß

Was ich im folgenden Text nicht extra jedesmal schreibe:
Wenn Fehler dann Beenden, und vor Beenden noch alles free´n und fclose´n was man hat.
Auch viele fer Dateifunktionen etc. gehören auf Fehler überprüft (anhand vom Returnwert)

Ablauf ca.:
Code:
Zuerst prüfen, ob die Parameteranzahl passt.
Dateien öffnen.
Mit fseek SEEK_END bzw. SEEKSET und ftell kannst du die Byteanzahl der Inputdatei rausfinden,
abspeichern in eine Variable filelen (zB.).
Dann mit fread das Anfangs-int auslesen (Funktionsbeispiel siehe Code irgendwo oben)
Laut Angabe darf muss das int >0 sein, sonst Fehler.
Dann mach einen char-Pointer, auf den du mit malloc zB. 10 Byte reservierst.
Dazu ein int size, wie viel Byte der hat.

Jetzt so oft, wie das Anfangsint angegeben hat in einer Schleife durch
{
int i einlesen
Wenn i > filelen: File korrupt-Fehler

Wenn i > size dann den char-Pointer per realloc vergrößern (auf i)
und size entsprechend auf i setzen

i Byte per fread in den char-Pointer einlesen
Per Schleife durchkontrollieren, ob die Byte wohl nicht zw. -1 und 31 sind (-1 und 31 auch nicht)
Wenn schon dann File korrupt

Per fwrite diese i Byte in die Zieldatei schreiben und einen Zeilenechsel dazu (fputc/fprintf...)

filelen -= i;
}

Nach der Schleife:
Wenn filelen != 0 dann file korrupt

Alles schließen und freigeben


@cwriter, zu http://www.tutorials.de/c-c/396376-pascal-string-einlesen.html#post2047250:
Das ist Linux :p


@Scal & Jester, zu http://www.tutorials.de/c-c/396376-pascal-string-einlesen.html#post2047258 etc.
Was genau versteht ihr nicht? Was wollt ihr überhaupt machen?
 
Hi sheel danke mal für deine Erklärung :) ! ich werds mal versuchen ob ich es hinbekomme.
*g* also ich hab auf jeden fall nur EINEN account ;)

Lg
 
Ich hab auch meinen eigenen Account :)

Ich hab mir deine Beschreibung mal durchgelesen @Sheel und werde heute versuchen das Ganze mal zu programmieren. Zum einlesen der Datei nehme ich aber schon "fopen(FILENAME, "rb") oder?

lg Alex
 
Genau.
Und zum Schreiben der Textdatei w oder a (macht dann einen Unterschied,
wenn es eine Datei mit dem Namen schon gibt:
w überschreibt alles und a hängt das Neue nur hinten an.
Na gut, man könnte auch zuerst abfragen, ob es die Datei gibt und dann sagen "Gibts schon"...)

Bisschen was Beschreibendes zum Vorgang, weil das so vllt. teilweise verwirrend ist:
Eingelesen/Rausgeschrieben wird jeweils ein einzelner String.
Nicht alle Strings einlesen, sondern einen einlesen, rausschreiben, einlesen, rausschreiben...
das ganze Rein-Raus hätte man theoretisch auch nur mit einem Zeichen oÄ. machen können,
aber so ist malloc drin (was ja anscheinend wichtig ist).

Weil der String beim Einlesen ja irgendwo gespeichert werden muss,
bevor man ihn wieder rausschreibt, gibts dafür den char-Pointer, mit malloc-iertem Speicher.
Angefangen mit irgendeiner Grundgröße wie 10, wird er dann eben vergrößert,
wenn man zu einem zu langen String kommt. Wenn dann später ein noch
längerer String in der Datei it wird eben wieder vergrößert usw.

Die Sache mit der Prüfung, ob die Bytes zw. -1 und 31 sind, dann Korrupt-Fehler:
In dem Nummernbereich gibt es keine wirklichen Textzeichen, nur Sonderzeug
wie ein Stringendzeichen (das den String hier abschneiden würde),
ein Dateiendzeichen (das man nicht in die Textdatei rausschreiben sollte),
einen Code der das letzte geschriebene Zeichen uU. wieder löscht
(wenn er irgendwo ausgegeben wird) oder etwas, das bei Ausgabe einen Ton erzeugt.
s steht zwar nicht konkret in der Angabe, aber wenn das Ergebnis
eine Textdatei sein soll ist sowas ungültig.

Und die Sache mit der Dateilänge (zwei Korruptprüfungen):
In der Schleife:
Die Stringlängenint in der Datei müssen ja überprüft werden, ob sie stimmen können.
Ganz am Anfang wird einmal die Dateilänge abgefragt, und wenn man einen String
mit x Byte eingelesen hat wird die Längenzahl um x verkleinert, so dass man sagen kann
"jetzt kommen noch xyz Byte".
Wenn jetzt ein Stringlängenint in der Datei ist, das größer als die restliche Dateilänge ist -> Fehler.

Nch der Schleife:
Man weiss ja von Anfang an, wie viele Strings in der Datei sind (das ganz erste int drin).
Man liest als xyz Strings sein und subtrahiert die gelesene Byteanzahl
von der Dateilängenvariable.
Wenn außer den Strings nichts in der Datei ist sollten am Schluss 0 Byte übrigbleiben,
die man noch nicht verarbeitet hat. Wenn da aber noch was ist: Datei nciht in Ordnung.
 
Zurück