Copying to free store

Hi,

I am doing an exercise that states to write a function that copies a c-style string into memory it allocates on the free store and to not use any standard library functions. This is what I have so far:

Code:

char* foo(char* c)
{
	char* e = new char;
	e=c;
	
	return e;
}

int main()
{
		
		
	char* f = func("hello");

	cout << f;
	

}

It seems to work, and the cout prints correctly. My concern is that I have allocated memory on the free store without immediate initialisation, that was done in the line below. Is this how it is done?

Thanks,

It is not. You have allocated one character on the free store and given its address to e. Then you have reassigned e to the string literal "hello", which exists in memory allocated by main(). Then you, via the function return, assigned the "hello" address to f. Printing f will print "hello", but you have done little but confuse yourself. No offense. Check it out:

Code:

char* foo(char* str)
{
   //Find out how big the string referred to by str is.
   //That is, write your own strlen implementation.
   //Then,
   
   unsigned int len = MyStrlen(str);
   char* returnable = new char[len];
   
   //Copy, character by character, the contents of str into returnable.
   //That is, write your own implementation of strcpy.
   //Then,

   return returnable;
}

int main()
{
   const char* lit = "hello";
   char* f = foo(lit);  ///const trouble? I'm not sure.
   std::cout << f << " is a copy of " << lit << std::endl;

   delete [] f; //so easy to forget... your program has a leak, by the way.
   return 0;
}

Originally Posted by CodeMonkey

It is not. You have allocated one character on the free store and given its address to e. Then you have reassigned e to the string literal "hello", which exists in memory allocated by main(). Then you, via the function return, assigned the "hello" address to f. Printing f will print "hello", but you have done little but confuse yourself. No offense. Check it out:

Code:

char* foo(char* str)
{
   //Find out how big the string referred to by str is.
   //That is, write your own strlen implementation.
   //Then,
   
   unsigned int len = MyStrlen(str);
   char* returnable = new char[len];
   
   //Copy, character by character, the contents of str into returnable.
   //That is, write your own implementation of strcpy.
   //Then,

   return returnable;
}

int main()
{
   const char* lit = "hello";
   char* f = foo(lit);  ///const trouble? I'm not sure.
   std::cout << f << " is a copy of " << lit << std::endl;

   delete [] f; //so easy to forget... your program has a leak, by the way.
   return 0;
}

Thanks, I will have a go at implementing that now.

Darren.

For my own strlen function, would it be something as simple as:

Code:

int len = 0;
	for(int i=0; str[i]!=0; ++i){
		++len;
	}

I have this as the final solution, is this correct?

Code:

char* foo (char* str)
{
	int len = 0;
	for(int i=0; str[i]!=0; ++i){
		++len;
	}

	char* returnable = new char(len);

	for(int i = 0; i<len; ++i){
		returnable[i] = str[i];
	}

	return returnable;

	

	
	
}

Almost, look at the difference between your 'char* returnable =' line and CodeMonkey's above. Yours allocates one char and initializes it with the value of len (the effect of the round brackets), the other allocates an array of len chars (the effect of the square brackets). Just a little error in syntax, along with forgetting to account for the terminating 0 on returnable, but otherwise fine. Though if you're going to be doing other exercises which have the no standard library requirement, it'll be worth breaking the copying and length finding code into seperate functions.

> char* returnable = new char[len];
You forgot to count the \0

> char* returnable = new char(len);
There is a big difference between using [ ] and ( )
[ ] allocates an array of the specified size
( ) allocates a single object, and initialises it to the provided value.

Originally Posted by adeyblue

Almost, look at the difference between your 'char* returnable =' line and CodeMonkey's above. Yours allocates one char and initializes it with the value of len (the effect of the round brackets), the other allocates an array of len chars (the effect of the square brackets). Just a little error in syntax, along with forgetting to account for the terminating 0 on returnable, but otherwise fine. Though if you're going to be doing other exercises which have the no standard library requirement, it'll be worth breaking the copying and length finding code into seperate functions.

Thanks for that.

Originally Posted by Salem

> char* returnable = new char[len];
You forgot to count the \0

My bad.