Comments by Member 16116753 (Top 50 by date)

I would like to ask because there are two different spelling with &(str[0]) and (&str[1]) dunno if it makes difference.

Second thing is why it would give segfault ? I didn't understand to be honest. str[1] from this point to str[4] it is 4 bytes.

Hmmm I also putted this code into compiler and it worked it printed both of them.
But maybe it shouldn't work ??? But it worked somehow.

What do I mean is that if the int was 8 bytes long then this 5 byte string isn't enough although it worked because of 0x0, I also wondered why.

I did another experiment :

#include <stdio.h>

int main()
{
    char str[5] = { 0x01, 0x00, 0x00, 0x00, 0x00 };  /* a 5 byte string, all zeros */
    int *i = (int *)&(str[0]);
    printf("*i = %d\n", *i);  
    i = (int*)(&str[1]);
    printf("*i = %d\n", *i);
    i = (int*)(&str[2]);
    printf("*i = %d\n", *i);
    i = (int*)(&str[3]);
    printf("*i = %d\n", *i);
}

And I had these results :

*i = 1
*i = 0
*i = 0
*i = -150994944

So it somehow worked for str[2] but it didn't works for str[3] because it took some random data in a non existing str[5] and str[6] I guess. It worked for str[2] even though there is non existing str[5] but repeating it always gave me 0, so maybe this spot always has 0, and in str[6] place there is random data so the 1 byte that is reserved for something random.

Interesting. Although I didn't understood the segfault

The "x" is type of int

int *x;
char *y;

x = (char *)y;

typic x + 1, the arithmetics is that it adds 4 bytes (for 32 bit) and not 1 byte. Because "x" is int and not char i just changed y to be a char.

But with an example with int *x and char *y. When I type x = (char*)y or x = (int*)y or x = (float *)y it doesn't change anything to be honest, because if I write x + 1 it will always shift by 4 bytes/8 bytes (depends on the system), no matter if it's x = (char*) y it will still shift by 4 bytes when x + 1, etc.

I don't really know how it works. I think that in this case no matter what "x" will see what type is there it won't change the arithmetics. The "x" is int type so the arithmetics are for intiger, so even if x = (char*) y, and I type x + 1 then the arithmetic will still shift by 4 bytes and not by 1 because it is by the type of pointer and not the pointer stuff so char doesn't matter to the arithmetics I think so ?

I am mostly new to C, so I don't really much know what I am doing so reading your code doesn't tell me a lot nor it tells me what happens in there ;D *&f like what ? and *(unsigned int *) &f. * is for getting value and & is to get the address so both at the same time hmmm ...

It doesn't quite answer my question.

I gave an example with int *x and char *y. When I type x = (char*)y or x = (int*)y or x = (float *)y it doesn't change anything to be honest, because if I write x + 1 it will always shift by 4 bytes/8 bytes (depends on the system), no matter if it's x = (char*) y it will still shift by 4 bytes when x + 1, etc.

Why adding cast types matters though in this situation.

Second thing, as I understood if I write *((char*)ptr + 2) then the arithmetics changes and instead of 2*sizeof(int) changes into 2*sizeof(char) ??

I've understood the solution below so please stop sticking pins in my questions. If me trying is a problem then why I can't ask ? It's like that if I want to try understand something I see that it is a problem and points out my inability. Thank you ...

Well giving a bigger value like 300 also worked, but okey. Same goes with my malloc that had void but was pointed by int and gave a good answear everytime. So I just don't understand why it is wrong.

But I still didn't get an answer to one question. When can I change the type and when not. You've used this type change but in my case it wasn't correct. But that's also my last thing to write after this it will be closed.

Have a nice day and thank you for help :>

Well I do have a problem understanding it just by looking at some examples.
Like this one in which the pointer is int but I could read from it a char.

#include <stdio.h>

int main()
{
    int *x;
    int y = 35;
    
    x = &y;
    
    printf("%c\n", *x);

    return 0;
}

Or changing the int pointer to a char pointer and point it to integer, it also works :

#include <stdio.h>

int main()
{
    char *x;
    int y = 35;
    
    x = &y;
    
    printf("%c\n", *x);

    return 0;
}

Or for malloc()

When I type int *x = malloc()
It doesn't matter what type of malloc is whether it is char*, float* arithmetics worked the same which was x + 1 or x + i which is the size of the x type which will be size of int and it is 4 bytes.

#include <stdio.h>
#include <stdlib.h>

int main()
{
int *x = (char*)malloc(5);
x[0] = 33;
x[1] = 34;

printf("%c\n", *x);
printf("%c\n", *(x+1));

return 0;
}

It gave a proper output.
So I was wondering where this type next to pointer is necessary.

I don't really much know how to address my problem with understanding ;D in your example I see the changes wouldn't affect, but in some pointers changing the type will be problematic.

And the example that will give a bad result :

#include <stdio.h>
#include <stdlib.h>

int main()
{
int *x;
int y = 5;
x = &y;

printf("%f\n", *(float*)x);

return 0;
}

