Thread: Why use malloc()

In this case, an accident probably saved you from yourself.

malloc() is most likely unable or unwilling to allocate only 1 byte of memory for you, hence you are probably actually having more than that being allocated. Nevertheless, this behavior, is potentially undefined, which means if you try this on another machine, you may as well crash since an int on most modern systems is a 32-bit number, which is 4 bytes.

Dynamically allocating memory is useful in cases where you will not know how much memory to allocate until runtime. Consider a program that has to read in an entire file and do some processing.... and assume that for whatever reason you need to have the entire file in memory, not just parts of it (although this is not always likely). How can you accomplish this? You could declare a massive array, but if you guess too small, your program can't read certain files. If you guess too large, your program wastes a substantial amount of memory. That plus arrays are limited in how big they can be on the stack.

Hence your alternative is to attempt to allocate about as much memory as you need when you need it. That's what malloc() and free() is for.

malloc() allocates data from the heap. On a Mac in OS X, the smallest amount of memory that you can get is 16 bytes, even if you ask for 1 byte. You operating system may be different. Your example just "happens" to work since your process "happens" to own the memory it is writing to.

Todd

Technically, the code you've just posted is not correct. You can't [on any ordinarily available machine] use 1 byte (the unit for malloc) and store an int - it takes 2 or 4 bytes. So correctly, you should do

Code:

ptr = malloc(1 * sizeof(int));

to ask for the right amount of memory for one integer.

It is of course a very silly example - there is no need to allocate memory at all for one integer in this example - you could just remove the star in front of ptr [and preferrably rename ptr], remove the malloc line altogether and remove the stars on assignment and printing, remove the free-line, and you'd get exactly the same result.

But then it would not be an example of allocating memory, which I suspect it is supposed to be. If this is part of some "real" code, then it's defnitely a bad choice. This is more like the woodworking stuff you do when you start doing woodwork at school - you cut a few pieces of wood and put them together, and call it a bookend or some such - but it's really not an advanced thing, just something to teach you the basic techniques of woodworking. Same if you learn to weld or solder - you start by just attaching bits of scrap metal together, then you do more advanced stuff. Get the idea?

--
Mats

Wow, thanks for the quick replies!

Ok, so I played around with my code a bit more and I have this now:

Code:

	char* ptr;
	
	ptr = malloc(1);
	
	if (ptr == NULL)
		printf("err");
	else
	{
		*ptr = "abcdefghijklmnopqrstuvwxyz-1234567890";
	
		printf("%s\n", *ptr);
	
		free(ptr);
	}

And thank goodness it crashed. Because if that code didn't cause any errors, I would be so confused.

So now that I'm using a c-string, how to malloc space on the fly? What do I put in the parameter for malloc?

EDIT:
I just want to thank you guys for the clarifications on malloc(), and that some systems allocate a min of say 4 or more bytes.

"something" == char*
So, *ptr = "Something" means *ptr = some_address_here;
The real way would be strcpy for C.
You're wrong about memory allocation too. One character takes one byte, so you need to do

Code:

malloc(sizeof(char) * length_of_string + 1);

All C strings have one extra byte at the end with the value 0 that tells all functions that this is the end of the string.

If you actually look at the assembly code, you'll see that the compiler takes the lower byte of the address of the string and puts it into ptr. In my testing, it put 0x38 there (which represents the character '8').
Unfortunately, this kind of thing is valid code in C, but fortunately, not in C++.

A pointer contains the address where a value is. Malloc(1) means you're allocating only one byte for a char array (!!!), which is only good for a NULL array (aka ""), because char array's length should be at least the text's length + 1 (null terminator).

With integer values (char, short, int etc) you can use this technique to get data into the pointed address:

Code:

*acharptr='A'; //note that 'A' represents an integer
*acharptr=245; //unsigned char can hold a value up to 255
*anintegerptr=50000;

But in case of a string (char array), it doesn't do what you want it to do. It makes the pointer point to a new location (the string you specified, hardcoded somewhere in the program memory) and means that the memory address of allocated memory gets lost, which means a memory leak.

To get data into a buffer, you should do something like this:

Code:

strcpy(ptr, "abcdefghijklmnopqrstuvwxyz-1234567890");

If you allocate memory for a char array, you MUST allocate enough bytes for the data you want to put into it. And if you don't know how long string it has to carry, then you could use a power of 2 as the length (256,512,1024 etc).

Code:

char *ptr;
ptr=malloc(1024*sizeof(char));
strcpy(ptr,"blablablabla");
strcat(ptr,"morestuff"); //append to char array
sprintf("string---> %s",ptr); //note that %s means a char array (char*), so no *ptr here
free(ptr);

And if you know the length of what you want to copy there:

Code:

char* ptr;
ptr=malloc((sizeof("yourstringhere")+1)*sizeof(char));
strcpy(ptr,"yourstringhere");
sprintf("string---> %s",ptr);
free(ptr);

K, so I'm trying to put a char array into a pointer. Maybe this doesn't make much sene, but yea. The following is bad code, I know that it is, but help me out.

Code:

	char* ptr;
	char word[26] = {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'};
	int count = 0;
	
	ptr = malloc(sizeof(char) * strlen(word) +1);
	
	if (ptr == NULL)
		printf("err");
	else
	{
		//How do I copy over the char array into the pointer? This is wrong...
		for (count=0; count<strlen(word); count++)
			strcat(ptr, word[count]);
		
		printf("&#37;s\n", ptr); //this is wrong
	
		free(ptr);
	}

Originally Posted by I-See-C

K, so I'm trying to put a char array into a pointer. Maybe this doesn't make much sene, but yea. The following is bad code, I know that it is, but help me out.

Code:

	char* ptr;
	char word[26] = {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'};
	int count = 0;
	
	ptr = malloc(sizeof(char) * strlen(word) +1);
	
	if (ptr == NULL)
		printf("err");
	else
	{
		//How do I copy over the char array into the pointer? This is wrong...
		for (count=0; count<strlen(word); count++)
			strcpy(word[count], ptr);
		
		printf("%s\n", *ptr); //this is wrong
	
		free(ptr);
	}

strlen won't work here, since you don't actually have a NUL at the end of your array of alphabet letters - the array only holds 26 elements, and none of those is zero. In this particular case you could use sizeof(word) - but that only works if you have a local array.

THis is also broken:

Code:

strcpy(word[count], ptr);

word[count] is a single char, and you are copying a string ptr into it - it will crash, I can guarantee it [assuming you ignore the warnings that the compiler will give for trying to pass a char as a pointer].

--
Mats