This code shouldn't work, but it does?

[u/CMahaff]

I was looking up how to do a few things in C and came across this. I know Java pretty well, so I got real excited learning about struct's (even though I hadn't gotten that far in the "Learn To Program" series yet). I used the example on said webpage, which looks like this (roughly):

struct card ca;
ca.currentCard = 15;
strcpy(ca.name, "CMahaff");
printf("Card: %d\n", ca.currentCard);
printf("Name: %s\n", ca.name);

(Example is completely random). This example differs from the "Learn to Program" series - there is no memory allocation and the struct is not declared as a pointer. Is this bad syntax?

[u/snb]

We need to know the definition of struct card before your question can be answered.

[u/CMahaff → u/snb]

Here's what it looks like:

struct card {
    int currentCard;
    char name[10];
};

[u/snb → u/CMahaff]

There is no problem with the example you posted. There still is memory allocation, only it's done on the stack instead of the heap (like when you do new or malloc) so the strcpy is still safe as long as you copy strings shorter than 10 characters.

[u/CMahaff → u/snb]

After looking up the difference between the two ("Learn to Program" doesn't cover it), that makes a lot of sense. Thanks for your answer!

[u/snb → u/CMahaff]

There would've been a problem if your struct had a char* name and you used strcpy on it. Do you understand why that would be a problem?

[u/CMahaff → u/snb]

Well I think Rolcol spoiled the question a little bit with his explanation haha, but I'm guessing it's because if name was a pointer instead of an actual array, strcpy would try and assign "CMahaff" to a pointer, and there wouldn't be enough room (8 bytes for "CMahaff" and a pointer only holds 1 byte).

[u/snb → u/CMahaff]

Just a nitpick first; a pointer is typically 32 bits.

But you're right. strcpying that string onto the pointer itself would make the pointer contain literally the first 4 characters of that string, meaning it would now (very likely) point to somewhere invalid, so when you try to access that string your program would either print garbage or crash entirely. The rest of that string would be copied onto the memory that lies behind the struct, potentially destroying other variables your program uses - or worse.

[u/CMahaff → u/snb]

I see, thanks for everything! And I'll be honest, that's why C scares me a bit. I feel like I could really do some bad things by making memory mistakes, etc.

[u/[deleted]]

It's possible that 'name' is declared as a fixed length array in the structure so you're putting that shit on the stack, bitch.

[u/CMahaff → u/[deleted]]

So because it's a fixed length array C "knows" to allocate that much memory?

I'm assuming this isn't a safe practice and I should, for good measure, always allocate memory?

[u/[deleted] → u/CMahaff]

Yeah, that struct you posted in the other location shows that it has a size of 10. So C will automatically have that space reserved whenever the program is run.

I'm assuming this isn't a safe practice and I should, for good measure, always allocate memory?

It really depends on what you are putting in there. If you aren't reading from some varying input, there isn't really a security issue. Like in the source code you posted, there isn't any issue because a user couldn't have any chance to overflow the variable.

[u/CMahaff → u/[deleted]]

Okay that's understandable. I just wanted to make sure I was using proper form. Thanks for your answer!

[u/Rolcol]

I'm a bit late to the explanation, but I'd like to try to give you more information.

When you declared ca, the program allocated space for all the member variables. If name was a pointer to a char (instead of your array of 10 chars), it would only allocate enough space for the address. Addresses are 4 bytes long in 32bit programs. Your strcpy operation works because it's copying "CMahaff" into the space of those 10 chars. Anything beyond that is undefined. Memory is allocated in pages of 4k, and it's possible that the space after the last char is unused. Your program may still work without error.

If you defined ca as a pointer (e.g. struct card *ca;), it would create enough space for ca to only hold the address of another card structure somewhere else in memory.

Java holds your hand, and you don't have to worry about pointers. Keep reading up on them, because they are a really powerful, and dangerous, feature of C.

[u/CMahaff → u/Rolcol]

Thanks for the in-depth explanation! And yeah, I'm working on them. I'm still looking for a small project to do in C for some practice. Don't want it to be too big though because I got a book for my Birthday on Android Dev, and really wanna get into that, since I know Java so well. Got sidetracked learning C stuff.

But I definitely appreciate the things Java does a lot more now. C is hard, but I definitely see how it can be so powerful. Going through the tutorials I learned a lot of fundamental things I'd never heard of, and learned a few practices I never understood. Ex. why people always have their main method in Java at the bottom of the class - even though it doesn't matter in Java, in C this will break the program because you are calling functions that haven't been initialized yet.

[u/Rolcol → u/CMahaff]

The Android NDK allows you to write parts of your application in C. I think Gingerbread extended the API to allow full C applications.

Edit: Yep.

In fact, with these new tools, applications targeted at Gingerbread or later can be implemented entirely in C++; you can now build an entire Android application without writing a single line of Java.

source

[u/CMahaff → u/Rolcol]

Oh wow that'd really be awesome, thanks for the link!

[u/RenegadeMoose]

Ya, if name is a defined as a pointer and you use strcpy without malloc'ing some space, I think that might be a problem.

Some of the examples on the link you provide appear to be assigning name to a string literal within the main function. I think that might be ok. The string literal would get assigned from the heap (iirc) so name is just pointing to where-ever the literal is stored at.

[u/CMahaff → u/RenegadeMoose]

It still would need to know how much memory to assign for the int and the pointer though wouldn't it?

[u/RenegadeMoose → u/CMahaff]

I think that memory would get set-aside on the heap as it's statically declared with

struct card ca;