Which I partly understand.
Also in your example I don't know what happens if I don't change the type because it points to malloc so maybe nothing ? That's only a speculation, and it came up because malloc doesn't know what it has inside it only give an addres to a space in memory. So passing the addres from malloc to vp and from vp to another pointer then the type shouldn't matter only the type for pointer that takes the addres I guess matters ? Perhaps I am strongly wrong, but that's what I so far deduced reading, testing and watching.

By the way type isn't necessary in malloc as I remember so when "v" points to the malloc then it's type doesn't matter I guess ?

I've tested the void pointer to the malloc without changing the type and putted in char data and it worked.
I think I know what did you mean that it is a good thing to change the type.

Although I want to ask, when can I change the type and when not of a pointer ?
In your example it was more of a changing the type for a pointer to the memory, but if I used "normal pointers" I belive It is not a good idea ?

I've tested it like that :

#include <stdio.h>

int main()
{
int *x;
int y = 16;

x = &y;

printf("%f\n", *(float*)x);

return 0;
}

Result ? It was 0.0000 :> Not really sure how it interprets but welp that's what you said of not changing the type of a pointer (but you've changed it) so I tried to check how it works and figure out why it works like that.

Even in your examples the pointer changed the type ;>
So I thought this is very often used, so maybe the data is changed but I assume that my example with int* x changing into float *x will affect with random number because it read the 8 bytes while he stored at the beggining 4 bytes.

Well that's still some wondering but wanted to see how it works and I saw many examples that changed the type like in yours changes the vp from void to other data. But maybe it is possible because it points to space and not into specific data.
Like changing the int* into char* or putting string value into int like "OK", I guess it will store like you said that 1st byte will be O and goes on and numbers are always stored like I said before no matter what type it shows ??? for Float I don't know yet.

Well so many to test.

You are totally right!
I should just keep things clear this is why I just tested some of the stuff what is the result.

Okey so strings are stored differently. That's good to know So the first byte is O and not \0 Nice.

I also wanted to know how it works because I see pretty often that the pointer is changed from int to char or to float etc. So I wanted to know if it's okey to do it.

Because if I had an integer pointer like int *x, that is pointing to 4 byte integer, and now it is changed to (float *)x, and type *x it should then appear a random number because now it has to read 8 bytes, which first 4 are the int value and the rest are random I guess. Although I don't know how float numbers are alocated.

Well changing types is also a thing to know. Or perhaps it will work correctly but I don't know yet.

Thank you.

as I thought !!! It read also the random 4 bytes :>
Also I think that "d\0\0\0" should be enough because it is 4 byte as a whole so enough to show the number 100 I guess. I checked it on, and it worked even for "d\0", so I don't know what is the logic how the compilator reads it ;>

Also I've learned how the bytes are putted into memory like number 100 is alloceted this way :

01100100
00000000
00000000
00000000

So the first byte is indeed 100 in integer and the first byte is also a 'd' char. So the same goes with my number 33 which is an int number and a letter.

Or another integer if I had a number 300 then :

00101100 - first byte of 300
00000001 - 2nd byte of 300
00000000
00000000

So the first byte it points to is 00101100 so it is reduced from 300 to 44 so it is now in char "," symbol.

