输入punning和malloc'ed记忆

Question

I originally asked this question: Type Punning with Unions and Heap

And not wanting the question to keep evolving to the point that anyone reading in the future had no idea what the original question was, I have a spin off question.

After reading this site: https://kristerw.blogspot.com/2016/05/type-based-aliasing-in-c.html

Near the bottom it talks about malloc'd memory. Is it safe to say that casting from one pointer type to another pointer type is safe when memory is on the heap?

Example:

#include <stdio.h>
#include <stdlib.h>

struct test1
{
    int a;
    char b;
};

struct test2
{
    int c;
    char d;
};

void printer(const struct test2* value);

int main()
{
    struct test1* aQuickTest = malloc(sizeof(struct test1));
    aQuickTest->a = 42;
    aQuickTest->b = 'a';
    printer((struct test2*)aQuickTest); //safe because memory was malloc'd???
    return 0;
}

void printer(const struct test2* value)
{
    printf("Int: %i Char: %c",value->c, value->d);
}

And guessing it might not be safe. What would be the proper way to do this with memcpy? I will attempt to write an example with a function of what might hopefully work?

struct test2* converter(struct test1* original);

int main()
{
    struct test1* aQuickTest = malloc(sizeof(struct test1));
    aQuickTest->a = 42;
    aQuickTest->b = 'a';
    struct test2* newStruct = converter(aQuickTest);
    printer(newStruct);
    return 0;
}

struct test2* converter(struct test1* original)
{
    struct test2* temp;
    memcpy(&temp, &original, sizeof(struct test2));
    return temp;
}

Answer 1

void *pnt = malloc(sizeof(struct test1));

What type has the memory behind pnt pointer? No type. It is uninitialized (it's value is "indeterminate"). There is just "memory".

Then you do:

struct test1* aQuickTest = malloc(sizeof(struct test1));

You only cast the pointer. Nothing happens here. No assembly is generated. Reading uninitialized memory is undefined behavior tho, so you can't read from aQuickTest->a (yet). But you can assign:

aQuickTest->a = 1;

This writes to an object struct test1 in the memory. This is assignment. You can now read aQuickTest->a , ie. print it.
But the following

printf("%d", ((struct test2*)aQuickTest)->a);

is undefined behavior (although it will/should work). You access the underlying object (ie. struct test1 ) using a not matching pointer type struct test2* . This is called "strict alias violation". Dereferencing an object (ie. doing -> or * ) using a handle of not compatible type results in undefined behavior. It does not matter that struct test1 and struct test2 "look the same". They are different type. The rule is in C11 standard 6.5p7 .

In the first code snipped undefined behavior happens on inside printf("Int: %i Char: %c",value->c . The access value-> accesses the underlying memory using incompatible handle.

In the second code snipped the variable temp is only a pointer. Also original is a pointer. Doing memcpy(&temp, &original, sizeof(struct test2)); is invalid, because &temp writes into the temp pointer and &original writes into the original pointer. No to the memory behind pointers. As you write out of bounds into original pointer. No to the memory behind pointers. As you write out of bounds into original pointer. No to the memory behind pointers. As you write out of bounds into &temp pointer and read of bounds from &original pointer (because most probably sizeof(temp) < sizeof(struct test2) and sizeof(original) < sizeof(struct test2)`), undefined behavior happens.

Anyway even if it were:

    struct test1* original = &(some valid struct test1 object).
    struct test2 temp;
    memcpy(&temp, original, sizeof(struct test2));
    printf("%d", temp.a); // undefined behavior

accessing the memory behind temp variable is still invalid. As the original didn't had struct test2 object, it is still invalid. memcpy doesn't change the type of the object in memory.