Thread: malloc? What is this?

What is malloc? I've been wondering about this on thursday, did some online reading, told me about how it makes size of memory so you can use it outside the function or something like that. If anyone has time on their hands , can you guys explain this to me and how it will be used in a code... cause I have no idea what this is, but it seems important.

Thank you.

You can find a discussion of malloc and the data type it returns at our fine web site. http://www.cprogramming.com/tutorial/c/lesson6.html

Originally Posted by citizen

You can find a discussion of malloc and the data type it returns at our fine web site. http://www.cprogramming.com/tutorial/c/lesson6.html

Thanks for the quick response, and thanks for the link. I'll check it out, see if I can do it on my own, but I need help, I'll post it here Thanks you guys ^^. Very grateful

Originally Posted by dwks

Well, you're rather confused, I think. You're using the wrong variable in several places; you're allocating a multiple of sizeof(int) rather than of char. You're using int* instead of char*. Your code has several typos which makes me think you typed it from memory (or something) rather than copy-pasting it, which is never a good idea. (Your prototype says "bar", not "ar", and you're missing a closing parenthesis.)

And you're using such short variable names that it can't be helping you figure things out.

It's quite simple, really.

• Calculate how much memory you need. This will likely be the length of the string you want to copy, plus one for a NULL char.
• Allocate that much memory, and store it in a char* pointer!
• Copy your substring to this new memory.
• Return your new string.

Perhaps you're thinking of something like this.

Code:

char *extract_substring(char *string, int start, int length) {
    char *new_str = malloc(length - start + 1);
    strcpy(new_str, string + start);
    return new_str;
}

Let me see if I understand what you wrote...

Code:

char *extract_substring(char *string, int start, int length)

- Means you want "extract_substring" to be a pointer to a char.
- The function of "extract_substring" has a pointer named "string" pointing to a char, has a int called "start", and also a int called "length".

Code:

char *new_str = malloc(length - start + 1);

- A new pointer called "new_str" (which we want it to be a new string later on), is a pointer to a char.
- The pointer called "new_str" also has malloc(length - start + 1);, which is how much space we want to allocate. And the amount of memory we want to allocate is (the length of the string) - (the starting index given) + (NULL termination so '\0' or 0)

Code:

    strcpy(new_str, string + start);  
         return new_str;

- In this part we are copying the string with "strcpy" and we are copying the "new_str". I don't quite understand the part of "string + start.
- Then finally we want to return the "new_str" like I wanted...


can you tell me if I'm somewhat on the right track reading this. Thanks for helping me out. really appreciate it

Originally Posted by citizen

I think a more correct line-by-line dissection would be (slight edits to dwks' example)

Code:

1: char * 
2: extract_substring ( char * str, int start, int length )
3: {
4:    char * new_str = malloc( length - start + 1 );
5:    strncpy( new_str, str + start, length );
6:    new_str[length] = '\0';
7:    return new_str;
8: }

1. The function's return value - you know that this will return a string.

2. On this line is the name of our function, which explains what it does, and the parameters required to do it. We have the original string named str, a starting location named start and a length of characters to copy. All of these parameters have data types.

4. We call malloc on this line. As you should have learned from the tutorial, malloc returns at least the amount of its argument (a size) in bytes.

5. The example uses pointer arithmetic to start copying at the appropriate index. Without going into a lesson, it's as if we moved str by start characters and stored the value in strncpy's source argument. But this does not affect the value stored in str. We could have accomplished the same with the syntac &str[start] - what you use is up to you.

Going into a lesson, treat pointers like a ruler when you do arithmetic with pointer variables. Additiion and subtraction is like moving up and down a number line, and you can imagine the stored address moving up and down n-bytes. When you store this calculated amount (assignment) think of it like marking a spot on a ruler.

For larger data than a char, you will have to multiply by the size of the object to get the difference in addresses, but that's really low level thinking. You're almost never concerned with the size of things as much as how many elements you skipped over in the array.

The copy happens and we move on to line six.

6. This terminates the string by storing a zero at that index.

7. Then you return the string desired and the function is done.

YOU GUYS ARE SO SMART AND SO GODLY!!!!! , I FULLY UNDERSTAND THIS!!!

but can't we write like what "pheonix_rebirth" wrote? something char *p = malloc( (many + 1) * sizeof(char))

and do something like this?

but you guys are truly godly, i will see if this works and stuff... Coding is lots of work, but its soo fun . Thanks guys, I really appreciate it.

>> but can't we write like what "pheonix_rebirth" wrote? something char *p = malloc( (many + 1) * sizeof(char))

You can write that, but sizeof (char) is always 1. More generally, the size of things will be important, as you need say 20 bytes for five integers. This was covered in the tutorial I think.

Originally Posted by citizen

>> but can't we write like what "pheonix_rebirth" wrote? something char *p = malloc( (many + 1) * sizeof(char))

You can write that, but sizeof (char) is always 1. More generally, the size of things will be important, as you need say 20 bytes for five integers. This was covered in the tutorial I think.

yeah, it was covered, and char is 1 byte right and integer is 4? Or something like that.... but I was just wondering if there was another way to write this with malloc.

you mean

Code:

char * new_str = malloc( (length - start + 1)*sizeof(char) );

?
Sure.

4 bytes for int isn't guaranteed, but is usually the case on modern PCs with modern compilers.