expect 'uint32' but argument is of type 'void *'

这个错误通常出现在使用函数时传递了错误类型的参数。函数期望的参数类型是 uint32，但你传递了一个 void 指针作为参数。请检查你的代码，确保传递正确的参数类型。如果你需要将 void 指针转换为 uint32 类型，请使用类型转换操作符。例如，如果你的指针变量名为 ptr，你可以使用以下代码将其转换为 uint32 类型：

uint32_t val = *((uint32_t*)ptr);

这将把 void 指针 ptr 转换为 uint32_t 指针，然后通过解引用操作符 * 获取该指针指向的值。

相关问题

format ‘%f’ expect argument of type ‘double’，but argument 2has tgpe ‘double’

当你看到这样的错误信息 "format '%f' expect argument of type 'double', but argument 2 has type 'double'"，这是因为在C语言或其他支持格式字符串（如C++的`printf`函数）中，你在尝试使用特定的格式说明符 `%f` 来格式化一个变量，但传入的第2个参数实际上不是`double`类型的浮点数。

`%f` 是用于格式化 `double` 类型数值的，例如 `printf("%.2f", value);` 这里 `value` 就应该是一个 `double` 变量。如果实际传递的是其他类型的值，比如整数 `int` 或者 `float`，编译器会报错，因为无法匹配预期的数据类型。

解决这个问题的方法就是确保你在调用 `printf` 函数时提供的参数类型与格式说明符匹配。如果你有第二个 `double` 类型的值需要打印，你应该直接指定 `%f`：

double num1 = 3.14;
double num2 = 2.71;
printf("两个数字分别是 %f 和 %f\n", num1, num2);

如果第二参数实际上是其他类型，你需要先将其转换为 `double`：

int int_val = 100;
printf("转换后的双精度数为 %f\n", (double)int_val);

One might expect the parameter to have the type List. That way, it seems likely, you could call it with parameters of type List or List for any class E. Explain carefully what is wrong with this argument and why the type List is used instead.

The argument that the parameter should have the type `List<E>` instead of `List<? extends E>` is based on the assumption that `List<E>` can be used to represent a list of any type of object. However, this assumption is incorrect. Consider the following example:

List<String> strings = new ArrayList<>();
List<Object> objects = strings; // Not allowed
objects.add(1);
String s = strings.get(0); // Throws ClassCastException at runtime

Here, `strings` is a `List<String>` and `objects` is a `List<Object>`. If we were allowed to assign `strings` to `objects`, we could add an integer to `objects`, violating the type safety of `strings`. This is why Java does not allow such an assignment.

Now, consider a method with a parameter of type `List<E>`. The following call might seem valid:

List<Object> objects = new ArrayList<>();
foo(objects);

However, if `foo` adds an element of type `E` to the list, it would violate the type safety of `objects`. This is why Java uses a bounded wildcard `List<? extends E>` instead of `List<E>`. This ensures that the method cannot add elements to the list, only read them, and does not violate the type safety of the argument list.