Thread: Location of the dereference operator

Apparently this code works:

Code:

char* temp = ((ada+ind)->text);
process(ada+ind, &temp);

While this code doesn't:

Code:

char** temp = &((ada+ind)->text);
process(ada+ind, temp);

Does anyone have any idea why this is true? I made it work by changing it to the first way, but I really don't understand what is going on here.

In case anyone is curious, this is part of an assignment to write a MIPS simulator. ada is a struct that contains some primitives and char text[40].
The variable "ind" is an integer quantity. I discovered this peculiar problem when I tried to combine the two lines of code into one line and it didn't work.

The top one is taking the address of a variable called temp, allowing process to change what temp points to.
The bottom one is taking the address of the text variable at position ind in the array ada, allowing process to modify what that text variable points to. Presumably modifying that turns out to be a bad thing for your program.

These two could instead be written as:

Code:

char* temp = ada[ind].text;
process(ada+ind, &temp);

process(ada+ind, &ada[ind].text);

Which I believe more clearly hilights what each it doing.

So perhaps you should post the code of "process", since it may be important to understand what it actually does.

Also the initialization of the ada.text fields would be helpfull.

Finally, what actually happens, and how is that different from what you expect?

--
Mats

Originally Posted by merlin2011

I'm a little bit confused. My understanding is that

Code:

char* temp = ada[ind].text;

causes temp to point at the same thing text is pointing to.
Doesn't that mean I'm modifying what text is pointing to in either case?

Yes, but that's what your code always has been doing, just with a slightly different code. But nevertheless the same.

Originally Posted by Elysia

Yes, but that's what your code always has been doing, just with a slightly different code. But nevertheless the same.

I'm not quite convinced what you mean, but I'd say that "slightly different location" is a better statement than "slightly different code".

If we take the two first code-segments, and rewrite them to be more clear:

Code:

char* temp = ((ada+ind)->text);
char **ptemp = &temp;
process(ada+ind, ptemp);

ptemp points to the address of the temp variable, which holds a COPY of text. Changing *ptemp will change the value of temp, but not the value of text.

Code:

char** temp = &((ada+ind)->text);
process(ada+ind, temp);

temp points to the address of text. Modifying *temp will change the value of text.

--
Mats

Originally Posted by Elysia

This...

Code:

char* temp = ((ada+ind)->text);
process(ada+ind, &temp);

...is the same as...

Code:

char* temp = ada[ind].text;
process(ada+ind, &temp);
...which is the same as...
process(ada+ind, &ada[ind].text);

The first two are the same, yes, the third one doesn't pass the address of temp, but rather the address of text - which is different.

--
Mats

This...

Code:

char* temp = ((ada+ind)->text);
process(ada+ind, &temp);

...is the same as...

Code:

char* temp = ada[ind].text;
process(ada+ind, &temp);

Agreed.

--
Mats

Ok, so first question is why you need to pass the address of a pointer in the first place - if the code is as you describe, then you only need the address of the char array itself, not the address of an address of it.

Secondly, using & on the text field in that structure doesn't work as you'd expect it to - it still gives you the address of the char array, not the address of a pointer to it.

Code:

#include <stdio.h>

int main() 
{
  struct A
  {
    char text[100];
  } a;
  char *temp;

  temp = a.txt;
  printf("&a.text = %p, a.text = %p\n", &a.text, a.text);
  printf("&temp = %p, temp = %p\n", &temp, temp);
  return;
}

Try this on your machine, and you'll see that both are the same thing in the first line of output, but not in the second row.

--
Mats