如何解决'(strict) incompatible pointers in ='指针不兼容赋值错误？

Ah, that classic strict incompatible pointers error—total pain when you’re scratching your head over why the compiler’s throwing a fit, right? You’re spot-on that it’s all about mismatched pointer types during assignment, especially when strict type checking is enabled (like with GCC’s -Wall or -Wstrict-aliasing flags). Let’s break down the most common cases and how to fix ’em:

• Const-qualifier mismatches
  This is one of the most frequent culprits. If you’re trying to assign a const-qualified pointer to a non-const one, the compiler will yell because you’re discarding the const protection. For example:

  const char* read_only_str = "I'm immutable";
  char* mutable_str = read_only_str; // ❌ Strict incompatible pointers error
  

  Fix it by either adding const to the target pointer (the right move 99% of the time, since string literals are read-only):

  const char* mutable_str = read_only_str; // ✅
  

  Or if you really need to modify the data (and you’re 100% sure it’s safe—like if the underlying memory isn’t actually read-only), use an explicit cast (but add a comment explaining why you’re doing this, because it’s risky):

  char* mutable_str = (char*)read_only_str; // ⚠️ Use with extreme caution
  

• Mismatched custom types/struct pointers
  If you’re assigning a pointer to one struct type to a pointer of a completely different struct type, the compiler will flag it immediately. For example:

  struct Car { int wheels; };
  struct Bike { int wheels; };
  struct Car* my_car = malloc(sizeof(struct Car));
  struct Bike* my_bike = my_car; // ❌ Types are unrelated
  

  Fix this by making sure you’re using the correct type everywhere. If you must cast between them (only do this if you’re dealing with a union or you’re certain the memory layouts are identical), use an explicit cast, but again—proceed with caution, as this can lead to undefined behavior.

• Array-to-pointer type confusion
  Arrays decay to pointers, but only to pointers of their base type. If you try to assign an array of int to a char* pointer (or vice versa), you’ll get this error:

  int numbers[5] = {1,2,3,4,5};
  char* num_ptr = numbers; // ❌ int* vs char* mismatch
  

  Simple fix: Use the correct pointer type for the array:

  int* num_ptr = numbers; // ✅
  

• Function pointer signature mismatches
  Function pointers are picky about their signatures—return type and parameter types must match exactly. For example:

  void (*print_int)(int);
  void print_char(char c) { printf("%c", c); }
  print_int = print_char; // ❌ Parameter type mismatch
  

  Fix this by ensuring the function pointer and the target function have identical signatures, or adjust one to match the other.

Also, a quick tip: Enable stricter compiler warnings (like -Wall -Wextra -Werror) to catch these issues early—turning warnings into errors forces you to fix them before they turn into runtime bugs.

If you can share a snippet of the code that’s triggering the error, I can give you a more tailored fix, but these are the most common scenarios that cause this strict pointer mismatch error.

内容的提问来源于stack exchange，提问作者Ben Groseclose