We all know (or should know) that pointers are variables which contain
address data types. So if we have

  {
  int i=0;
  int *j=&i;
  }

the expression "i" equals "0", the expressions "&i" and "j" both equal the
address of "i", and "*j" also equals "0".

Now, how can we find out which variable whose address is contained in a
pointer. Certainly we can test the expression (&i==j), but one would have
to set up a test for every variable that might be a candidate. C would need
to have a way to find out the identifier based on the address, instead of
the address based on the identifier (an "anti-address" operator or
function, if you will). Depending on how the compiler or the platform sets
up variables for a program, perhaps there is a variable table where the
addresses of all the currently declared variables are stored, and a
function can paruse that table and find which variable is being pointed to
be a given pointer.

Maybe this is simply overcomplicating things and there really cannot be a
conceivable situation in which anything more than (&i==j) is needed, if the
programmer is good enough. Still, while I think typedef is rather useless,
I'm sure someone somewhere has put it to good use ...

--
Matthew Shelton, a.k.a. Xeno,
a.k.a. Marcus Daggersmith

Homepage: www.people.memphis.edu/~mlsheltn

Me too!
Sometimes I also desperately  need the <- operator
to find the pointer that led to the member of a struct.

and the ][ operator to find the index that led to a certain value
in an array.

And I'd like to have the name of the variable that contains the value 42.

--
Happy hacking,

Adriaan van Kessel.
Ingres DBA, C/Unix hacker

(remove NotThere. from the above address)
*** Nederlandstalige zachtwaar is een pijn in de aars ***

[snip]

Let us consider a symbolic de{*filter*}.  A pointer contains an address and
the user wants to know the variable that the pointer is pointing to.

Side note:  In an executable program, there are no variable names or
concepts of a variable.  An executable deals with memory locations and
processor registers.  Therefore I am assuming that this topic has a very
limited real-world usage domain.

The method for converting pointer address to symbol name is to search
the symbol table by address, noting also the scope of a variable.  Once
the symbol is found, then all the attributes of the symbol are known.
In a similar manner, one could create this effect by developing a table
of <variable address, symbol name> in the local scope, then searching
the table to resolve a the pointer value.  The table has to be local to
the scope of the variable, since some variables can "disappear" when
executions leaves the scope, such as variables declared inside a
function.

This implies that a symbol table exists.  The symbol table for a given
program must be created.  When a program is compilied with "debug
information", the executable file contains this information.  The format
is compiler & platform dependent.  Post to a platform specific newsgroup
for more information.

For further information, search the web for "compiler theory", and the

--
Thomas Matthews

Or what if the function was able to give you the name of the variable?
What could you do with that?

One sometimes encounters situations in which it was useful to
use a pointer as a search key to look for an object, but the
aim is not to scan all of the objects in the program's environment.

One example is that of deletion from a linked list. To delete a
node, I need to know what its predecessor is, but since the list
is singly linked, you can't use a ->prev pointer to get
to that node directly. So what you do is search
the linked list, looking for a node whose ->next field
is identical to the pointer to the node being deleted.

On Fri, 08 May 1998 09:50:04 -0600, "Thomas O. Matthews"

The question is, of what practical use, other than debugging,
would such an operation be?

It is agreed that an anti-address operator would probably have no use
outside of debugging, but there have been several situations where I was
using pointers and the results were different from predicted, and it would
be have saved a lot of time to have a hypothetical anti-address operator.
As it was, I was parsing a string to divide it into three separate strings
and the pointer was not starting at the right element for the second and
third strings.

Such an operator, which would return a pointer to a string containing the
identifier of the variable, would have told me immediately that it was
pointing to the wrong element, narrowing the scope of the bug considerably.

--
Matthew Shelton, a.k.a. Xeno,
a.k.a. Marcus Daggersmith

Homepage: www.people.memphis.edu/~mlsheltn

--
-----------------------------------------


-----------------------------------------

Regards Rainer

 > Me too!
 > Sometimes I also desperately  need the <- operator
 > to find the pointer that led to the member of a struct.
 >
 > and the ][ operator to find the index that led to a certain value
 > in an array.
 >
 > And I'd like to have the name of the variable that contains the value
42.

Do you know the algorithm that leads to 42?

 >  > And I'd like to have the name of the variable that contains the value
 > 42.
 >
 > Do you know the algorithm that leads to 42?

Yup.  6 * 9.
--
dik t. winter, cwi, kruislaan 413, 1098 sj  amsterdam, nederland, +31205924131
home: bovenover 215, 1025 jn  amsterdam, nederland; http://www.cwi.nl/~dik/

acceptable short form:
   lifeTheUniverseAndEverything

Stephan
(initiator of the campaign against grumpiness in c.l.c)

Sorry for not quoting the whole thread...

This is the funniest thread I can ever remember in this newsgroup.

I appreciate the restraint of those attempting to add grumpiness to
this newsgroup.

thanks,

-- glen

--

I believe we can change anything.
I believe in my dream.
    - Joe Satriani

--
(initiator of the campaign for grumpiness where grumpiness is due in c.l.c)

Attempting to write in a hybrid which can be compiled by either a C compiler
or a C++ compiler produces a compromise language which combines the drawbacks
of both with the advantages of neither.