Same goes with string words, that \0 is placed in the first byte so if I read a character from that string it should print \0 (or maybe nothing I don't know how it prints this). Let's say word "OK"

00000000 - \0
1001111 - K
1001011 - O

So if I read the first character from it, it should pop out the \0 ? Because it read from the pointer to this place.

Edit :
My theory it should print the \0 didn't work. Instead it printed O as a first character hmmm
There are like 3 chars 1001011 1001111 00000000, and they are placed from top is 00000000 and the last one is 1001011 so it should read 00000000 first hmmmmm. What is my logical error here because I showed the example with 100 and 300 int numbers and how char is picking the first byte so why the first byte is not \0 hmmmm

So the first byte the char is pointing is \0 like tih

In arrays I guess it works differently that the first Character should be O but I think it works differently than pointers.

Uhhhh very interesting. And then I write z = y which z is and normal int and y is a char. Then it converts "d" into 100 and fills the rest with 0. I don't know why but understanding it made me happy ;>

Tell me also if I am right :>

But I also wonder if I have int *x, and write *x it will always return and int number ? I thought for a moment that this int next to a pointer doesn't decide what *x will show because of this printf thing.

Hmmm I still don't quite get it because vp is a variable and it is treated as pointer to the function but I will for now listen your suggestion ;>

So yea now I am working on with the think I showed in the comment. Using the book as well but it didn't answear my question so I am experimenting. But the PS.2 info I added just now destroyed my theory ;> maybe the 33 number is only written in 1 byte at the beggining the the rest are ignored maybe hmmm 33 in bytes hmm

Very thank you very much. PS.The code didn't work and the last two code "(void(*)(int))vp" are completelly not understandable for me ;D
I've read a bit of that book you've mentioned and some of the stuff has been resolved for me.

I am now experimenting this code and understand how it works :

#include <stdio.h>

int main()
{
    int *x;
    char y = 'd';
    
    x = &y;
    
    printf("%d\n", *x);
    printf("%c\n", *x);
    
    int z, g;
    z = y;
    g = *x;
    
    printf("%d\n", z);
    printf("%c\n", z);
    printf("%d\n", g);
    printf("%c\n", g);

    return 0;
}

Which gives me result of *x being a random decimal number and z being a normal decimal number.
So far I've deduced that %d from *x gives me the 4 byte value from where it points. So whenever I use *x like you did in "if" statement then I will get a decimal number? Like the variable "g" will get a integer from *x. It was just interesting because the z gave me an integer equal to 100, so I thought that it transfered the letter into an integer. And with pointer it did not transfer the letter into an integer. Which is very interesting because why then the pointer doesn't transfer the letter into an int.

PS.2

Although my teory is broken because :

#include <stdio.h>

int main()
{
int *x;
int l = 33;
x = &l;

printf("%d\n", *x);
printf("%c\n", *x);

return 0;
}

It actually shows an letter. So my theory that or reads only the 1st byte is not working ... Hmmmmm I wonder how it works.

Still very very thank you. And sorry for the trouble, because now I feel bad for what I did ;>

Okey, I read it and read something from book.
Tell me only if I am right when it comes to this topic and that's all :

- if I had int *ptr then &ptr is the address of that pointer, ptr is a pointer to the integer (it's address inside), *ptr is the value the address was pointing to. So (int *)malloc() is the same as : "ptr is a pointer to the integer (it's address inside)"

- The int *p = (int *)malloc() is the same as :

int *p;
int *x;
p = x;

- The type of malloc doesn't really matter in int *p = (int *)malloc() when it comes to arithmetics because if malloc was : (char*)malloc() then typing p + 1 will still shift by 4 bytes becase the pointer is int. But when I want to write a number like 256 into (char*)malloc() it will only save the number 2 in first byte and the rest I think are ingored ? Typing again printf("%d", p) will in result give 2 ? I guess

Is it possible to resolve this question ? I know this is chaotic, but I feel if I won't know this I will not understand something during the learning.

This book contains these type of dilemma like my questions ? And what if doesn't ? Should I ask here or will it be treated like random question ?

I've got the book k5054 provided so I'll start with it, but I wanted to finish at least this topic (because I feel a bit stressed not understanding it and it can block my understanding of other stuff sorry ;<) and I will give a break. Although I think I will have again a problem same goes with random questions they are related so why is it random ;> ?

also : "It means that the pointer it returns can't be used on either side of an assignment operator unless you cat it to an valid type: void is a "zero length value", or a "null value" if you prefer." means what ? Which part ?
I've given an example, and I wanted to see if my comparison is somewhat correct. But yes while giving a question I just came up with that int * p = (int *)malloc() is similar to int *x = y in which y is int *y. So why even saying that y is a pointer same with malloc why I had to use this (int *) if not normal (int) because saying p + 1 will shift by 4 bytes because of size of(int) from int *p or with the example int *x = y, typing x + 1 will shift always by 4 bytes no matter if y is char *y or float *y it will always shift by 4 bytes. That's weird and doesn't have sense ...

And I think this will block my understanding while reading books it at least blocked my understanding while reading "Understanding and Using C Pointers". I know to read a book and I will do it I just want to finish this topic atleast.

Yes OriginalGriff you are right that this is an old language that's why the pointers are very puzzeling, and that's why I ask stuff like these because (int *) function and int (* function) looked the same.
So I was like okey let's rewind my knowladge. If I have int *ptr then I have a pointer to an integer. Typing ptr will give me the address this pointer points to and typing &ptr I get the address of that ptr.
So if I have (int *) malloc() and malloc returns address to the memory then (int *) malloc() return something like ptr, Why I assumed something like that is because malloc gives the address where it points to like ptr. And if I say &malloc() then it should give me the address of the pointer itself like &ptr. Hence the *ptr gives the content like *(int*) malloc() ?

The thing was with (int *) with a function.

I also remembered something like this example :

int ptr*;
ptr = &x

And there was something like (char *)ptr which changed a bit where the pointer points to and arithmetics changes from sizeof(int) to sizeof(char) when I type ptr+i. So yea I compare many things which I again apologize for taking your time, because I thought this is not as random.

Or I came up with another thing if (int *)malloc() is similar if not the same as ptr (when int *ptr). Then :

int * ptr;
ptr = (int*)malloc();

Feels the same as

int *p;
int *x;
p = x;

Which feel weird Because what will change if I say (char *)x when ptr will shift by 4 bytes anyway. Ehhhhhhh sorry

int *p;
char *x;
p = x

and shifter by 1 p + 1 it shift by 4 byte no matter what the x is if it's char or int.
If i had the second example it would have also any matter because the pointer is 8 byte big so shifting it will be correct anytime p = &x; and typing p + 1 will shift by 8 bytes

And so this also means that the malloc has the addres of that pointer so it indicates that &malloc is there because malloc is a pointer.

Maybe different question. What does it mean it returns a void pointer. If I had int *ptr then I guess ptr is a integer pointer and *ptr is the value I guess.

It is still very weird because because it's like a pointer points to the content of another pointer like this :

int *p;
int *x;
p = x;

Usually I see double pointers like these :

int **p;
int *x;
p = &x;

So I thought the first one is incorrect or rather why then use this int *x when this int will have no meaning because the shift from first example is defined by int *p not int *x. Or in other way because my english might be very bad. From first example if I had

int *p;
char *x;
p = x

and shifter by 1 p + 1 it shift by 4 byte no matter what the x is if it's char or int.
If i had the second example it would have also any matter because the pointer is 8 byte big so shifting it will be correct anytime p = &x; and typing p + 1 will shift by 8 bytes

And so this also means that the malloc has the addres of that pointer so it indicates that &malloc is there because malloc is a pointer.

ehhhh

Hmm I will give it a try, so far I was following "Understanding and Using C Pointers".
But I usually have a problem with pointers that I compare new stuff with old stuff like I showed with malloc because they look similar if not the same but one has (int *) function and the other is int (*function). I have a feeling with new book I will have the same because I very often compare new stuff because mallox acts like &x and the content of malloc is like int x, which is weird because malloc has next to it (int *)

Sorry if my questions seems random.
I in school encounter with these type of situations so when I encounter something new I try to find something similar on the website because I don't know how to call this new thing.

Like I showed with void (*fun_ptr)(int) = fun; it look very similar to (int *) malloc() both of them are functions and both of them have pointer * but differently written ? I don't know is there a difference if I write (int *) and int (*) ????

I also sometimes comeup with the answear to the question after sometime reading the forum.
And you are perfectly right I don't really much grasp sometimes simple thing which I am sorry for ... I just find in a code something I don't understand and try to find that information. And finding an info usually give me new questions so I didn't know it is random.

void * - a pointer to a void. What does it mean what can I compare it to ? And what I can compare malloc to from simple examples ?
Function pointers you've told, I don't quite get it. They have pointer but this pointer is different from other pointers so &fun in which fun is a function is invalid ?

Again sorry for annoying you everyone I just try to compare new stuff with old stuff because these addresses and pointers are mixing up. Like malloc it has a (int *) which indicates that it is a pointer like int * ptr. But it returns an address which is not a pointer ;>

I'm sometimes basing my questions from the books.
I also watch tutorials that starts from the beggining and step by step shows new stuff that also is connected to the last lessons. So I was stuck with pointers and how do they work. Maybe questions are pointless but then what quesitons should I ask ? I am stuck with the tutorials or information from books on website

I just found out I was a bit stupid as well. And that Assigning *type**)ptr to &arr will give an error because it is an 3*8 bytes or something it should be (type**)ptr = arr.

