Stack smashing detected问题解析：结构体强制类型转换引发的栈溢出原因排查

Let's break down exactly why your code is triggering that stack smashing error—it all boils down to memory overwriting caused by unsafe type casting and mismatched struct sizes.

First, let's look at your struct definitions:

• type1 is a struct with 6 int members, so it takes up 6 * sizeof(int) bytes (usually 24 bytes on systems where int is 4 bytes).
• type2 only has 3 int members, so it's half the size—3 * sizeof(int) (12 bytes).

Your copy function does a straightforward struct assignment: *arg = RTE;. This means it copies the entire 24-byte type1 value into the memory location pointed to by arg.

Here's the problem: when you call copy((type1 *) &local);, you're telling the compiler "treat the address of local (a 12-byte type2 variable) as if it points to a 24-byte type1 struct". The copy function doesn't know any better—it proceeds to write all 24 bytes of RTE into that memory space.

But local only has 12 bytes allocated on the stack. The extra 12 bytes get written to the memory immediately after local on the stack. That memory isn't yours to use—it's likely holding critical stack frame data (like a stack "canary" value that modern compilers insert to detect buffer overflows).

When your program tries to exit the main function, the compiler's stack checking code notices that the canary value has been overwritten. That's when it throws the "Stack smashing detected" error to alert you that you've corrupted the stack.

To make this even clearer:

• local occupies bytes [0-11] on the stack (example addresses)
• copy writes bytes [0-23], overwriting bytes [12-23] which belong to the stack's internal structures

This kind of type casting is considered undefined behavior in C. The language only allows type aliasing with char*—casting a pointer to a different struct type like this breaks strict aliasing rules and leads to unpredictable results (stack smashing is just one possible outcome).

内容的提问来源于stack exchange，提问作者Robert Ilin