Howto declare a string without knowing how big it would be in c?

[Face_Man]

Hello All,

if i want to declare a string but i don't know how big it would be, it could be 300 or 7000 or maybe more.

for example:

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
char *FristFun(char *Parm){
	char  ReturnStr=malloc(1*sizeof(char));
	//Do somthing unique in this function
	ReturnStr = realloc(ReturnStr,(strlen(ReturnStr) + strlen(Parm)+1));

	strcpy(ReturnStr , Parm);
	return ReturnStr;
}

char *SecondFun(char *Parm){
	char ReturnStr = malloc(1*sizeof(char));
	//Do somthing unique in this function
	ReturnStr = realloc(ReturnStr,(strlen(ReturnStr) + strlen(Parm)+1));
	strcpy(ReturnStr , Parm);
	return ReturnStr;
}

char *ThirdFun(char *Parm){
	char ReturnStr = malloc(1*sizeof(char));
	//Do somthing unique in this function
	ReturnStr = realloc(ReturnStr,(strlen(ReturnStr) + strlen(Parm)+1));
	strcpy(ReturnStr , Parm);
	return ReturnStr;
}
int main() {

	char FristReturn = malloc(1*sizeof(char));
	char SecondReturn = malloc(1*sizeof(char));
	char ThirdReturn = malloc(1*sizeof(char));
   
    	{//Get Values
		strcpy(FristReturn,FristFun("111111111111111111111111"));
		strcpy(SecondReturn,SecondFun("2222222222222222222222"));
		strcpy(ThirdReturn,ThirdFun("3333333333333333333"));
	}

	printf("\n============================================\n");
	printf("FristReturn:\n\t%s\n",FristReturn);
	printf("SecondReturn:\n\t%s\n", SecondReturn);
	printf("ThirdReturn:\n\t%s\n", ThirdReturn);
 	printf("\n============================================\n\n");
    	{//Free Var's
		free(FristReturn);
		 free(SecondReturn);
		 free(ThirdReturn);
	}
	return 0;
}

this is just an example the function should return a bigger string than this. however the programing dose not seem to be working and from what i understand i have to use malloc and realloc to change the size of char.


Therefore, how can i declare a dynamic char that could be as big as what i store in it ?

Any help would be much appreciated.

[slavik]

no you can't.

[phrostbyte]

You have to keep track of the capacity of the array, and then realloc if the actual size of string gets to the capacity of the array. AFIAK, realloc is not always guaranteed to succeed. What you have to in the case realloc fails is memcpy the entire array to a new, larger array, and then free the old array (although I think realloc will do this for you). Essentially this is what the string (and vector) implementation in C++ does. So you can do it, but it is a very expensive operation to resize a large string, and should be avoided if possible.

[LKjell]

hmm do this?

char* str = "Hello\0";

[Bachstelze]

hmm do this?

char* str = "Hello";

No, the point is that you don't know in advance how large the string will be. Obviously that means you also don't know what it is.

[LKjell]

No, the point is that you don't know in advance how large the string will be. Obviously that means you also don't know what it is.

oh trust me you always know. If there is input then a modified fgets and getline will do its job. There is also dynamic allocation during runtime.

[Compyx]

If you just want to grab a copy of a string then you can do something like this:

char *dupstr(const char *s)
{
    size_t n = strlen(s) + 1;
    char *p = malloc(n);
    if (p != NULL) memcpy(p, s, n);
    return p;
}

Many C implementations provide a function strdup() as an extension, which does what the above function does. strdup() is not part of the standard C library so you would loose a little portability by using it.

As a side note: sizeof(char) is 1 by definition, so in stead of writing:

x = malloc(n * sizeof(char));

you can simply write:

x = malloc(n);

HTH

[Bachstelze]

As a side note: sizeof(char) is 1 by definition, so in stead of writing:

x = malloc(n * sizeof(char));

you can simply write:

x = malloc(n);

However what it one wants to switch from plan chars to, say, Unicode characters? A simple

sed 's/sizeof(char)/sizeof(your_unicode_char_here)/g'

would do. If you just assumed it to be 1, you're screwed.

[phrostbyte]

If you just want to grab a copy of a string then you can do something like this:

char *dupstr(const char *s)
{
    size_t n = strlen(s) + 1;
    char *p = malloc(n);
    if (p != NULL) memcpy(p, s, n);
    return p;
}

Many C implementations provide a function strdup() as an extension, which does what the above function does. strdup() is not part of the standard C library so you would loose a little portability by using it.

As a side note: sizeof(char) is 1 by definition, so in stead of writing:

x = malloc(n * sizeof(char));

you can simply write:

x = malloc(n);

HTH

That's a very nice example. Here is just a possible modification.

This function _should_ (cross-fingers), resize a string, without modifying its contents. It does so by allocating a new chunk of memory, copying it over, freeing the original chuck, and rebasing the pointer. It assumes s points to some data allocated on the heap, and that n is NOT less then the data allocated. And yes if there are any other pointers to this string, they are invalid after calling this. Might be a way to avoid these disadvantages (double pointers, heh)..

char *strresize(char* const s, size_t n)
{
    char *p = malloc(++n);
    if (p != NULL) memcpy(p, s, n);
    else return;
    free(s);
    return p;
}

Now someone else can code a strcat that calls this function as needed. Wow, a mildly safe strcat in C.

[LKjell]

modify const is kinda risky... And if you allocate the string on the stack free will give you a nice Christmas tree.