Because it works the same with normal array like value[5]. If I write value + i I get the value of the addres, if I write *(value + i) I get the value from that addres, and if I write &value+i it is the whole array just like with the char *arr[3] and it's &arr+i.

The difference between them is that in char *arr[] I can get two addresses, one is the pointer address in arr+i and the addres of the value which is *(arr+i), in normal aaray like int value[] if I type value+i i get the addres value and that's all. In *(value+i) I get the value only and not the address.

I don't know if I am quite correct. But that's all ;>

May I ask one last question because I think I got the idea how it works.
Why then I want to print &arr + i it will increase by the size of 3 pointers and not a single pointer ?
In double pointers like **pp and *p when I increased pp + 1 which is the same as &p + 1 then it increased by 8 bytes of a pointer *p, but what if I increased &pp ?

So what is special in array that I can't increase by a single pointer of the array ?
Or is it also something I got it wrongly.

Because if I had a normal array like val[2] then typing val+1 will shift it by 4 bytes. What is the arithmetic behind that &arr is 3bytes*sizeof(char**) ? And the other one that usually is 8 bytes or 4 bytes. Because I believed that &arr + 1 is an address of arr + 1 and &arr + 0 is an address of arr + 0. So what is the address of arr + 1 ?

Image in my head :

Address of an element The array elements from arr[0] ... arr [3] Points to value

[ ] -----> [ it contains pointer ] ---> [value]

So arr[0] has it's own address &arr[0] ? Like here : https://i.postimg.cc/k5Zv8mpk/obraz-2023-10-18-210634239.png[^]

Every element of arrays has it's own address. But incrementing it + 1 it will go not by 8 bytes but more

EDIT :

or what happens if I assign **ptr = &arr ? if I type ptr + 1 then it should shift by 3*8 bytes which is the size of array ? How does he know he must just 3 and not 1 arr ??? this is problematic for me now Because now the pointer is 24 byte size ???

With matrix bellow the **pp example that I tried to compare to

I just found out that (int *) doesn't have pointer inside so my example you've commented is incorrect because then **matrix gives the value it stores and not the addres of the value.

So that's why it is mixing up.

I am still puzzled with sizeof because I don't understand still how it interpreted.

