DaniWeb Forum Index > Software Development > C

C RSS

dynamically allocating memory-malloc

Thread Solved

•

Join Date: Aug 2008

Posts: 91

Reputation: CPPRULZ is an unknown quantity at this point

Solved Threads: 0

CPPRULZ

Offline

Junior Poster in Training

dynamically allocating memory-malloc

Feb 4th, 2009

Hi lately i have been studying the malloc and calloc functions for dynamically allocating memory. I thought the form was:

 Help with Code Tags 
 C Syntax (Toggle Plain Text) 
(data_type*) malloc(data_size);
(data_type*) malloc(data_size);

But then I stumbled onto this code snippet on a tutorial site:

 Help with Code Tags 
 c Syntax (Toggle Plain Text) 
#include <cstdlib>
    void *malloc( size_t size );
#include <cstdlib>
    void *malloc( size_t size );

Why is the data type void?
Is my understanding of the malloc and calloc functions wrong or is this website wacky?
Oh and is the * after void for the pointer returned?

Last edited by CPPRULZ; Feb 4th, 2009 at 2:17 am.

•

Join Date: Dec 2007

Posts: 443

Reputation: Agni is a jewel in the rough

Solved Threads: 68

Agni

Offline

Posting Pro in Training

Re: dynamically allocating memory-malloc

Feb 4th, 2009

malloc returns a void* to the memory allocated and you need to ensure that you type cast it to the correct type.

thanks
-chandra

•

Join Date: Apr 2008

Posts: 670

Reputation: Freaky_Chris is a jewel in the rough

Solved Threads: 113

Freaky_Chris Freaky_Chris is offline

Offline

Practically a Master Poster

Re: dynamically allocating memory-malloc

Feb 4th, 2009

 Help with Code Tags 
 c Syntax (Toggle Plain Text) 
void *malloc ( size_t size );
void *malloc ( size_t size );

This is the function prototype, and as Agni stated it returns a void pointer. Since this is the function prototype you do not use this syntax when calling the function and infact you use the syntax you originally posted. Here is a small example

 Help with Code Tags 
 c Syntax (Toggle Plain Text) 
int q = 34;
char *test;
test = (char*)malloc(q);
...
free( test );
int q = 34;
char *test;
test = (char*)malloc(q);
...
free( test );

The snippet above will create a character array (c-string) of length 33, since 1 space is need for the null terminator. Be sure to read about the use of free(), it's essential!

Chris

Last edited by Freaky_Chris; Feb 4th, 2009 at 5:29 am.

Knowledge is power -- But experience is everything

•

Join Date: Jan 2009

Posts: 476

Reputation: csurfer is just really nice

Solved Threads: 76

csurfer

Offline

Posting Pro in Training

Re: dynamically allocating memory-malloc

Feb 4th, 2009

malloc(<size>) just allocates a memory space for the size specified and returns a void * pointer pointing to the starting of the allocated memory block.
It returns a void * pointer (so that it can be type cast to any pointer type) and as you know void * pointer itself cannot be used to dereference any variable.So we need to typecast it according to our needs.
Example:

 Help with Code Tags 
 c Syntax (Toggle Plain Text) 
struct node{
int a ;
char b;
};
typedef struct node * NODE;
 
int main()
{
//Some code
 
NODE temp=(NODE)malloc(sizeof(struct node));
 
//Some code
}
struct node{
int a ;
char b;
};
typedef struct node * NODE;

int main()
{
//Some code

NODE temp=(NODE)malloc(sizeof(struct node));

//Some code
}

General form:

<req>*<variable> = (<req>*)malloc(<size>);

Last edited by csurfer; Feb 4th, 2009 at 1:02 pm.

I Surf in "C"....

•

Join Date: Sep 2004

Posts: 7,630

Reputation: Narue has a reputation beyond repute

Solved Threads: 718

Narue

Offline

Code Goddess

Re: dynamically allocating memory-malloc

Feb 4th, 2009

The cast is bad in C. It hides potential errors such as forgetting to include <stdlib.h> and makes maintenance more difficult if you change the type of the pointer, so you'd best get into the habit of not casting the return value. Pointers are implicitly converted to and from void* with no complaints, so there's no good reason to cast anyway.

Here's a much improved form:

 Help with Code Tags 
 c Syntax (Toggle Plain Text) 
/* Allocate one object */
p = malloc ( sizeof *p );
 
/* Allocate N objects */
p = malloc ( N * sizeof *p );
/* Allocate one object */
p = malloc ( sizeof *p );

/* Allocate N objects */
p = malloc ( N * sizeof *p );

The cast is a throwback from the dark ages when char* was the generic pointer rather than void* and there wasn't an explicit conversion rule in place.