Different semantics between `char *` and `int *` - c

Question

I want to know why declaring and assigning a char * versus an int * in C have different semantics.
All of the following code is compiled with clang using the flags -Wall -Werror -std=gnu99 --pedantic.
I am trying to understand whether the difference is something that just is, or whether there's some bigger difference between int * and char * that I have yet to realize.
// this will compile
int main(int argc, const char *argv[]) {
char *a;
a = "1";
printf("a: %s\n", a);
return EXIT_SUCCESS;
}
// this will not compile. It's a parallel construction, substituting char for int
#include <stdio.h>
#include <stdlib.h>
int main(int argc, const char *argv[]) {
int *a;
a = 1;
printf("a: %d\n", a);
return EXIT_SUCCESS;
}
// but this will compile
#include <stdio.h>
#include <stdlib.h>
int main(int argc, const char *argv[]) {
int *a;
int b = 1;
a = &b;
printf("a: %d\n", *a);
return EXIT_SUCCESS;
}

Answer 1

The gist of it:
The data type of "1" is char*. So you are assigning a char* to a char* variable.
The data type of 1 is int. So you are assigning an int to an int* variable which won't work since the types don't match.

Answer 2

The second example won't compile because you have -Werror on, and you're attempting to assign an integer to a pointer without a cast, which is normally just a warning. The same would happen if you did char* a; a='a'; because you'd be attempting to assigning a char to char*.
In terms of different semantics between pointer types - what is stored in the memory as the pointer, it's likely not going to be different, but the pointer type will affect compilation. Mainly when it comes to pointer arithmetic, array indexing, and using pointers to aggregate (struct) types and functions.
Things start acting differently when you start using pointer arithmetic/array indexing. For example:
int value = 4
char *charp = &value;
int* intp = &value;
These will both be valid pointers. You'll also see different behaviors during compilation if you're working with function pointers, which you can use function call syntax with, and struct pointers, where you can access members of the referenced structure with the -> operator.

Answer 3

You're dealing with a difference between array, pointer, and scalar semantics.
Except when it is the operand of the sizeof or unary & operators, or is a string literal used to initialize a character array in a declaration, an expression of type "N-element array of T" will be converted ("decay") to an expression of type "pointer to T", and the value of the expression will be the address of the first element of the array.
The string literal "1" is an array expression of type char [2]. In this context, it "decays" to an expression of type char *, and the value of the expression is the address of the first character of the string. So you're assigning like to like:
a = "l"; // char * = char *
This doesn't happen with the integer variant. The literal 1 has type int, but you're trying to assign that int value to an int * object:
a = 1; // int * = int
which should trigger a diagnostic. You can only assign an int * value to an int * object - you would need to explicitly cast the 1:
a = (int *) 1;
which will suppress the diagnostic, but 1 is very likely not a valid memory address on your platform, and attempting to use it will cause problems.