Also I understand that my example is similar to malloc ? I mean ptr = val[] similar to ptr = (int*)malloc ? it's like the &val is int ? and the addres of malloc is also int ? Although it was declared as (int *) ??? Weird.

About new post I was thinking about it but it would sound the same ... So I don't know how to ask this question and sorry for the problem the pointers are just hard.

Shouldn't it be i*sizeof(int) ? Because if malloc doesn't have a pointer inside even though it has (int *) next to it then to move from lets say 600 in matrix[0] to matrix[0][1] it must be 4 bytes ?

I maybe get it I don't know ?

Maybe because malloc is a bit different from other.
Because array[] doesn't have pointers inside but *array[] has pointers inside then *malloc() doesn't have pointers inside but **malloc() has pointers inside.

What I imagine of malloc right now with similar example is :

int *ptr;
int val[5];
ptr = val; or ptr = &val[0];

So now *ptr = val[0] give a value, but a twist here with int val[] each &val is 4 byte so difference between &val[0] and &val[1] is 4 bytes as I remember.

So typing ptr + 1 will move only 4 bytes ?

And with malloc

int* ptr = (int *)malloc(3*sizeof(int));

So now ptr + 1 will give the address and *(ptr+1) will give the value this (int *) is very sketchy so I thought that inside of *(ptr +1) will be a pointer.

So we get the same result and because ptr+1 will shift only by 4 bytes as I understand because sizeof(int) ??? I don't quite know because ptr + 1 indicates at (int *)malloc which has this "*" but it is only logical thing I can come up with I guess when malloc doesn't have inside any pointers. I don't get it why it is still from (int *) changes into int inside of sizeof. Because ptr points at (int *) hmmmm and in the first example ptr points at address val which is int ??? I don't get it.

Then I am even more confused them. I know I've asked a lot but it basically is about bytes how do I know how many space to "make" that if I type + i it will get to the right address or to correctly create malloc.
So I wondered why for matrix[0] I've allocated a malloc that has 4 byte for every digit and not 8 bytes like is int * when I type + i it will give sizeof(int) and when I have int ** and type + i to it then it shifts sizeof(int*) so weird.

I'm slowly getting it but this mess in my head made by sizeof and how it shifts when I type +i was the dominant part of it.

So my simple example *pp, *p and a doesn't apply hmmm.I thought it is similar because there was a double pointer which was **matrix very similar to **pp so I got confused and couldn't find the difference between them or how to look at it using random address value to show it but I couldn't figure anything.

Sorry for bugging you with repeating my questions ... Pointers are really hard for me but I need to master it once and for all ;>

Okey so what happens with my matrix then ?
In this picture from a website https://www.javatpoint.com/c-pointer-to-pointer It shows that **pp and *p and "a" are used in the example so typing printf("%p",pp) will give me the address of p, typing printf("%p",*pp), the address of "a" and typing printf("%p",**pp), the value of "a".

But how it works in my matrix : https://postimg.cc/8J7fqswQ

when I type printf("%p",matrix) I will get the address 500, when I type printf("%p",*matrix) I get the address of 600 so when I type printf("%p",**matrix) i get the address of a variable I write there not the value so I should write printf("%p",***matrix) ??? Because **malloc is a double pointer and *malloc is a single pointer.

*matrix gets the addres of 600 which is the address of *malloc it is a pointer. So what it contains I have to use **matrix and the value of that address must be ***matrix ???

Weird not gonna lie. Also *malloc is 4 byte not 8 byte even though it is a pointer ... Or am I again mixing stuff because I compared this double pointer to simpler version which is this :

#include<stdio.h>  
void main ()  
{  
    int a = 10;  
    int *p;  
    int **pp;   
    p = &a; // pointer p is pointing to the address of a  
    pp = &p; // pointer pp is a double pointer pointing to the address of pointer p  
    printf("address of a: %x\n",p); // Address of a will be printed   
    printf("address of p: %x\n",pp); // Address of p will be printed  
    printf("value stored at p: %d\n",*p); // value stoted at the address contained by p i.e. 10 will be printed  
    printf("value stored at pp: %d\n",**pp); // value stored at the address contained by the pointer stoyred at pp  
}  

So when pp showed the addres of p then in my example matrix shows the addres of (int **) malloc which is 500, then again *pp shows the addres of a variable in my case *matrix shows the address of (int *) malloc which is 600, and it is not the addres of a value, and lastelly **pp is the value of a, in my example **matrix shows the addres of value stored in 600 ...

Do you maybe know why I am so confused with this ? It's hard to explain but now (int *) malloc has 4 bytes just because why not but it is a pointer to the addres let's say x = 5 so the address of x = 5 lets say 1001 is stored in 600 which is this thing I guess ????

EDIT :

Here is what I found : https://www.javatpoint.com/c-pointer-to-pointer which shows that **pp and *p and a. typing pp will give me the address of p, typing *pp will give me the addres of a and **pp will give me the value.

Now in my matrix. Typing matrix will give me the address 500, typing *matrix I will get address 600 so typind **matrix I will get the addres of a value ? That doesn't make sense.

