strings and memory

[stormbringer]

hi

i'm a little confused about strings and memory. if i specify a statement like:

char *mystring;

mystring="Hello";

what happens then? is memory allocated automaticaly or is this potentialy dangerous? would it be beter to do the folowing?

char *mystring;

mystring=(char *)malloc((strlen("Hello")+1)*sizeof(char));
mystring="Hello";

especialy: what's happening if i read a string from a file e.g. with fgets and then do want to use it throughout my programm. is it sufficient to make mystring = fgets(...) or do i need to guesse the lengt and malloc it, then fill it?

thanks

[Stoned_Coder]

char *mystring;

mystring="Hello";

This is ok as long as you realise that the string "Hello" is in static read only memory. You may not write to this string.

char *mystring;

mystring=(char *)malloc((strlen("Hello")+1)*sizeof(char));
mystring="Hello";

This is a balls-up! A memory leak!
You get dynamic memory then throw it away by repointing your pointer at a static string. To place the string "Hello" in the memory pointed to by mystring you should have used strcpy(). If you had used strcpy then this string could be modified if you wanted to unlike the first example.

[stormbringer]

ok

another question:

if i have functions like:

int main()
{
	char *mystring = f1();
	...;
	f2(mystring);
}

char *f1(...)
{
	char *mystring;
	fgets(mystring,100,f);
	return mystring;
}

int f2(char *mystring)
{	
	do something with the string;
}

i'd think that this wan't work, because when exiting f1 the memory is freed and the pointer points to nirvana. right? so here i need to go the way over malloc?

thanks

[Cela]

>>because when exiting f1 the memory is freed and the pointer points to nirvana. right?
It won't work, but not how you think. The problem is that mystring is a pointer to garbage and you try to use fgets to read into memory you don't have. This should cause an access violation of some sort. What you need to do is allocate memory first.

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

char *f1(void)
{
  char *mystring;

  if ((mystring = malloc(100)) == 0)
  {
    return 0;
  }

  fgets(mystring,100,stdin);

  return mystring;
}

void f2(char *mystring)
{
  printf("%s\n", mystring);
}

int main(void)
{
  char *mystring = f1();

  if (mystring != 0)
  {
    f2(mystring);
  }

  return 0;
}

[stormbringer]

i see. so if i want to read a small file into memory (parts of the line, which specify options) i qould do best to write a function with a array of let's say thousand. then get the real stringlength (linelength) and malloc that much memory for each line (storing those strings in a linked list or tree or something). that would save me memory (at cost of efficency), right?

[Shiro]

You can use standard library functions for calculating the size of a file. Use fseek() to put the filepointer at the end and then use ftell() to get the file length.

Then you could use malloc() to allocate the necessary memory. You could allocate one block of memory for the whole file or use a linked list to store each line in a node.

That's more efficient memory use than your proposal, because if you write a function with an array of thousand, you already have allocated that thousand bytes, but you don't know if you would need it all. On the other hand the situation could happen that you needed more than thousand bytes.

[stormbringer]

but if the file is too large to read into memory, there's a problem. and there's no way to get the lenght of a line in an acceptable time (we could determine it by going from \n to \n with fgetc, but that will slow down the programm)
so the only way is going over a buffer that maybe wastes memory, but when exiting the function, memory will be free and just the precisly allocated meory from the relevant lines remains.

isn't it so?

[Shiro]

Do you need a program that fast? Yes, when the file is too large, it won't fit in the memory and you need to implement a buffer mechanism. This does not necessarily need to be a waste of memory. You could consider the array being a queue. At the tail you add characters and at the beginning you read characters. In this way you can analyze the stream of characters and your buffer is never empty. Unless you have almost reached the end of the file or in the beginning ofcourse.

[stormbringer]

well, i once wrote a programm scaning, converting and replacing expressions in a 8gb logfile.
with a buffer the file runs for about half an hour or so, without two days.....

however, what confused me was porting strings between functions. that programm did all the string stuff in one function.

thank you all