Allocating memory for structures in c

Question

struct data{
char *key;
char *fname;
char *lname;
char *grade;
struct data *next;
};


 newnode = (struct data*)malloc(sizeof(struct data));
 strcpy(newnode->lname,lname);
 strcpy(newnode->grade,grade);
 strcpy(newnode->key,key);
 strcpy(newnode->fname,fname);
 newnode->next=NULL;

So i was working on hashtables. The above code crashes while

struct data *newnode;
newnode = (struct data*)malloc(sizeof(struct data));
newnode->lname=(char*)malloc(strlen(lname)+1);
newnode->fname=(char*)malloc(strlen(fname)+1);
newnode->grade=(char*)malloc(strlen(grade)+1);
newnode->key=(char*)malloc(strlen(key)+1);

strcpy(newnode->lname,lname);
strcpy(newnode->grade,grade);
strcpy(newnode->key,key);
strcpy(newnode->fname,fname);
newnode->next=NULL;

this code seems to run. Why is that? As far as i understand i've already allocated memory for my struct in the heap. Why would i have to do it for each object specifically? Is there something else im missing? Cause i really don't understand why the bottom example would work.

We need more detail. Which line does it crash on, for instance? — Arya McCarthy, May 31 '17 at 06:17
Welcome to StackOverflow. Please take the [tour], learn asking good questions stackoverflow.com/help/how-to-ask, make a [mcve]. — Yunnosch, May 31 '17 at 06:20
As an aside: `strdup()` is a nicer way to duplicate strings than `malloc()/strcpy()` combinations. — Michael Burr, May 31 '17 at 06:20
@MichaelBurr The drawback is that `strdup` is not a standard function. Though I don't know any C compiler or system that doesn't come with it. — Some programmer dude, May 31 '17 at 06:21
You will also want to look at the obligatory "there is NO need to cast the return of `malloc`", it is unnecessary. See: [**Do I cast the result of malloc?**](http://stackoverflow.com/q/605845/995714) . — David C. Rankin, May 31 '17 at 06:32
Just because something isn't in the C standard doesn't mean it's not useful. — Michael Burr, May 31 '17 at 06:43
`strdup` is in POSIX and available also in Windows, so it is quite portable for desktop programs. When it fails to compile on some obscure platform, it is easy to provide an emulation. — Antti Haapala -- Слава Україні, May 31 '17 at 09:04

score 4 · Answer 1 · answered May 31 '17 at 06:19

When you do

newnode = malloc(sizeof(struct data));

you only allocate memory for the actual structure. But since the structure contains pointers, you need to make those pointers point somewhere valid. The single malloc call doesn't know anything about the contents of the structure, or how much extra memory it should allocate for all the pointers.

If, for example, you declare a single normal pointer variable you would not expect to be able to just use it as a destination for a strcpy call without allocating memory, would you?

Stephan Lechner · Accepted Answer · 2017-05-31T06:27:46.663

With newnode = (struct data*)malloc(sizeof(struct data)), you allocate memory only for struct data, which is a set of pointers, but you do not allocate any memory for that where these pointers are pointing to and where you will copy your strings to. So you have to allocate memory for each string separately, either by using malloc as in the second part of your question, or by using strdup, which does malloc and strcpy in one command:

struct data{
char *key;
char *fname;
char *lname;
char *grade;
struct data *next;
};


 newnode = (struct data*)malloc(sizeof(struct data));
 newnode->lname = strdup(lname);
 newnode-> grade = strdup(grade);
 newnode-> key = strdup(key);
 newnode-> fname = strdup(fname);
 newnode->next=NULL;

It's worth noting that strdup requires a string as input, i.e. a pointer that is not NULL and that points to a \0-terminated sequence of characters.

Thanks a lot both to you and @SomeProgrammerDude . That makes sense — Kyon Bugsy, May 31 '17 at 06:30

simo-r · Answer 3 · 2017-05-31T18:25:03.987

0

When you malloc a structure with char * inside it doesn't point anywhere (at least is NULL) so you've to malloc it as a normal sequence of characters also because you must know the size of the destination string. You can do it in your way using malloc and strcpy or just strdup.

edited May 31 '17 at 18:25

answered May 31 '17 at 06:30

simo-r

733
1
9
13

1

`strncpy()` is terrible for most uses - you need to jump through hoops to ensure that the destination is properly terminated. – Michael Burr May 31 '17 at 06:46
@MichaelBurr If the source string is properly terminated and you use strncpy in the right way it improves security and robustness of you code avoiding buffer overflows. – simo-r May 31 '17 at 06:52
1

@BetaRunner, strncpy has it's uses, but not as a "safe" version of strcpy. Sadly it's a much misunderstood function. Also the buffer returned by malloc may contain garbage, so there's no guarantee that the pointers in the stuct are NULL. Most likely they are not. – harald May 31 '17 at 17:53
@BetaRunner: Microsoft [disallows `strncpy()` in their own code](https://msdn.microsoft.com/en-us/library/bb288454.aspx) (and newer MSVC compilers warn about it by default for everyone) because of documented problems in its use. And here's [a quote from Linus Torvalds about `strncpy()`](http://yarchive.net/comp/linux/strncpy.html): "`strncpy()` is a frigging disaster when it comes to '\0', in many ways. We should probably disallow using `strncpy()`" – Michael Burr May 31 '17 at 20:01
You're right guys, I read a lot about it now and I agree with you. – simo-r May 31 '17 at 20:04

Allocating memory for structures in c

3 Answers3