指向int和char的指针（数组）

Question

I don't understand how pointers to chars differ from pointers to ints for example:

int a = 10;
int *b = &a;
printf("%d\n", *b); // print 10
char* d = "Hello";
printf("%d\n", (int) *d); // print 72, ASCII of H

Here what is "Hello"? Is every character an address to an int and thus "Hello" an array of addresses?

Answer 1

C is not strictly type-safe, especially the printf function which accepts anything as input (the ... syntax), how it's interpreted is handled by the format string: %d says "treat the Nth argument as a decimal integer".

A char* is a different type to int* . Another way they differ is how they behave when you increment a char* compared to an int* :

char* c1 = "foo";
char* c2 = c1 + 1;
// c2 is c1 + 1, as sizeof(char) == 1

int* i1 = &123;
int* i2 = i1 + 1;
// i2 is i1 + 4 as sizeof(int) == 4, assuming your system uses 4-byte integers

Answer 2

Well if you consider they are all holding addresses ...then

What is the difference?

Difference is suppose I have 10 bytes of memory

---+---+---+---+---+---+---+---+---+---+
|  |   |   |   |   |   |   |   |   |   |  
---+---+---+---+---+---+---+---+---+---+
1    2   3   4   5   6   7   8   9    10

Now suppose a char is of size 1 bye and int of 4 byte.

Now if someone asks you to give the integer starting from address 1 what you will do?

You know that size of int is 4 bytes so you get it and show it.

Similar for char you just get 1 locations value and show it.

Now a pointer similarly needs to know how much it should consider when it is asked to ( dereferenced)...

That's where int* and char* differ. Otherwise both of them hold addresse. And using a char* you can get all byes of an integer but that is overhead on part of user.

Formally....

The pointer to type basically tells the pointer how much it should move in memory from it's current location and how much is bytes staring from it's pointing address needs to be considered when dereferrenced.

Doubt-1 why don't we need &"Hello"?

char *d= "Hello" will place "Hello" in the read-only parts of the memory, and making da pointer to that makes any writing operation on this memory illegal.

ALSO IN C "hello" has type char[]. And an array can be converted to address of the first element automatically

Answer 3

Firstly, your usage of char* is a bad idea since, whilst the string literal is a 'char[6]', you can't legally modify it, so you would do well to use a const char* instead.

That aside, d will hold the memory address that points to the character H. On most platforms, a char is 1 byte long - thus, d++ will likely increment the memory address by 1 byte.

On the other hand, let's say that an int is 4 bytes. if d was an int* then d++ would increment the memory address by 4.