C语言按已知大小强制转换void指针

Question

Simple question, can we in c language cast void pointer by known size by unknown data type?

Consider this situation:

function assertEqual , which should get 2 pointers as arguments, dereference them and equal value. You can't of course dereference void pointer, but what if I know size of data, which the pointer point to? Can I create some dynamic pointer of known size but unknown data type? The function should looks like assertEqual(void* expected, void* current, size_t size) .

Answer 1

您可以将参数转换为unsigned char* ，然后比较第一个size字节（或者更好地使用memcmp来执行此操作），但不能保证在给定值有多个表示的情况下它会执行您想要的操作（例如，考虑在结构中填充，填充内容的差异可能是无害的，但是可以通过这种方法检测到，还有其他情况，例如浮点格式的NaN值，并且在技术上可能发生在最原始的情况下类型）。

Answer 2

Can I create some dynamic pointer of known size but unknown data type?

As a general rule. no. You need to know the type to typecast the void pointer. eg float and int both have a size of 4 bytes but the types are not equivalent.

However, if you have equivalent types, then you can typecast to the equivalent type. eg on some systems int and long are both 4 bytes and are equivalent.

Answer 3

Simple question, can we in c language cast void pointer by known size by unknown data type?

No. Every pointer type has a specific type to which it points. That includes void * , whose referenced type ( void ), is an incomplete type provided by the language. There is no such thing as a pointer to an unknown data type, though in void * you have a pointer type that is is interconvertible with all other object pointer types.

On the other hand, it is valid to access objects of any type via a pointer to a character type (eg char * , unsigned char * ), and one way to do that is via an lvalue whose type is an array of characters. You could get something very similar to what you ask like so:

int assertEqual(void* expected, void* current, size_t size) {
    unsigned char (*ep)[size] = expected;
    unsigned char (*cp)[size] = current;
    // ...
}

That makes use of a variable-length array type as the pointed-to type: pointers ep and cp each point to an array of size elements of type unsigned char . The size of that array type is size , so, for example, you will indeed find that sizeof(*ep) == size . That is, you have a pointer to an object of the specified size, through which you are permitted to access the bytes of that object.

As others have already pointed out, however, what you ask is kinda pointless. If you just want to compare two byte sequences without knowing what type of object they represent, then you can use memcmp() . On the other hand, that is not safe as a general equality test because two objects with different byte sequences can nevertheless be equal when compared as objects of a given type. This happens because many integer types are permitted to have padding bits that do not contribute to their values, and because floating-point representations are completely implementation-dependent.

Furthermore, struct and union types can contain padding bytes with unspecified, and not necessarily consistent values. You cannot compare compound types with the == operator, but comparing the byte arrays constituting the representations of such objects does not necessarily yield the same result as would comparing the objects on a per-member basis.