Read dynamic string

[Sillaba atona]

I use this code to read dynamic string:

char *s1;
.......
puts("Inserire una stringa: ");
while((*s1++=ge tchar())!='\n') ;
*s1='\0';

The compilation (ANSI C) is OK but I receive an error during the execution.

The problem is not present if I use a static array.

I cannot find the error.

[Malcolm]

"Sillaba atona" <NO****@tin.i t> wrote in message

char *s1;
......
puts("Inserire una stringa: ");
while((*s1++=ge tchar())!='\n') ;
*s1='\0';

The compilation (ANSI C) is OK but I receive an error during the
execution.

The problem is not present if I use a static array.

I cannot find the error.

s1 points to nowhere in particular. You then start overwriting this random
memory location with characters. Usually the result will be a crash
(probably a message saying "segmentati on fault").
If you say s1 = malloc(1000) then s1 will point to 1000 chars reserved for
you, and the program won't crash until you exceed that figure. (You can keep
a count and call realloc(), if you want to be able to read an arbitrary
string as long as the computer's meory allows).

[Walter Roberson]

In article <43************ ***********@rea der1.news.tin.i t>,
Sillaba atona <NO****@tin.i t> wrote:

I use this code to read dynamic string: char *s1;
......
puts("Inseri re una stringa: ");
while((*s1++=g etchar())!='\n' );
You have not allocated any storage. s1 is an uninitialized pointer;
you have to point it to a block of memory before you can use that code.

Except that that code doesn't take into account the possibility of
a really long string, and if you pre-allocate the memory then no matter
how much you allocate, the user might enter something larger.
Therefore you either need to limit the length that you will pay
attention to, or else you need to use a scheme in which the allocated
memory is grown as needed.
*s1='\0'; The compilation (ANSI C) is OK but I receive an error during the execution.
A good compiler would warn that s1 was potentially uninitialized, but
such a warning is not -required- by the standard.
The problem is not present if I use a static array.

Change back to a static, and then have the user paste in (say)
32K of text, and see whether you still say the problem is "not present"
when you use a static array.
--
"No one has the right to destroy another person's belief by
demanding empirical evidence." -- Ann Landers

[Toni Uusitalo]

Malcolm wrote:

If you say s1 = malloc(1000) then s1 will point to 1000 chars reserved for
you, and the program won't crash until you exceed that figure. (You can keep
a count and call realloc(), if you want to be able to read an arbitrary
string as long as the computer's meory allows).

Or you can keep reading into unallocated buffer until your computer meows.

;-)

with respect,
Toni Uusitalo

[Daniel Fischer]

Hi,

(You can keep a count and call realloc(), if you want to be able to read
an arbitrary string as long as the computer's meory allows).

there's also a neat way that involves using recursion to allocate
additional memory on the stack and putting the parts together on return,
thereby avoiding heap fragmentation.
Daniel

[Christopher Benson-Manica]

Sillaba atona <NO****@tin.i t> wrote:

char *s1;
......
puts("Inserire una stringa: ");
while((*s1++=ge tchar())!='\n') ;
*s1='\0'; The compilation (ANSI C) is OK but I receive an error during the execution.

It's wrong, as others have indicated.

You might find Chuck Falconer's ggets() routine, available at
cbfalconer.home .att.net/download/ggets.zip, to be helpful. Chuck is
(or at least was, he seems to have been missing for some time) a
regular contributor here, so you can use the code with confidence
(per the license, which I believe is GPL).

--
Christopher Benson-Manica | I *should* know what I'm talking about - if I
ataru(at)cybers pace.org | don't, I need to know. Flames welcome.

[Malcolm]

"Daniel Fischer" <sp**@erinye.co m> wrote

(You can keep a count and call realloc(), if you want to be able to read
an arbitrary string as long as the computer's meory allows).

there's also a neat way that involves using recursion to allocate
additional memory on the stack and putting the parts together on return,
thereby avoiding heap fragmentation.

Could you post a getline() function (get a line from a file, of arbitrary
length) that uses this?

[Toni Uusitalo]

Daniel Fischer wrote:

Hi,

(You can keep a count and call realloc(), if you want to be able to read
an arbitrary string as long as the computer's meory allows).

there's also a neat way that involves using recursion to allocate
additional memory on the stack and putting the parts together on return,
thereby avoiding heap fragmentation.

This is possible but I doubt it's worth the hassle (I admit it sounds
like neat trick).

I think something that reuses existing buffer would be enough for
avoiding constant buffer fiddling/reallocating.

Something like this:

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

struct GetLine {
FILE *f;
char *buf;
size_t bufsize;
};

int GetLine_Init(st ruct GetLine *gl, FILE *f)
{
gl->f = f;
gl->bufsize = 256;
gl->buf = malloc(gl->bufsize);
return (gl->buf) ? 1 : 0;
}

void GetLine_Destroy (struct GetLine *gl)
{
free(gl->buf);
}

char *GetLine_Read(s truct GetLine *gl)
{
size_t i=0;
int ch;

while(gl->buf) {
for(; i<gl->bufsize; gl->buf[i++]=ch) {
ch = fgetc(gl->f);
if (ch == EOF || ch == '\n') {
if (!i && ch == EOF) return NULL;
gl->buf[i] = '\0';
return gl->buf;
}
}
gl->bufsize += gl->bufsize;
gl->buf = realloc(gl->buf, gl->bufsize);
}
return NULL;
}

int main(int argc, char* argv[])
{
struct GetLine gl;
char *line;
FILE *f = fopen("test.txt ", "r");

if (!f) return (EXIT_FAILURE);
if (!GetLine_Init( &gl, f)) return (EXIT_FAILURE);

while((line=Get Line_Read(&gl)) )
puts(line);

GetLine_Destroy (&gl);
fclose(f);
return 0;
}

with respect,
Toni Uusitalo

[Joe Wright]

Daniel Fischer wrote:

Hi,

(You can keep a count and call realloc(), if you want to be able to read
an arbitrary string as long as the computer's meory allows).

there's also a neat way that involves using recursion to allocate
additional memory on the stack and putting the parts together on return,
thereby avoiding heap fragmentation.
Daniel

I'd love to see that. Can you post the code?

--
Joe Wright
"Everything should be made as simple as possible, but not simpler."
--- Albert Einstein ---

[Daniel Fischer]

On Sun, 27 Nov 2005 18:27:12 -0500, Joe Wright wrote:

there's also a neat way that involves using recursion to allocate
additional memory on the stack and putting the parts together on return,
thereby avoiding heap fragmentation.
Daniel

I'd love to see that. Can you post the code?

Sure:

------------------------->8---------------------------

/*
* rfgets.c
* dynamically allocating fgets
* daniel.fischer at iitb.fraunhofer .de
*/

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

char *rfg(FILE * f, int l) {
char b[32], *p;
int x;

if(!fgets(b, sizeof(b), f)) return 0;
x = strlen(b);
if(b[x - 1] != '\n' && (p = rfg(f, l + x))) {
p -= x;
memcpy(p, b, x);
return p;
}
p = (char *) malloc(l + x + 1) + l;
strcpy(p, b);
return p;
}

char *rfgets(FILE * f) {
return rfg(f, 0);
}

------------------------->8---------------------------

Usage:

char *line = rfgets(stdin);
...
free(line); // don't forget
Daniel