why pointer variable with asterisk and without asterisk behave differently in printf?

Question

I m new to programming, there is some part that made me confuse when learning pointer.

code1:

int main()
{
    char string[]="hello";

    char *my_pointer=string;

    printf("first character is %c", *my_pointer);
    return 0;
}

output : first character is h

code 2:

int main()
{    
    char array_of_words[]="one\0two\0three";

    char *my_pointer=array_of_words;

    printf("%s \n",my_pointer);

    return 0;
}

output : one

questions:

I'm confuse here, the printf function part in the first code using asterisk symbol means to point what is inside pointer (my_pointer) which is the address of variable string that refer to the pointer string for an array that point the memory address of the first word in array "hello". is my understanding true?

and also when I change %c in printf("first character is %c", *my_pointer); to %s, the program crash. i want to know why i cant use %s and what is the different if i dont use asterisk in my_pointer in printf("first character is %c", my_pointer);

While in second code my_pointer variable didnt use asterisk(*) in {printf("%s \n",my_pointer);}. in this code is my_pointer refer to the address of array_of_words variable or what is inside of my_pointer? and also why the output is 'one' not 'o'?

Answer 1

C strings, arrays, and pointers can be very confusing. Let's look at what each of them is.

A pointer refers to an address in memory. You seem somewhat familiar with them. Think of it like a locker key - it tells you a place in memory where you can store data.

When you declare an array, the compiler sets off a region of memory to store it. The variable that you called the array can be treated as a pointer to the start of that data. For example, *string is the first element of the string.

Now let's apply that to your programs.

Both your programs create a string and set my_pointer to the memory address that the string starts at. my_pointer=string means "Copy the contents of the variable string (which decays to the address of the start of the string) into my_pointer."

In program 1, read *my_pointer as "The contents of the memory address that my_pointer points to." Since my_pointer points at the first element of the string, that is the character h.

Why then does it crash when you substitute %s? Because printf needs a pointer to the string so it can go through the whole array. Since C is copy-by-value, giving it the value of first element is pointless since it can't get at any of the others. As a result, printf tries to read a character as a memory address, which fails. A good compiler might see that and give you a warning.

Now program 2. my_pointer refers to the address of the string in memory, not the address of the variable array_of_words.The output is one because printf prints everything up to the first null character (\0). Since the first null is right after one, it prints one and then hits the null and stops.

Answer 2

When you declare char string[]="Hello" you declare an array of characters.

string points to the first element of the array. * is known as the dereferencing operator.

Suppose ptr is an integer pointer. *ptr will give you the content of the memory location pointed by the pointer ptr. At the time of declaration you have to declare it as int *ptr so that the compiler knows that ptr is a pointer variable(hence the asterix there).

---

when you execute printf("first character is %c", *my_pointer); the function expects a character corresponding to %c. The declaration char *string and char string[] are roughly(not completely) equivalent. my_pointer is a character type pointer. *my_pointer dereferences my_pointer. In other words *my_pointer gives you the content of my_pointerie the first character in your string.

---

However a %s expects a string (a character array, which is basically a char pointer) as the corresponding argument in printf. *my_pointer is a character. my_pointer can be treated as a string. Also print will treat the argument as a string and print the who;e thing till \0.

---

my_pointer=array_of_words "assigns" the value of array_of_words to my_pointer.

array_of_words[] is an array, so the value of array_of_words is basically the memory address of the first element of the array(notice the absence of []). In effect my_pointer now points to the first element of the array.

Hope this explains it.

Answer 3

Lets assume string variable is located at memory address of 100. In C, a NUL character(\0) is automatically appended.

string 
|-------|
|hello\0|
|-------|
100

char *my_pointer = string;

Can be broken down to 2 statements:

 char *my_pointer;
 my_pointer = string;

Since my_pointer is a pointer to char, the value of my_pointer is an address which points to char.

 my_pointer
 |------|
 |100   |
 |------|

*my_pointer is an operation like addition or substraction. It means to go to that memory address and fetch the value. There is a fancy name for this: DEREFERENCING.

*my_pointer retrieves the first character at memory address of 100 which is h. Now why just h? Not the rest? That's because the printf() asked for a character with %c format specifier. If you want the whole string, you can do it with

  printf("%s\n", my_pointer );  

Note that, there is no dereference character. In this case, my_pointer becomes the memory address which is 100. Since there is %s format specifier, it will read from memory address 100 till a NUL byte character which is '\0'. This marks the end of the string.

Moving to 2nd example, array_of_words has 3 strings. The definition of a string is when characters ends with \0 (NUL character).

Lets say array_of_words is stored in memory address of 200.

 array_of_words
 |-----------------|
 |one\0two\0three\0|
 |-----------------|
 200



char *my_pointer=array_of_words;

 my_pointer
 |------|
 |200   |
 |------|

printf("%s \n",my_pointer);

returns characters starting from memory address of 200 till '\0' character.

This is why, one shows up only.

Hope I explained it correctly and hope it helps you to understand a little better.

Pointer is a very challenging subject. There are books written on just this topic.

Answer 4

the printf function part in the first code using asterisk symbol means to point what is inside pointer (my_pointer) which is the address of variable string that refer to the pointer string for an array that point the memory address of the first word in array "hello". is my understanding true?

Ans: the *my_pointer in printf means the value represented by the memory address currently the pointer my_pointer is pointing at. i.e. 'h'. Pointer knows no array; it only knows a single memory address.

You see, the * during declaration and definition mean two different things. The former means the type of variable is a pointer to a char type value, and the later means the ValueOf operator(*)

---

when I change %c in printf("first character is %c", *my_pointer); to %s, the program crash. i want to know why i cant use %s

Ans: This happened because when printf sees a %s placeholder, it expects the supplied object to be a pointer so that it can iterate from the first char to the null value(\0). But in your case it found a char which is also considered as 8-bit integer, so the renderer starts loading chars starting from memory address 104 to till it finds \0. So when it is out of memory allocated, it crashes.

what is the different if i dont use asterisk in my_pointer in printf("first character is %c", my_pointer);

Ans: As I already said; char is also a 8-bit unsigned integer, so compiler thinks that you have supplied a char(because my_pointer returns the memory address which is integer if you remember) and tries to render it; but unfortunately there is no such printable char so you see a blank.

---

While in second code my_pointer variable didnt use asterisk(*) in {printf("%s \n",my_pointer);}. in this code is my_pointer refer to the address of array_of_words variable or what is inside of my_pointer?

Ans: my words earlier should answer this question

why the output is 'one' not 'o'?

Ans: you have \0s in the string and printf searches for \0 to know that the string has ended. So first time it finds null value; it terminates the rendering.