Thread: urgent regarding malloc()

Code:

#include<stdio.h>
#include<conio.h>
#include<malloc.h>
struct list{
int a;
struct list *ptr;
};
void main(void)
{
typedef struct list *nn ;
nn node;
printf("\t%d",sizeof(nn));
node=(nn)malloc(sizeof(nn));
printf("\tenter node\n");
scanf("%d",node->a);
printf("\t%d",node->a);
node->ptr=NULL;
free(node);
getch();
}

variable a is input from the user
but it gives a garbage value as output.

A good reason to argue that hiding pointers is a bad idea:

Code:

node=(nn)malloc(sizeof(nn));

You're only allocating enough memory for a pointer.

There's a zillion other things wrong with that surprisingly short program that I'm not even going to get into. I don't know if I could throw that many bad habits into such a short program even if I tried.

Sure, why not?

Code:

int main(void)

Take good note.

Code:

int main(void)
{
	typedef struct list* nn;
	nn node;
	printf("\t%d",sizeof(struct list));
	node=(nn)malloc(sizeof(struct list));
	printf("\tenter node\n");
	scanf("%d",&node->a);
	printf("\t%d",node->a);
	node->ptr=NULL;
	free(node);
	getch();
	return 0;
}

Indentation is nice. If you really want to keep the pointer hidden, you'll need the size of the struct, not the pointer to the struct. In addition, scanf will need an address of a variable, or else it'll crash.

> node=(nn)malloc(sizeof(struct list));
I'd prefer removing the cast

Code:

node=malloc( sizeof *node );

Plus I notice the OP used #include<malloc.h> instead of #include<stdlib.h> which makes me suspicious that they're using some brain-dead fossil compiler.

>I'd prefer removing the cast
Good call. I'm too used to C++, which would complain about that. Also, I wasn't sure if it was safe to dereference node since it hadn't been allocated any memory.

Despite what it looks like, sizeof *node is NOT a dereference of the pointer.

sizeof is compile-time, and the only "dereferencing" is done on a type basis. So what you get is the size of the type which a pointer points to. This can all be done without any reference to actual memory locations - it's just a traversal of the compiler's internal type tables.

Oh, and one more thing - the return result of malloc needs to be checked (for being not NULL) before it is dereferenced.

Good to know. Thanks a lot, Salem. Useful as usual.