Pointer Help.

Hi,

So, i'm just working through pointers and I have the following very basic piece of code:

Code:

---


 char ch = 'c';
  char* pc = &ch;

  cout << pc << endl;
  cout << *pc;

---

I am expecting *pc to print out the value of ch, which it does. Also, I am expecting pc to print out the memory address, but using the console output all I see is what can best be described as heiroglyphics? Should it not be a Hex address?

Thanks.

A char* is interpreted as a C-style string. A string is an array consisting of N characters and a '\0' at the end. Clearly you don't have a string, so you gibberish instead. Whatever lies in the memory address at the point that you're printing it. You're lucky it doesn't crash.
You have to cast it to some other type to get it to work, eg:

Code:

---

cout << reinterpret_cast<int*>(pc) << endl;

---

Quote:

---

Originally Posted by Elysia

A char* is interpreted as a C-style string. A string is an array consisting of N characters and a '\0' at the end. Clearly you don't have a string, so you gibberish instead. Whatever lies in the memory address at the point that you're printing it. You're lucky it doesn't crash.
You have to cast it to some other type to get it to work, eg:

Code:

---

cout << reinterpret_cast<int*>(pc) << endl;

---

---

Cheers, i think I understand now.

Also, could you advice on this code from the book I am using. It is showing how to use pointer to create a doubly linked list and I am completely lost.

This is the struct:

Code:

---

struct Link {
                string value;
                Link* prev;
                Link* succ;
                Link(const string&v, Link* p = 0; Link*s = 0)
                        :value(v), prev(p), succ(s) {}
        };

---

I understand that the value is the name of the link, with prev and succ being pointers to the predecessor and successor link.

Now the bits I don't understand are twofold, regarding inserting into the list. The book shows two ways of doing this, a long way, followed by a function.

The long way is:

Code:

---

Link* norse_gods = new Link("tHOR", 0, 0);
        norse_gods = new Link("Odin", norse_gods, 0);
        norse_gods->succ->prev = norse_gods;
        norse_gods = new Link("Freia", norse_gods, 0);
        norse_gods->succ->prev = norse_gods;

---

And the function is:

Code:

---

Link* insert(Link*p, Link*n) //insert n before p
        {
                n->succ=p;
                p->prev->succ = n;
                n->prev=p->prev;
                p->prev = n;
                return n;
        }

---

The parts that I am completely flummoxed with, in particular, is norse_gods->succ->prev = norse_gods and also understanding how the function works?

Do you have any tips regarding this?

Thanks,

Darren.

I cannot really see the purpose of the "long" way because it's broken.
Memory leaks. Dereferencing uninitialized pointers.

But the function is straight forward.
Here's a little schematic of how things look (the first low indicates the next pointer and the second row the previous pointer):

prev --> next
prev <-- next

Now, we want to insert an element in between these. So the first thing we do is connect the new element's next pointer to the next element in the list which it will appear before (next in this example):

prev --> next
prev <-- next

new --> next
? <-- new

Now, the element before new, prev must be set to point to new with its next pointer. How do we find prev? Remember that next's prev pointer points there. So we first go next->prev to get prev in the example. Then we set the next pointer there to new, so in essence it becomes next->prev->next = new. So we get:

prev --> new --> next
prev <-- next

new --> next
? <-- new

Now we make sure that new's prev pointer points to prev. Remember again that next->prev points there, so we set new->prev = next->prev, and we get:

prev --> new --> next
prev <-- next

new --> next
prev <-- new

Finally, we set next's prev pointer to the inserted node new, and so we get:

prev --> new --> next
prev <-- new <-- next

new --> next
prev <-- new

And we're done. "next" is p in the function and "new" is n. The previous element prev is p->prev.

That's great. Thanks for taking the time.

So, if I understand correctly, where it says (in the function), p->prev->succ=n; is that saying that Link p, set its previous Link, succ pointer to n? Is that correct?

Cheers

It sets the pointer previous to p's successor to n, yes.

Great. Thanks again.

void* is the generic pointer of pointers. If you just want a memory address to display, that is the appropriate type to cast the pointer.

I disagree. void* is an evil construct inherited from C. It's dangerous and has no place in C++. At all times, you will want a variable to have a type. Only char* is a special type, but it can be cast into something else. Although usually we don't need to print the address of pointers.

This particular use of void* is completely benign. It doesn't make sense to cast to a useable pointer type just for an address.

*shrug*
I avoided it just because void* is evil.