Completelly different from the example. correct my steps if I am wrong.

So matrix[0] shows the value 600 and typind printf("%p", matrix[0]) or printf("%p", *(matrix+0) will show the address 600 or will it be value at address 600 ? I got also confused watching this link https://www.geeksforgeeks.org/c-pointers/ Because let's say we have int * ptr = &var so ( address of ptr is let's say 1002, address of var is 2000 and value of var is 4) when I write printf("%p", ptr) it will show it's own address which is 1002 or 2000 ?

Second thing, I still don't get it why 4 bytes for the pointer. Because *matrix is now a single pointer ? So is the example above with ptr it also has 4 bytes ? How the computer or me have to know how much space I need to make for these pointers ? Is there a rule ? Because there is malloc with sizeof(int) which is 4 byte and is single pointer and another malloc with sizeof(int *) which has 8 bytes and is a double pointer ??

Is it possible for explaining comparing simple examples with bigger ones like I've shown ?

Sorry sorry and again sorry for taking your time I feel very nervous because I take so much of your time ;<

I've got a better question :

Take again look at this picture.
obraz 2023 10 18 050416732 — Postimages[^]

How do I get the address 100, the address 500 and the address 600.
I know that **(matrix) is the value pointed by 600, so the address of that value is in *(matrix), and the value 600 (address of a pointer) is in matrix, pointed by 500, so the value of 500 (the address of another pointer) is stored in &matrix pointed by 100. So the value of 100 is in &&matrix ?

I am basically confused because char* array is a pointer so I thought that the address of the array is also 8 byte big.

Same goes with matrix. I don't know what is matrix+i, *(matrix + i), &matrix + i. And why when I type *(matrix+0) and *(matrix+1) it is 4 byte difference although it is a pointer I guess. If its a pointer it should always be 8 byte because pointers have 8 bytes. The value is in **(matrix+0) this is the value. And what if I type &(matrix+0) ?

sizeof(arr) I was told it is the same as the size of a type it is assigned to.
What I imagined is let's say I have normal array -> value[2], so the &value[0] is basically the address of that array, and the value[0] is what is has inside. So when I say int *value[2] then I add another pointer but inside of value[0] so now I have two pointers one from the address to the pointer &value[0] -points-> value[0] and this pointer which should be 8 byte big points to the value value[0] -> *value[0]. But I get lost what is what. So when I write value + 1 <==> &value[1], I shift it by 8 bytes ? But when I write value[0][1] then I shift one by 0*8 bytes and another shift is 1*4 bytes ? I wonder why 4 bytes in the second one though ... Like I said it is very confusing for me.

Yes indeed I am confused. So in other words what am I printing typing *(arr + 1), arr+1 and &arr + 1 ?

Because the arithmetics works how ? arr is always as I know the same address so it always shifts by 8 bytes and shows it's content ?

Like here :

#include <stdio.h>

int main()
{
 
    char* arr[3] = { "geek", "Geeks", "Geeksfor" };
 
    for (int i = 0; i < 3; i++) {
        printf("Indeks : %d, Address of (arr) : %p\n",i , *(arr+i));
        printf("Indeks : %d, Address of (&arr) : %p\n",i , arr+i);
        printf("Indeks : %d, Address of (&arr) : %p\n",i , &arr+i);
    }
 
    return 0;
}

Results :

Indeks : 0, Address of (arr) : 0x5644e043b008
Indeks : 0, Address of (&arr) : 0x7ffd0a7a3e60
Indeks : 0, Address of (&arr) : 0x7ffd0a7a3e60
Indeks : 1, Address of (arr) : 0x5644e043b00d
Indeks : 1, Address of (&arr) : 0x7ffd0a7a3e68
Indeks : 1, Address of (&arr) : 0x7ffd0a7a3e78
Indeks : 2, Address of (arr) : 0x5644e043b013
Indeks : 2, Address of (&arr) : 0x7ffd0a7a3e70
Indeks : 2, Address of (&arr) : 0x7ffd0a7a3e90

Or in my matrix example. What am I showing typing matrix+1 and *(matrix+1) ?

In the image here : obraz 2023 10 18 050416732 — Postimages[^] it shows that *(matrix + 1) is the value inside of 600. So I understand that shifting matrix + 1 I will get 608 ? Because it is 8 byte or is it different shifting because it should be matrix[0][1] the second element in 1st row, But I don't know how to write it in *(matrix+i) notation to have 2 elements And how does it shift.

PS.
I still feel confused when I think about the matrix because *matrix is alocated in malloc that sizeof(int) is 4 and not 8 hmmmm I don't know what is what ...

I get usually mixed in what is the address of the pointer and what is the address of a value.

Isn't *arr a value we want to get right ? so arr is also a pointer to that value *arr. So why arr is random bytes like 5 or 6 etc like you said with "geek\0" that is 5 byte big and "Geeks\0" that is 6 byte big. So the difference between geek and Geeks is 5 byte and not 8 either though arr is a pointer and *arr is a value.

I'll give a better example maybe we have an char* arr[3] not let's make blocks &arr[0] is


char* arr[3]

Address of each element

&arr[0] = 0x7fff60e25ef0 -> [ arr[0] - pointer (it's address 0x55ae7f302008) ] -> [arr[0][0] value of a letter and it's address is passed to the pointer 0x55ae7f302223]

&arr[1] = 0x7fff60e25ef8 -> [ arr[1] - pointer (it's address 0x55ae7f30200D) ] -> [arr[0][1] value of a letter and it's address is passed to the pointer ???]

The problem was that the arr[0] shifted by 5 bytes but it is not a letter it is just a pointer.

Another example :

Normal array :

int value [2]

So :

&value[1] = 0x7fff60e25ef8 -> [ value[1] - value (it's address 0x55ae7f30200D) ]

It is only one pointer which is &value to the element in value[1] that's why I saw that value[1] is equal to *value+1. But it is still a pointer &value[1] so why it shifts only 4 bytes and not 8 ?

I don't know if what I wrote is understandable, because as I said I am so mixed I need some more images or examples from easy to harder because everything is now mixed ...

In the pictures like here : obraz 2023 10 18 050416732 — Postimages[^] it was hard to understand or from websites like : https://www.oreilly.com/library/view/understanding-and-using/9781449344535/ch04.html or https://www.geeksforgeeks.org/pointer-arithmetics-in-c-with-examples/ .

They say that the pointer is 8 byte big but in images it shows that it is shited by 4 bytes. But why now pointer is 4 byte and not 8 ??? It said that pointers are always 8 bytes or 4 bytes. But when I add char it changes into 1 byte so I don't get it.

"So here is the question to you: are you either run the code you are asking about to understand how it work?" Yes.

"0x55eff083e2d4 - 0x55eff083e2c0 = 0x08". I don't get this part. One byte difference is adding hexa 1 to the addres right ? Like 0x55eff083e2d4 + 1 byte is 0x55eff083e2d5 this is one byte difference as I assume so how substracting it you have 8 ? I've got 14 in hexa which is 20 in decimal so it's 20 bytes difference.

"The values you are provided as *(arr+1) are invalid - it is not possible to have such address of the pointer type 0x55ae7f302013". When I turned on again the compiler it showed some errors but showed some values.

I still don't get it how it works ...
So what is *(arr+i), (arr+i) or &arr+i ? Same goes with the second example. Because I get mixed how it works and how it operates.

I've changes a bit the code but it still couldn't work well :

#include <stdio.h>

int main()
{
 
    char* arr[3] = { "geek", "Geeks", "Geeksfor" };
 
    for (int i = 0; i < 3; i++) {
        printf("Indeks : %d, Address of (arr) : %p\n",i , arr+i);
        printf("Indeks : %d, Address of (&arr) : %p\n",i , &arr+i);
    }
 
    return 0;
}

Result :

main.cpp: In function ‘int main()’:
main.cpp:14:22: warning: ISO C++ forbids converting a string constant to ‘char*’ [-Wwrite-strings]
   14 |     char* arr[3] = { "geek", "Geeks", "Geeksfor" };
      |                      ^~~~~~
main.cpp:14:30: warning: ISO C++ forbids converting a string constant to ‘char*’ [-Wwrite-strings]
   14 |     char* arr[3] = { "geek", "Geeks", "Geeksfor" };
      |                              ^~~~~~~
main.cpp:14:39: warning: ISO C++ forbids converting a string constant to ‘char*’ [-Wwrite-strings]
   14 |     char* arr[3] = { "geek", "Geeks", "Geeksfor" };
      |                                       ^~~~~~~~~~
Indeks : 0, Address of (arr) : 0x7fffcac41510
Indeks : 0, Address of (&arr) : 0x7fffcac41510
Indeks : 1, Address of (arr) : 0x7fffcac41518
Indeks : 1, Address of (&arr) : 0x7fffcac41528
Indeks : 2, Address of (arr) : 0x7fffcac41520
Indeks : 2, Address of (&arr) : 0x7fffcac41540

I am so lost because now I see only bytes and I don't get it how it works ...

PS.

Like the picture here : obraz 2023 10 18 050416732 — Postimages[^]

It shows that matrix[0] or *matrix+0 have address 600 and it's next element is shifted by 4 bytes (604) how does he know ? This is a pointer it should shift by 8 bytes. And in my results it shows it is I guess 4 bytes ? I don't know what is what now to be honest I need some help here.

I don't quite get it so I asked in another question because I struggel understanding how these bytes works. In my next question I've shown from char *arr that the address of arr is one byte per character but &arr is 8 byte per I guess pointer ? Which doesn't make sense because normal array is also somekind of a pointer because the address of array is a pointer to it's content let's say value[2] = {1, 2}. So the address &value[0] is a pointer to it's content value[0]. In char *arr I have double pointer which are &arr and arr, but it's value *arr should be one byte ? but instead arr is one byte from every step like 1 string has 5 characters so arr+0 and arr+1 have 6 bytes difference but the pointer is 8 bytes ....

Oho okey, so the example with int *arr can also be two dimensional but I just need a bigger malloc like you've mentioned, and the example with char *arr writing Geek itself creates another array or something like that.

PS.
It was also confusing watching at malloc because it has (int *) which I thought indicated a pointer just like int *ptr. So when I type ptr = &a it contained the address and *ptr will give the value so I thought that in *malloc there is an address and with malloc = addres of value and *malloc will give the value. so I thought because malloc return the address so I thought this is the address of a pointer like &ptr it is also an address of an pointer. you know what I mean ?

Btw I have another question because we pass the %s addres of that first character which is arr[0] or arr[1] etc. then when I pass the address he itsel does "inside" arr[i][0] or arr[i][1] similar to showing the single character you've shown but it does automatically in %s and shows only the end result of arr[i][0] and not only a single character.

Also one more thing I know that *arr[0] will display 1 character, arr[0][0] will also display the same character as *arr[0] and **(arr+i) will also display 1 and the same character as arr[0][0] and *arr[0]. So how using this notation **(arr+i) get into another element of the character like arr[1][0] ? How to get the next character using this notation **(arr+i) should I add another bracket or what ? In the tutorials it wasn't mentioned ;>

Pointer that is 4 byte long ? Weird. I thought that pointers have usually 8 bytes like char * but this question is for another post

Hello !

I've choosed C language because of microcontrollers and microprocessors and some stuff from VHDL. That's why I've decided to learn it (although I am not a great programmer because I often use "if else" statements ...), I know there are also objective programming like C+ and other languages but I don't get it at all ...

Comming back to earth I think I somehow understand it ? I need sometime but I've decided to leave a comment to not abandon this question and maybe hope for reply if I comeback asking here in this post ;>

Pointers are the hardest part for me because reading them and trying to understand them sometimes makes me sick because I don't know what is pointing to what and why there are pointers that have a lot of stars "***" etc. That's why I am reading from many websites as possible.

I'm still struggeling with this char *arr example because I still don't get it how it gets the content I saw a non pointer example with string

// C Program to print Array of strings without array of pointers
#include <stdio.h>
int main()
{
    char str[3][10] = { "Geek", "Geeks", "Geekfor" };
 
    printf("String array Elements are:\n");
 
    for (int i = 0; i < 3; i++) {
        printf("%s\n", str[i]);
    }
 
    return 0;
}

but I don't get it how the %s know that he has to go through every element.

I have here a website https://www.geeksforgeeks.org/array-of-pointers-in-c/ It showed the addres of first letter and it was 2000 "g" so another letter is 2001 "f" and I guess 2002 "g" ?? ok so now another string starts poiting at 2004 which will be leter "g" 2005 "e", 2006 "e" and 2007 "k"

But there is a problem because there is a 5th row which addres is 2016 it should be "G" but the 4th row last letter as I counter is also 2016. Error ?

Also how does the array know that from typing 'geek' it will give the address ? Like in my example the *ptr had in his {} only &var which where the addresses of the variable. So how ?

Hello !

I do have a question though with this char *array. Because I still don't get it, why it is zero ending string. Ok first of all (to not mix a lot of stuff), why then the arrays is set to be a char ? Each element is 1 byte let's say the first address of char *array is 100 and moving by 1 "array + 1" then I have address 101. I guess ? So how is it possible that

printf("%s\n", arr[i]);

it will read the rest of the characters ? Because typing arr[i] I get to the address of a pointed character, how the rest of the characters are stored ? If I write *arr[i] I will get the first letter of a string not full string, if I write arr[0][1] then I think I should get the first letter and typing arr[0][2] I should get another but how do I know if another letter is one byte apart from the first letter.

The great example was also here :

<pre> int* arr[5];
    for(int i=0; i<5; i++) {
        arr[i] = (int*)malloc(sizeof(int));
        *arr[i] = i;
    }

Which if I type arr[5][1] then I should get I guess another value but there are no additional elements.

It's so messy ...

PS.

// C Program to print Array of strings without array of pointers
#include <stdio.h>
int main()
{
    char str[3][10] = { "Geek", "Geeks", "Geekfor" };
 
    printf("String array Elements are:\n");
 
    for (int i = 0; i < 3; i++) {
        printf("%s\n", str[i]);
    }
 
    return 0;
}

but I don't get it how the %s know that he has to go through every element.

I have here a website https://www.geeksforgeeks.org/array-of-pointers-in-c/ It showed the addres of first letter and it was 2000 "g" so another letter is 2001 "f" and I guess 2002 "g" ?? ok so now another string starts poiting at 2004 which will be leter "g" 2005 "e", 2006 "e" and 2007 "k"

But there is a problem because there is a 5th row which addres is 2016 it should be "G" but the 4th row last letter as I counter is also 2016. Error ?

Also how does the array know that from typing 'geek' it will give the address ? Like in my example the *ptr had in his {} only &var which where the addresses of the variable. So how ?